EvernoteTest - Code Metrics - Inspection of "those service require a link to be provided - if n..." - foxmask/django-th - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (28ef54)

by Fox

created 2016-05-15 09:21 UTC

EvernoteTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	56
Duplicated Lines	100 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	56
loc	56
rs	10
wmc	9

How to fix Duplicated Code

# coding: utf-8
import datetime
import time

from django.test import TestCase
from django.conf import settings
from th_evernote.models import Evernote
from th_evernote.forms import EvernoteProviderForm, EvernoteConsumerForm
from django_th.tests.test_main import MainTest


class EvernoteTest(MainTest):


    """
        EvernoteTest Model
    """
    def create_evernote(self):
        trigger = self.create_triggerservice(consumer_name='ServiceEvernote')
        tag = 'test'
        notebook = 'my notebook'
        title = 'a new note'
        status = True
        return Evernote.objects.create(tag=tag, title=title,
                                       notebook=notebook, trigger=trigger,
                                       status=status)

    def test_evernote(self):
        ev = self.create_evernote()
        self.assertTrue(isinstance(ev, Evernote))
        self.assertEqual(ev.show(), "My Evernote {}".format(ev.title))
        self.assertEqual(ev.__str__(), ev.title)

    """
        Form
    """
    # provider
    def test_valid_provider_form(self):
        ev = self.create_evernote()
        data = {'tag': ev.tag, 'notebook': ev.notebook}
        form = EvernoteProviderForm(data=data)
        self.assertTrue(form.is_valid())

    def test_invalid_provider_form(self):
        form = EvernoteProviderForm(data={})
        self.assertFalse(form.is_valid())

    # consumer
    def test_valid_consumer_form(self):
        ev = self.create_evernote()
        data = {'tag': ev.tag, 'notebook': ev.notebook}
        form = EvernoteConsumerForm(data=data)
        self.assertTrue(form.is_valid())

    def test_invalid_consumer_form(self):
        form = EvernoteConsumerForm(data={})
        self.assertFalse(form.is_valid())

    def test_get_config_th(self):
        """
            does this settings exists ?
        """
        self.assertTrue(settings.TH_EVERNOTE)

    def test_get_services_list(self):
        th_service = ('th_evernote.my_evernote.ServiceEvernote',)
        for service in th_service:
            self.assertIn(service, settings.TH_SERVICES)

try:
    from unittest import mock
except ImportError:
    import mock


class ServiceEvernoteTest(TestCase):
    """
       ServiceEvernoteTest
    """
    def setUp(self):
        self.date_triggered = datetime.datetime(2013, 6, 10, 00, 00)
        self.data = {'link': 'http://foo.bar/some/thing/else/what/else',
                     'title': 'what else',
                     'content': 'foobar',
                     'summary_detail': 'summary foobar',
                     'description': 'description foobar'}
        self.token = 'AZERTY123'
        self.trigger_id = 1

    def test_process_data(self, token='AZERTY123',
                          trigger_id=1, date_triggered=''):
        token = self.token
        date_triggered = self.date_triggered
        trigger_id = self.trigger_id

        since = int(
            time.mktime(datetime.datetime.timetuple(date_triggered)))

        datas = list()
        self.assertTrue(isinstance(self.date_triggered, datetime.datetime))
        self.assertTrue(token)
        self.assertTrue(isinstance(trigger_id, int))
        self.assertTrue(isinstance(since, int))
        self.assertTrue(isinstance(datas, list))

        self.assertIn('sandbox', settings.TH_EVERNOTE)
        sandbox = settings.TH_EVERNOTE['sandbox']

        client = mock.Mock()
        client.method(token=token, sandbox=sandbox)
        client.method.assert_called_with(token=token, sandbox=sandbox)

        return datas

    def test_save_data(self, token='AZERTY123', trigger_id=1):
        token = self.token
        trigger_id = self.trigger_id

        the_return = False
        self.assertTrue(token)
        self.assertTrue(isinstance(trigger_id, int))
        self.assertIn('content', self.data)
        self.assertIn('summary_detail', self.data)
        self.assertIn('description', self.data)
        self.assertIn('title', self.data)
        self.assertIsNotNone(self.data['link'])
        self.assertNotEqual(self.data['title'], '')

        self.assertIn('sandbox', settings.TH_EVERNOTE)
        sandbox = settings.TH_EVERNOTE['sandbox']

        client = mock.Mock(return_value=True)
        client.method(token=token, sandbox=sandbox)
        client.method.assert_called_with(token=token, sandbox=sandbox)

        if client():
            the_return = True

        return the_return

    def test_get_config_th(self):
        """
            does this settings exists ?
        """
        self.assertTrue(settings.TH_EVERNOTE)
        self.assertIn('consumer_key', settings.TH_EVERNOTE)
        self.assertIn('consumer_secret', settings.TH_EVERNOTE)
        self.assertIn('sandbox', settings.TH_EVERNOTE)

    def test_get_config_th_cache(self):
        self.assertIn('th_evernote', settings.CACHES)

    def test_get_evernote_client(self, token=None):
        """
            get the token from evernote
        """
        sandbox = settings.TH_EVERNOTE['sandbox']
        client = mock.Mock(return_value=True)
        client.method(token=token, sandbox=sandbox)
        client.method.assert_called_with(token=token, sandbox=sandbox)

        sandbox = settings.TH_EVERNOTE['sandbox']
        consumer_key = settings.TH_EVERNOTE['consumer_key']
        consumer_secret = settings.TH_EVERNOTE['consumer_secret']

        client = mock.Mock(return_value=True)
        client.method(consumer_key=consumer_key,
                      consumer_secret=consumer_secret, sandbox=sandbox)
        client.method.assert_called_with(consumer_key=consumer_key,
                                         consumer_secret=consumer_secret,
                                         sandbox=sandbox)

        return client

    def test_auth(self):
        pass

    def test_callback(self):
        pass


1		# coding: utf-8
2		import datetime
3		import time
4
5		from django.test import TestCase
6		from django.conf import settings
7		from th_evernote.models import Evernote
8		from th_evernote.forms import EvernoteProviderForm, EvernoteConsumerForm
9		from django_th.tests.test_main import MainTest
10
11
12	View Code Duplication	class EvernoteTest(MainTest):
		0 ignored issues – show Duplication introduced 2016-05-02 08:27 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
13
14		"""
15		EvernoteTest Model
16		"""
17		def create_evernote(self):
18		trigger = self.create_triggerservice(consumer_name='ServiceEvernote')
19		tag = 'test'
20		notebook = 'my notebook'
21		title = 'a new note'
22		status = True
23		return Evernote.objects.create(tag=tag, title=title,
24		notebook=notebook, trigger=trigger,
25		status=status)
26
27		def test_evernote(self):
28		ev = self.create_evernote()
29		self.assertTrue(isinstance(ev, Evernote))
30		self.assertEqual(ev.show(), "My Evernote {}".format(ev.title))
31		self.assertEqual(ev.__str__(), ev.title)
32
33		"""
34		Form
35		"""
36		# provider
37		def test_valid_provider_form(self):
38		ev = self.create_evernote()
39		data = {'tag': ev.tag, 'notebook': ev.notebook}
40		form = EvernoteProviderForm(data=data)
41		self.assertTrue(form.is_valid())
42
43		def test_invalid_provider_form(self):
44		form = EvernoteProviderForm(data={})
45		self.assertFalse(form.is_valid())
46
47		# consumer
48		def test_valid_consumer_form(self):
49		ev = self.create_evernote()
50		data = {'tag': ev.tag, 'notebook': ev.notebook}
51		form = EvernoteConsumerForm(data=data)
52		self.assertTrue(form.is_valid())
53
54		def test_invalid_consumer_form(self):
55		form = EvernoteConsumerForm(data={})
56		self.assertFalse(form.is_valid())
57
58		def test_get_config_th(self):
59		"""
60		does this settings exists ?
61		"""
62		self.assertTrue(settings.TH_EVERNOTE)
63
64		def test_get_services_list(self):
65		th_service = ('th_evernote.my_evernote.ServiceEvernote',)
66		for service in th_service:
67		self.assertIn(service, settings.TH_SERVICES)
68
69		try:
70		from unittest import mock
71		except ImportError:
72		import mock
73
74
75		class ServiceEvernoteTest(TestCase):
76		"""
77		ServiceEvernoteTest
78		"""
79		def setUp(self):
80		self.date_triggered = datetime.datetime(2013, 6, 10, 00, 00)
81		self.data = {'link': 'http://foo.bar/some/thing/else/what/else',
82		'title': 'what else',
83		'content': 'foobar',
84		'summary_detail': 'summary foobar',
85		'description': 'description foobar'}
86		self.token = 'AZERTY123'
87		self.trigger_id = 1
88
89		def test_process_data(self, token='AZERTY123',
90		trigger_id=1, date_triggered=''):
91		token = self.token
92		date_triggered = self.date_triggered
93		trigger_id = self.trigger_id
94
95		since = int(
96		time.mktime(datetime.datetime.timetuple(date_triggered)))
97
98		datas = list()
99		self.assertTrue(isinstance(self.date_triggered, datetime.datetime))
100		self.assertTrue(token)
101		self.assertTrue(isinstance(trigger_id, int))
102		self.assertTrue(isinstance(since, int))
103		self.assertTrue(isinstance(datas, list))
104
105		self.assertIn('sandbox', settings.TH_EVERNOTE)
106		sandbox = settings.TH_EVERNOTE['sandbox']
107
108		client = mock.Mock()
109		client.method(token=token, sandbox=sandbox)
110		client.method.assert_called_with(token=token, sandbox=sandbox)
111
112		return datas
113
114		def test_save_data(self, token='AZERTY123', trigger_id=1):
115		token = self.token
116		trigger_id = self.trigger_id
117
118		the_return = False
119		self.assertTrue(token)
120		self.assertTrue(isinstance(trigger_id, int))
121		self.assertIn('content', self.data)
122		self.assertIn('summary_detail', self.data)
123		self.assertIn('description', self.data)
124		self.assertIn('title', self.data)
125		self.assertIsNotNone(self.data['link'])
126		self.assertNotEqual(self.data['title'], '')
127
128		self.assertIn('sandbox', settings.TH_EVERNOTE)
129		sandbox = settings.TH_EVERNOTE['sandbox']
130
131		client = mock.Mock(return_value=True)
132		client.method(token=token, sandbox=sandbox)
133		client.method.assert_called_with(token=token, sandbox=sandbox)
134
135		if client():
136		the_return = True
137
138		return the_return
139
140		def test_get_config_th(self):
141		"""
142		does this settings exists ?
143		"""
144		self.assertTrue(settings.TH_EVERNOTE)
145		self.assertIn('consumer_key', settings.TH_EVERNOTE)
146		self.assertIn('consumer_secret', settings.TH_EVERNOTE)
147		self.assertIn('sandbox', settings.TH_EVERNOTE)
148
149		def test_get_config_th_cache(self):
150		self.assertIn('th_evernote', settings.CACHES)
151
152		def test_get_evernote_client(self, token=None):
153		"""
154		get the token from evernote
155		"""
156		sandbox = settings.TH_EVERNOTE['sandbox']
157		client = mock.Mock(return_value=True)
158		client.method(token=token, sandbox=sandbox)
159		client.method.assert_called_with(token=token, sandbox=sandbox)
160
161		sandbox = settings.TH_EVERNOTE['sandbox']
162		consumer_key = settings.TH_EVERNOTE['consumer_key']
163		consumer_secret = settings.TH_EVERNOTE['consumer_secret']
164
165		client = mock.Mock(return_value=True)
166		client.method(consumer_key=consumer_key,
167		consumer_secret=consumer_secret, sandbox=sandbox)
168		client.method.assert_called_with(consumer_key=consumer_key,
169		consumer_secret=consumer_secret,
170		sandbox=sandbox)
171
172		return client
173
174		def test_auth(self):
175		pass
176
177		def test_callback(self):
178		pass
179

foxmask / django-th

Branch — master (28ef54)

EvernoteTest A

Complexity

Size/Duplication

Importance

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like