PermissionPermissionHandlersTestCase.test_has_perm_add_wihtout_obj() - Code Metrics - Inspection of "Merge pull request #61 from AmbientLighter/feature..." - lambdalisue/django-permission - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 194382...d1a5fb )

by Lambda

created 2016-07-13 02:07 UTC

test_has_perm_add_wihtout_obj() A

↳ Parent: PermissionPermissionHandlersTestCase

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	1
c	2
b	0
f	0
dl	0
loc	6
rs	9.4285

# coding=utf-8
from django.test import TestCase
from permission.handlers import PermissionHandler
from permission.handlers import LogicalPermissionHandler
from permission.tests.utils import create_user
from permission.tests.utils import create_article
from permission.tests.models import Article
from permission.tests.compat import MagicMock
from permission.tests.compat import override_settings


@override_settings(
    PERMISSION_DEFAULT_PERMISSION_HANDLER=PermissionHandler
)
class PermissionPermissionHandlersTestCase(TestCase):
    def setUp(self):
        self.handler = PermissionHandler
        self.user = create_user('john')
        self.perm1 = 'permission.add_article'
        self.perm2 = 'permission.change_article'
        self.perm3 = 'permission.delete_article'
        self.article = create_article('test')

    def test_constructor_with_model(self):
        instance = self.handler(Article)
        self.assertEqual(instance.app_label, 'permission')
        self.assertEqual(instance.model, Article)
        # backward reference
        self.assertEqual(Article._permission_handler, instance)

    def test_constructor_with_app_label(self):
        instance = self.handler('permission')
        self.assertEqual(instance.app_label, 'permission')
        self.assertEqual(instance.model, None)

    def test__get_app_perms_with_app_label(self):
        instance = self.handler('permission')
        perms = instance._get_app_perms()
        self.assertEquals(perms, set([
            'permission.add_article',
            'permission.change_article',
            'permission.delete_article',
            'permission.add_bridge',
            'permission.change_bridge',
            'permission.delete_bridge',
        ]))

    def test__get_app_perms_with_model(self):
        instance = self.handler(Article)
        perms = instance._get_app_perms()
        self.assertEquals(perms, set([
            'permission.add_article',
            'permission.change_article',
            'permission.delete_article',
            'permission.add_bridge',
            'permission.change_bridge',
            'permission.delete_bridge',
        ]))

    def test__get_model_perms(self):
        instance = self.handler(Article)
        perms = instance._get_model_perms()
        self.assertEquals(perms, set([
            'permission.add_article',
            'permission.change_article',
            'permission.delete_article',
        ]))

    def test_get_supported_permissions(self):
        instance = self.handler(Article)
        perms = instance.get_supported_permissions()
        self.assertEquals(perms, set([
            'permission.add_article',
            'permission.change_article',
            'permission.delete_article',
        ]))

    def test_get_supported_permissions_with_includes(self):
        instance = self.handler(Article)
        instance.includes = [
            'permission.add_article',
            'permission.change_article',
        ]
        perms = instance.get_supported_permissions()
        self.assertEquals(perms, set([
            'permission.add_article',
            'permission.change_article',
        ]))

    def test_get_supported_permissions_with_includes_change(self):
        instance = self.handler(Article)
        instance.includes = [
            'permission.add_article',
            'permission.change_article',
        ]
        instance.get_supported_permissions()
        instance.includes = [
            'permission.change_article',
        ]
        perms = instance.get_supported_permissions()
        self.assertEquals(perms, set([
            'permission.change_article',
        ]))

    def test_get_supported_permissions_with_excludes(self):
        instance = self.handler(Article)
        instance.excludes = [
            'permission.add_article',
        ]
        perms = instance.get_supported_permissions()
        self.assertEquals(perms, set([
            'permission.change_article',
            'permission.delete_article',
        ]))

    def test_get_supported_permissions_with_excludes_change(self):
        instance = self.handler(Article)
        instance.excludes = [
            'permission.add_article',
        ]
        instance.get_supported_permissions()
        instance.excludes = []
        perms = instance.get_supported_permissions()
        self.assertEquals(perms, set([
            'permission.add_article',
            'permission.change_article',
            'permission.delete_article',
        ]))

    def test_get_supported_app_labels(self):
        instance = self.handler(Article)
        app_labels = instance.get_supported_app_labels()
        self.assertEquals(app_labels, set([
            'permission',
        ]))

    def test_get_supported_app_labels_with_includes(self):
        instance = self.handler(Article)
        instance.includes = [
            'permission.add_article',
            'permission.change_article',
        ]
        app_labels = instance.get_supported_app_labels()
        self.assertEquals(app_labels, set([
            'permission',
        ]))

    def test_get_supported_app_labels_with_includes_change(self):
        instance = self.handler(Article)
        instance.includes = [
            'permission.add_article',
            'permission.change_article',
        ]
        instance.get_supported_app_labels()
        instance.includes = [
            'permission.change_article',
        ]
        app_labels = instance.get_supported_app_labels()
        self.assertEquals(app_labels, set([
            'permission',
        ]))

    def test_get_supported_app_labels_with_excludes(self):
        instance = self.handler(Article)
        instance.excludes = [
            'permission.add_article',
        ]
        app_labels = instance.get_supported_app_labels()
        self.assertEquals(app_labels, set([
            'permission',
        ]))

    def test_get_supported_app_labels_with_excludes_change(self):
        instance = self.handler(Article)
        instance.excludes = [
            'permission.add_article',
        ]
        instance.get_supported_app_labels()
        instance.excludes = []
        app_labels = instance.get_supported_app_labels()
        self.assertEquals(app_labels, set([
            'permission',
        ]))

    def test_has_perm_add_wihtout_obj(self):
        instance = self.handler(Article)
        self.assertRaises(
            NotImplementedError,
            instance.has_perm,
            self.user, self.perm1)

    def test_has_perm_change_wihtout_obj(self):
        instance = self.handler(Article)
        self.assertRaises(
            NotImplementedError,
            instance.has_perm,
            self.user, self.perm2)

    def test_has_perm_delete_wihtout_obj(self):
        instance = self.handler(Article)
        self.assertRaises(
            NotImplementedError,
            instance.has_perm,
            self.user, self.perm3)

    def test_has_perm_add_wiht_obj(self):
        instance = self.handler(Article)
        self.assertRaises(
            NotImplementedError,
            instance.has_perm,
            self.user, self.perm1, self.article)

    def test_has_perm_change_wiht_obj(self):
        instance = self.handler(Article)
        self.assertRaises(
            NotImplementedError,
            instance.has_perm,
            self.user, self.perm2, self.article)

    def test_has_perm_delete_wiht_obj(self):
        instance = self.handler(Article)
        self.assertRaises(
            NotImplementedError,
            instance.has_perm,
            self.user, self.perm3, self.article)

    def test_has_module_perms_success(self):
        instance = self.handler(Article)
        user = MagicMock()
        user.has_perm.return_value = True
        self.assertTrue(instance.has_module_perms(user, 'permission'))
        self.assertTrue(user.has_perm.called)

    def test_has_module_perms_fail(self):
        instance = self.handler(Article)
        user = MagicMock()
        user.has_perm.return_value = True
        self.assertFalse(instance.has_module_perms(user, 'unknown'))
        self.assertFalse(user.has_perm.called)


@override_settings(
    PERMISSION_DEFAULT_PERMISSION_HANDLER=LogicalPermissionHandler,
)
class PermissionLogicalPermissionHandlerTestCase(TestCase):
    def setUp(self):
        # make sure all caches are removed
        Article._permission_logics = set()
        self.handler = LogicalPermissionHandler
        self.user = create_user('john')
        self.perm1 = 'permission.add_article'
        self.perm2 = 'permission.change_article'
        self.perm3 = 'permission.delete_article'
        self.article = create_article('test')

        from permission.logics import PermissionLogic
        from permission import add_permission_logic
        self.mock_logic1 = MagicMock(spec=PermissionLogic)
        self.mock_logic1.has_perm = MagicMock(return_value=False)
        self.mock_logic2 = MagicMock(spec=PermissionLogic)
        self.mock_logic2.has_perm = MagicMock(return_value=False)
        add_permission_logic(Article, self.mock_logic1)
        add_permission_logic(Article, self.mock_logic2)

    def test_constructor_with_app_label(self):
        self.assertRaises(AttributeError,
                          self.handler, 'permission')

    def test_has_perm_non_related_permission(self):
        instance = self.handler(Article)
        instance.get_supported_permissions = MagicMock(return_value=[
            'permission.add_article',
            'permission.change_article',
            'permission.delete_article',
        ])
        self.assertFalse(instance.has_perm(self.user, 'unknown'))
        self.assertFalse(instance.has_perm(self.user, 'unknown', self.article))

    def test_has_perm_permission_logics_called(self):
        instance = self.handler(Article)
        instance.get_supported_permissions = MagicMock(return_value=[
            'permission.add_article',
            'permission.change_article',
            'permission.delete_article',
        ])
        self.assertFalse(self.mock_logic1.has_perm.called)
        self.assertFalse(self.mock_logic2.has_perm.called)
        self.assertFalse(instance.has_perm(self.user,
                                           'permission.add_article'))
        self.assertTrue(self.mock_logic1.has_perm.called)
        self.assertTrue(self.mock_logic2.has_perm.called)
        self.assertEqual(self.mock_logic1.has_perm.call_count, 1)
        self.assertEqual(self.mock_logic2.has_perm.call_count, 1)
        # permission check should be cached thus `has_perm` should not be
        # called twice for same user instance
        self.assertFalse(instance.has_perm(self.user,
                                           'permission.add_article'))
        self.assertEqual(self.mock_logic1.has_perm.call_count, 1)
        self.assertEqual(self.mock_logic2.has_perm.call_count, 1)


1			# coding=utf-8
2			from django.test import TestCase
3			from permission.handlers import PermissionHandler
4			from permission.handlers import LogicalPermissionHandler
5			from permission.tests.utils import create_user
6			from permission.tests.utils import create_article
7			from permission.tests.models import Article
8			from permission.tests.compat import MagicMock
9			from permission.tests.compat import override_settings
10
11
12			@override_settings(
13			PERMISSION_DEFAULT_PERMISSION_HANDLER=PermissionHandler
14			)
15			class PermissionPermissionHandlersTestCase(TestCase):
16			def setUp(self):
17			self.handler = PermissionHandler
18			self.user = create_user('john')
19			self.perm1 = 'permission.add_article'
20			self.perm2 = 'permission.change_article'
21			self.perm3 = 'permission.delete_article'
22			self.article = create_article('test')
23
24			def test_constructor_with_model(self):
25			instance = self.handler(Article)
26			self.assertEqual(instance.app_label, 'permission')
27			self.assertEqual(instance.model, Article)
28			# backward reference
29			self.assertEqual(Article._permission_handler, instance)
30
31			def test_constructor_with_app_label(self):
32			instance = self.handler('permission')
33			self.assertEqual(instance.app_label, 'permission')
34			self.assertEqual(instance.model, None)
35
36			def test__get_app_perms_with_app_label(self):
37			instance = self.handler('permission')
38			perms = instance._get_app_perms()
39			self.assertEquals(perms, set([
40			'permission.add_article',
41			'permission.change_article',
42			'permission.delete_article',
43			'permission.add_bridge',
44			'permission.change_bridge',
45			'permission.delete_bridge',
46			]))
47
48			def test__get_app_perms_with_model(self):
49			instance = self.handler(Article)
50			perms = instance._get_app_perms()
51			self.assertEquals(perms, set([
52			'permission.add_article',
53			'permission.change_article',
54			'permission.delete_article',
55			'permission.add_bridge',
56			'permission.change_bridge',
57			'permission.delete_bridge',
58			]))
59
60			def test__get_model_perms(self):
61			instance = self.handler(Article)
62			perms = instance._get_model_perms()
63			self.assertEquals(perms, set([
64			'permission.add_article',
65			'permission.change_article',
66			'permission.delete_article',
67			]))
68
69			def test_get_supported_permissions(self):
70			instance = self.handler(Article)
71			perms = instance.get_supported_permissions()
72			self.assertEquals(perms, set([
73			'permission.add_article',
74			'permission.change_article',
75			'permission.delete_article',
76			]))
77
78			def test_get_supported_permissions_with_includes(self):
79			instance = self.handler(Article)
80			instance.includes = [
81			'permission.add_article',
82			'permission.change_article',
83			]
84			perms = instance.get_supported_permissions()
85			self.assertEquals(perms, set([
86			'permission.add_article',
87			'permission.change_article',
88			]))
89
90			def test_get_supported_permissions_with_includes_change(self):
91			instance = self.handler(Article)
92			instance.includes = [
93			'permission.add_article',
94			'permission.change_article',
95			]
96			instance.get_supported_permissions()
97			instance.includes = [
98			'permission.change_article',
99			]
100			perms = instance.get_supported_permissions()
101			self.assertEquals(perms, set([
102			'permission.change_article',
103			]))
104
105			def test_get_supported_permissions_with_excludes(self):
106			instance = self.handler(Article)
107			instance.excludes = [
108			'permission.add_article',
109			]
110			perms = instance.get_supported_permissions()
111			self.assertEquals(perms, set([
112			'permission.change_article',
113			'permission.delete_article',
114			]))
115
116			def test_get_supported_permissions_with_excludes_change(self):
117			instance = self.handler(Article)
118			instance.excludes = [
119			'permission.add_article',
120			]
121			instance.get_supported_permissions()
122			instance.excludes = []
123			perms = instance.get_supported_permissions()
124			self.assertEquals(perms, set([
125			'permission.add_article',
126			'permission.change_article',
127			'permission.delete_article',
128			]))
129
130			def test_get_supported_app_labels(self):
131			instance = self.handler(Article)
132			app_labels = instance.get_supported_app_labels()
133			self.assertEquals(app_labels, set([
134			'permission',
135			]))
136
137			def test_get_supported_app_labels_with_includes(self):
138			instance = self.handler(Article)
139			instance.includes = [
140			'permission.add_article',
141			'permission.change_article',
142			]
143			app_labels = instance.get_supported_app_labels()
144			self.assertEquals(app_labels, set([
145			'permission',
146			]))
147
148			def test_get_supported_app_labels_with_includes_change(self):
149			instance = self.handler(Article)
150			instance.includes = [
151			'permission.add_article',
152			'permission.change_article',
153			]
154			instance.get_supported_app_labels()
155			instance.includes = [
156			'permission.change_article',
157			]
158			app_labels = instance.get_supported_app_labels()
159			self.assertEquals(app_labels, set([
160			'permission',
161			]))
162
163			def test_get_supported_app_labels_with_excludes(self):
164			instance = self.handler(Article)
165			instance.excludes = [
166			'permission.add_article',
167			]
168			app_labels = instance.get_supported_app_labels()
169			self.assertEquals(app_labels, set([
170			'permission',
171			]))
172
173			def test_get_supported_app_labels_with_excludes_change(self):
174			instance = self.handler(Article)
175			instance.excludes = [
176			'permission.add_article',
177			]
178			instance.get_supported_app_labels()
179			instance.excludes = []
180			app_labels = instance.get_supported_app_labels()
181			self.assertEquals(app_labels, set([
182			'permission',
183			]))
184
185			def test_has_perm_add_wihtout_obj(self):
186			instance = self.handler(Article)
187			self.assertRaises(
188			NotImplementedError,
189			instance.has_perm,
190			self.user, self.perm1)
191
192			def test_has_perm_change_wihtout_obj(self):
193			instance = self.handler(Article)
194			self.assertRaises(
195			NotImplementedError,
196			instance.has_perm,
197			self.user, self.perm2)
198
199			def test_has_perm_delete_wihtout_obj(self):
200			instance = self.handler(Article)
201			self.assertRaises(
202			NotImplementedError,
203			instance.has_perm,
204			self.user, self.perm3)
205
206			def test_has_perm_add_wiht_obj(self):
207			instance = self.handler(Article)
208			self.assertRaises(
209			NotImplementedError,
210			instance.has_perm,
211			self.user, self.perm1, self.article)
212
213			def test_has_perm_change_wiht_obj(self):
214			instance = self.handler(Article)
215			self.assertRaises(
216			NotImplementedError,
217			instance.has_perm,
218			self.user, self.perm2, self.article)
219
220			def test_has_perm_delete_wiht_obj(self):
221			instance = self.handler(Article)
222			self.assertRaises(
223			NotImplementedError,
224			instance.has_perm,
225			self.user, self.perm3, self.article)
226
227			def test_has_module_perms_success(self):
228			instance = self.handler(Article)
229			user = MagicMock()
230			user.has_perm.return_value = True
231			self.assertTrue(instance.has_module_perms(user, 'permission'))
232			self.assertTrue(user.has_perm.called)
233
234			def test_has_module_perms_fail(self):
235			instance = self.handler(Article)
236			user = MagicMock()
237			user.has_perm.return_value = True
238			self.assertFalse(instance.has_module_perms(user, 'unknown'))
239			self.assertFalse(user.has_perm.called)
240
241
242			@override_settings(
243			PERMISSION_DEFAULT_PERMISSION_HANDLER=LogicalPermissionHandler,
244			)
245			class PermissionLogicalPermissionHandlerTestCase(TestCase):
246			def setUp(self):
247			# make sure all caches are removed
248			Article._permission_logics = set()
249			self.handler = LogicalPermissionHandler
250			self.user = create_user('john')
251			self.perm1 = 'permission.add_article'
252			self.perm2 = 'permission.change_article'
253			self.perm3 = 'permission.delete_article'
254			self.article = create_article('test')
255
256			from permission.logics import PermissionLogic
257			from permission import add_permission_logic
258			self.mock_logic1 = MagicMock(spec=PermissionLogic)
259			self.mock_logic1.has_perm = MagicMock(return_value=False)
260			self.mock_logic2 = MagicMock(spec=PermissionLogic)
261			self.mock_logic2.has_perm = MagicMock(return_value=False)
262			add_permission_logic(Article, self.mock_logic1)
263			add_permission_logic(Article, self.mock_logic2)
264
265			def test_constructor_with_app_label(self):
266			self.assertRaises(AttributeError,
267			self.handler, 'permission')
268
269			def test_has_perm_non_related_permission(self):
270			instance = self.handler(Article)
271			instance.get_supported_permissions = MagicMock(return_value=[
272			'permission.add_article',
273			'permission.change_article',
274			'permission.delete_article',
275			])
276			self.assertFalse(instance.has_perm(self.user, 'unknown'))
277			self.assertFalse(instance.has_perm(self.user, 'unknown', self.article))
278
279			def test_has_perm_permission_logics_called(self):
280			instance = self.handler(Article)
281			instance.get_supported_permissions = MagicMock(return_value=[
282			'permission.add_article',
283			'permission.change_article',
284			'permission.delete_article',
285			])
286			self.assertFalse(self.mock_logic1.has_perm.called)
287			self.assertFalse(self.mock_logic2.has_perm.called)
288			self.assertFalse(instance.has_perm(self.user,
289			'permission.add_article'))
290			self.assertTrue(self.mock_logic1.has_perm.called)
291			self.assertTrue(self.mock_logic2.has_perm.called)
292			self.assertEqual(self.mock_logic1.has_perm.call_count, 1)
293			self.assertEqual(self.mock_logic2.has_perm.call_count, 1)
294			# permission check should be cached thus `has_perm` should not be
295			# called twice for same user instance
296			self.assertFalse(instance.has_perm(self.user,
297			'permission.add_article'))
298			self.assertEqual(self.mock_logic1.has_perm.call_count, 1)
299			self.assertEqual(self.mock_logic2.has_perm.call_count, 1)
300

lambdalisue / django-permission

GitHub Access Token became invalid

Push — master ( 194382...d1a5fb )

test_has_perm_add_wihtout_obj() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like