Test2 - Code Metrics - Inspection of "Explicitly test some multiple inheritance." - mwchase/class-namespaces - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e9d347...6f0922 )

by Max

created 2016-11-21 00:18 UTC

Test2 A

↳ Parent: test_multiple_inheritance()

Complexity

Total Complexity

Size/Duplication

Total Lines	3
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	3
rs	10
wmc	1

import sys

import pytest


def test_import(namespaces):
    assert namespaces


def test_meta_basic(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        pass
    assert Test


def test_basic_namespace(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            a = 1
        assert ns
    assert Test
    assert Test().ns


def test_delete(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            a = 1
            del a
            b = 2
        assert ns
    assert Test
    assert Test().ns
    assert Test.ns.b == 2
    assert Test().ns.b == 2
    with pytest.raises(AttributeError):
        del Test().ns.b
    del Test.ns.b
    with pytest.raises(AttributeError):
        Test.ns.b
    with pytest.raises(AttributeError):
        Test().ns.b


def test_set(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            a = 1
            del a
        assert ns
    assert Test
    assert Test().ns
    Test.ns.b = 2
    assert Test.ns.b == 2
    assert Test().ns.b == 2
    test = Test()
    test.ns.b = 3
    assert Test.ns.b == 2
    assert test.ns.b == 3
    test2 = Test()
    test2.ns.c = 3
    with pytest.raises(AttributeError):
        Test.ns.c
    with pytest.raises(AttributeError):
        test.ns.c
    assert test2.ns.c == 3


@pytest.mark.xfail(sys.version_info < (3, 4),
                   reason="python3.4 api changes?", strict=True)
def test_dir(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            a = 1
        assert ns
    assert dir(Test.ns) == ['a']
    assert dir(Test().ns) == ['a']


def test_shadow(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        foo = 1
        with namespaces.Namespace() as ns:
            foo = 2
            assert foo == 2
        assert foo == 1
    assert Test().foo == 1
    assert Test().ns.foo == 2


def test_resume(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        foo = 1
        with namespaces.Namespace() as ns:
            foo = 2
            assert foo == 2
        foo = 3
        with ns:
            foo = 4
        assert foo == 3
    assert Test().foo == 3
    assert Test().ns.foo == 4


def test_redundant_resume(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        foo = 1
        with namespaces.Namespace() as ns:
            foo = 2
            assert foo == 2
        foo = 3
        ns = ns
        with ns as ns:
            foo = 4
        assert foo == 3
    assert Test().foo == 3
    assert Test().ns.foo == 4


def test_basic_inherit(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        foo = 1
        with namespaces.Namespace() as ns:
            foo = 2

    class Subclass(Test):
        pass
    assert Subclass().foo == 1
    assert Subclass().ns.foo == 2


def test_basic_super(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            def hello(self):
                return 1

    class Subclass(Test):
        with namespaces.Namespace() as ns:
            def hello(self):
                return super().ns.hello()

    assert Test().ns.hello() == 1
    assert Subclass().ns.hello() == 1


def test_private(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as __ns:
            foo = 2

        def foo(self):
            return self.__ns.foo

    class Subclass(Test):
        pass

    assert Test().foo() == 2
    assert Subclass().foo() == 2


def test_nested_namespace(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            with namespaces.Namespace() as ns:
                a = 1
    assert Test().ns.ns.a == 1


def test_basic_shadow(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            foo = 2

    class Subclass(Test):
        ns = 1
    assert Subclass().ns == 1


def test_double_shadow(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            foo = 2

    class Subclass(Test):
        ns = 1

    class DoubleSubclass(Subclass):
        with namespaces.Namespace() as ns:
            bar = 1
    assert not hasattr(DoubleSubclass().ns, 'foo')


def test_overlap(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            foo = 2

    class Subclass(Test):
        with namespaces.Namespace() as ns:
            bar = 3
    assert Subclass().ns.foo == 2
    assert Subclass().ns.bar == 3


def test_advanced_overlap(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            foo = 2
            with namespaces.Namespace() as ns:
                qux = 4

    class Subclass(Test):
        with namespaces.Namespace() as ns:
            bar = 3
    assert Subclass().ns.foo == 2
    assert Subclass().ns.bar == 3
    assert Subclass().ns.ns.qux == 4


def test_empty_nameless(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with pytest.raises(RuntimeError):
            with namespaces.Namespace():
                pass


def test_non_empty_nameless(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with pytest.raises(RuntimeError):
            with namespaces.Namespace():
                a = 1


def test_rename(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            pass
        with pytest.raises(ValueError):
            with ns as ns2:
                pass


def test_use_namespace(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            foo = 1
            qux = 3
        assert ns.foo == 1
        ns.bar = 2
        assert ns.bar == 2
        del ns.qux
        with pytest.raises(AttributeError):
            del ns.qux
    assert Test.ns.foo == 1
    assert Test.ns.bar == 2


def test_basic_prop(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            @property
            def foo(self):
                return 1
    assert Test().ns.foo == 1


def test_override_method(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            def foo(self):
                return 1
    test = Test()
    assert test.ns.foo() == 1
    test.ns.foo = 2
    print(vars(test))
    assert test.ns.foo == 2
    del test.ns.foo
    assert test.ns.foo() == 1
    Test.ns.foo = 3
    assert Test.ns.foo == 3
    assert test.ns.foo == 3


def test_can_t_preload_with_namespace(namespaces):
    with pytest.raises(ValueError):
        namespaces.Namespace(ns=namespaces.Namespace())


def test_add_later(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        pass

    Test.ns = namespaces.Namespace()
    Test.ns.ns = namespaces.Namespace()
    Test.ns.value = 1
    Test.ns.ns.value = 2
    assert Test.ns.value == 1
    assert Test.ns.ns.value == 2


@pytest.mark.xfail(sys.version_info < (3, 6),
                   reason="python3.6 api changes", strict=True)
def test_3_6_descriptor(namespaces):
    class Descriptor:
        def __set_name__(self, owner, name):
            self.owner = owner
            self.name = name
    assert namespaces.namespaces._DescriptorInspector(
        Descriptor()).is_descriptor

    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            d = Descriptor()

    assert Test.ns.d.name == 'd'


def test_basic_meta(namespaces):
    class Meta(type, metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            meta_var = 1

    class Test(metaclass=Meta):
        pass

    assert Meta.ns.meta_var == 1
    assert Test.ns.meta_var == 1


def test_somewhat_weird_meta(namespaces):
    class Meta(namespaces.Namespaceable, metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            meta_var = 1

    class Test(metaclass=Meta):
        pass

    assert Meta.ns.meta_var == 1
    assert Test.ns.meta_var == 1
    with pytest.raises(AttributeError):
        Test().ns.meta_var


def test_somewhat_weirder_meta(namespaces):
    class Meta(namespaces.Namespaceable, metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            meta_var = 1

    class Test(metaclass=Meta):
        with namespaces.Namespace() as ns:
            cls_var = 2

    assert Meta.ns.meta_var == 1
    assert Test.ns.meta_var == 1
    assert Test.ns.cls_var == 2
    assert Test().ns.cls_var == 2
    with pytest.raises(AttributeError):
        Test().ns.meta_var
    with pytest.raises(AttributeError):
        Test.ns.var
    with pytest.raises(AttributeError):
        Meta.ns.cls_var
    Test.var = 3
    assert Test.var == 3
    Meta.var = 4
    assert Meta.var == 4


def test_classmethod_basic(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            @classmethod
            def cls_mthd(cls):
                return 'called'

    assert Test.ns.cls_mthd() == 'called'
    assert Test().ns.cls_mthd() == 'called'


def test_meta_plus_classmethod(namespaces):
    class Meta(namespaces.Namespaceable, metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            pass

    class Test(metaclass=Meta):
        with namespaces.Namespace() as ns:
            @classmethod
            def cls_mthd(cls):
                return 'called'

    assert Test().ns.cls_mthd() == 'called'
    assert Test.ns.cls_mthd() == 'called'


def test_get_through_namespace(namespaces):
    class Test(metaclass=namespaces.Namespaceable):
        var = 1
        with namespaces.Namespace() as ns:
            var2 = var

    assert Test.var == 1
    assert Test.ns.var2 == 1


def test_multiple_inheritance(namespaces):
    class Test1(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            with namespaces.Namespace() as ns:
                var = 1

    class Test2(metaclass=namespaces.Namespaceable):
        with namespaces.Namespace() as ns:
            var = 2

    class Test3(Test2, Test1):
        pass

    assert Test3.ns.ns.var == 1
    assert Test3.ns.var == 2


1			import sys
2
3			import pytest
4
5
6			def test_import(namespaces):
7			assert namespaces
8
9
10			def test_meta_basic(namespaces):
11			class Test(metaclass=namespaces.Namespaceable):
12			pass
13			assert Test
14
15
16			def test_basic_namespace(namespaces):
17			class Test(metaclass=namespaces.Namespaceable):
18			with namespaces.Namespace() as ns:
19			a = 1
20			assert ns
21			assert Test
22			assert Test().ns
23
24
25			def test_delete(namespaces):
26			class Test(metaclass=namespaces.Namespaceable):
27			with namespaces.Namespace() as ns:
28			a = 1
29			del a
30			b = 2
31			assert ns
32			assert Test
33			assert Test().ns
34			assert Test.ns.b == 2
35			assert Test().ns.b == 2
36			with pytest.raises(AttributeError):
37			del Test().ns.b
38			del Test.ns.b
39			with pytest.raises(AttributeError):
40			Test.ns.b
41			with pytest.raises(AttributeError):
42			Test().ns.b
43
44
45			def test_set(namespaces):
46			class Test(metaclass=namespaces.Namespaceable):
47			with namespaces.Namespace() as ns:
48			a = 1
49			del a
50			assert ns
51			assert Test
52			assert Test().ns
53			Test.ns.b = 2
54			assert Test.ns.b == 2
55			assert Test().ns.b == 2
56			test = Test()
57			test.ns.b = 3
58			assert Test.ns.b == 2
59			assert test.ns.b == 3
60			test2 = Test()
61			test2.ns.c = 3
62			with pytest.raises(AttributeError):
63			Test.ns.c
64			with pytest.raises(AttributeError):
65			test.ns.c
66			assert test2.ns.c == 3
67
68
69			@pytest.mark.xfail(sys.version_info < (3, 4),
70			reason="python3.4 api changes?", strict=True)
71			def test_dir(namespaces):
72			class Test(metaclass=namespaces.Namespaceable):
73			with namespaces.Namespace() as ns:
74			a = 1
75			assert ns
76			assert dir(Test.ns) == ['a']
77			assert dir(Test().ns) == ['a']
78
79
80			def test_shadow(namespaces):
81			class Test(metaclass=namespaces.Namespaceable):
82			foo = 1
83			with namespaces.Namespace() as ns:
84			foo = 2
85			assert foo == 2
86			assert foo == 1
87			assert Test().foo == 1
88			assert Test().ns.foo == 2
89
90
91			def test_resume(namespaces):
92			class Test(metaclass=namespaces.Namespaceable):
93			foo = 1
94			with namespaces.Namespace() as ns:
95			foo = 2
96			assert foo == 2
97			foo = 3
98			with ns:
99			foo = 4
100			assert foo == 3
101			assert Test().foo == 3
102			assert Test().ns.foo == 4
103
104
105			def test_redundant_resume(namespaces):
106			class Test(metaclass=namespaces.Namespaceable):
107			foo = 1
108			with namespaces.Namespace() as ns:
109			foo = 2
110			assert foo == 2
111			foo = 3
112			ns = ns
113			with ns as ns:
114			foo = 4
115			assert foo == 3
116			assert Test().foo == 3
117			assert Test().ns.foo == 4
118
119
120			def test_basic_inherit(namespaces):
121			class Test(metaclass=namespaces.Namespaceable):
122			foo = 1
123			with namespaces.Namespace() as ns:
124			foo = 2
125
126			class Subclass(Test):
127			pass
128			assert Subclass().foo == 1
129			assert Subclass().ns.foo == 2
130
131
132			def test_basic_super(namespaces):
133			class Test(metaclass=namespaces.Namespaceable):
134			with namespaces.Namespace() as ns:
135			def hello(self):
136			return 1
137
138			class Subclass(Test):
139			with namespaces.Namespace() as ns:
140			def hello(self):
141			return super().ns.hello()
142
143			assert Test().ns.hello() == 1
144			assert Subclass().ns.hello() == 1
145
146
147			def test_private(namespaces):
148			class Test(metaclass=namespaces.Namespaceable):
149			with namespaces.Namespace() as __ns:
150			foo = 2
151
152			def foo(self):
153			return self.__ns.foo
154
155			class Subclass(Test):
156			pass
157
158			assert Test().foo() == 2
159			assert Subclass().foo() == 2
160
161
162			def test_nested_namespace(namespaces):
163			class Test(metaclass=namespaces.Namespaceable):
164			with namespaces.Namespace() as ns:
165			with namespaces.Namespace() as ns:
166			a = 1
167			assert Test().ns.ns.a == 1
168
169
170			def test_basic_shadow(namespaces):
171			class Test(metaclass=namespaces.Namespaceable):
172			with namespaces.Namespace() as ns:
173			foo = 2
174
175			class Subclass(Test):
176			ns = 1
177			assert Subclass().ns == 1
178
179
180			def test_double_shadow(namespaces):
181			class Test(metaclass=namespaces.Namespaceable):
182			with namespaces.Namespace() as ns:
183			foo = 2
184
185			class Subclass(Test):
186			ns = 1
187
188			class DoubleSubclass(Subclass):
189			with namespaces.Namespace() as ns:
190			bar = 1
191			assert not hasattr(DoubleSubclass().ns, 'foo')
192
193
194			def test_overlap(namespaces):
195			class Test(metaclass=namespaces.Namespaceable):
196			with namespaces.Namespace() as ns:
197			foo = 2
198
199			class Subclass(Test):
200			with namespaces.Namespace() as ns:
201			bar = 3
202			assert Subclass().ns.foo == 2
203			assert Subclass().ns.bar == 3
204
205
206			def test_advanced_overlap(namespaces):
207			class Test(metaclass=namespaces.Namespaceable):
208			with namespaces.Namespace() as ns:
209			foo = 2
210			with namespaces.Namespace() as ns:
211			qux = 4
212
213			class Subclass(Test):
214			with namespaces.Namespace() as ns:
215			bar = 3
216			assert Subclass().ns.foo == 2
217			assert Subclass().ns.bar == 3
218			assert Subclass().ns.ns.qux == 4
219
220
221			def test_empty_nameless(namespaces):
222			class Test(metaclass=namespaces.Namespaceable):
223			with pytest.raises(RuntimeError):
224			with namespaces.Namespace():
225			pass
226
227
228			def test_non_empty_nameless(namespaces):
229			class Test(metaclass=namespaces.Namespaceable):
230			with pytest.raises(RuntimeError):
231			with namespaces.Namespace():
232			a = 1
233
234
235			def test_rename(namespaces):
236			class Test(metaclass=namespaces.Namespaceable):
237			with namespaces.Namespace() as ns:
238			pass
239			with pytest.raises(ValueError):
240			with ns as ns2:
241			pass
242
243
244			def test_use_namespace(namespaces):
245			class Test(metaclass=namespaces.Namespaceable):
246			with namespaces.Namespace() as ns:
247			foo = 1
248			qux = 3
249			assert ns.foo == 1
250			ns.bar = 2
251			assert ns.bar == 2
252			del ns.qux
253			with pytest.raises(AttributeError):
254			del ns.qux
255			assert Test.ns.foo == 1
256			assert Test.ns.bar == 2
257
258
259			def test_basic_prop(namespaces):
260			class Test(metaclass=namespaces.Namespaceable):
261			with namespaces.Namespace() as ns:
262			@property
263			def foo(self):
264			return 1
265			assert Test().ns.foo == 1
266
267
268			def test_override_method(namespaces):
269			class Test(metaclass=namespaces.Namespaceable):
270			with namespaces.Namespace() as ns:
271			def foo(self):
272			return 1
273			test = Test()
274			assert test.ns.foo() == 1
275			test.ns.foo = 2
276			print(vars(test))
277			assert test.ns.foo == 2
278			del test.ns.foo
279			assert test.ns.foo() == 1
280			Test.ns.foo = 3
281			assert Test.ns.foo == 3
282			assert test.ns.foo == 3
283
284
285			def test_can_t_preload_with_namespace(namespaces):
286			with pytest.raises(ValueError):
287			namespaces.Namespace(ns=namespaces.Namespace())
288
289
290			def test_add_later(namespaces):
291			class Test(metaclass=namespaces.Namespaceable):
292			pass
293
294			Test.ns = namespaces.Namespace()
295			Test.ns.ns = namespaces.Namespace()
296			Test.ns.value = 1
297			Test.ns.ns.value = 2
298			assert Test.ns.value == 1
299			assert Test.ns.ns.value == 2
300
301
302			@pytest.mark.xfail(sys.version_info < (3, 6),
303			reason="python3.6 api changes", strict=True)
304			def test_3_6_descriptor(namespaces):
305			class Descriptor:
306			def __set_name__(self, owner, name):
307			self.owner = owner
308			self.name = name
309			assert namespaces.namespaces._DescriptorInspector(
310			Descriptor()).is_descriptor
311
312			class Test(metaclass=namespaces.Namespaceable):
313			with namespaces.Namespace() as ns:
314			d = Descriptor()
315
316			assert Test.ns.d.name == 'd'
317
318
319			def test_basic_meta(namespaces):
320			class Meta(type, metaclass=namespaces.Namespaceable):
321			with namespaces.Namespace() as ns:
322			meta_var = 1
323
324			class Test(metaclass=Meta):
325			pass
326
327			assert Meta.ns.meta_var == 1
328			assert Test.ns.meta_var == 1
329
330
331			def test_somewhat_weird_meta(namespaces):
332			class Meta(namespaces.Namespaceable, metaclass=namespaces.Namespaceable):
333			with namespaces.Namespace() as ns:
334			meta_var = 1
335
336			class Test(metaclass=Meta):
337			pass
338
339			assert Meta.ns.meta_var == 1
340			assert Test.ns.meta_var == 1
341			with pytest.raises(AttributeError):
342			Test().ns.meta_var
343
344
345			def test_somewhat_weirder_meta(namespaces):
346			class Meta(namespaces.Namespaceable, metaclass=namespaces.Namespaceable):
347			with namespaces.Namespace() as ns:
348			meta_var = 1
349
350			class Test(metaclass=Meta):
351			with namespaces.Namespace() as ns:
352			cls_var = 2
353
354			assert Meta.ns.meta_var == 1
355			assert Test.ns.meta_var == 1
356			assert Test.ns.cls_var == 2
357			assert Test().ns.cls_var == 2
358			with pytest.raises(AttributeError):
359			Test().ns.meta_var
360			with pytest.raises(AttributeError):
361			Test.ns.var
362			with pytest.raises(AttributeError):
363			Meta.ns.cls_var
364			Test.var = 3
365			assert Test.var == 3
366			Meta.var = 4
367			assert Meta.var == 4
368
369
370			def test_classmethod_basic(namespaces):
371			class Test(metaclass=namespaces.Namespaceable):
372			with namespaces.Namespace() as ns:
373			@classmethod
374			def cls_mthd(cls):
375			return 'called'
376
377			assert Test.ns.cls_mthd() == 'called'
378			assert Test().ns.cls_mthd() == 'called'
379
380
381			def test_meta_plus_classmethod(namespaces):
382			class Meta(namespaces.Namespaceable, metaclass=namespaces.Namespaceable):
383			with namespaces.Namespace() as ns:
384			pass
385
386			class Test(metaclass=Meta):
387			with namespaces.Namespace() as ns:
388			@classmethod
389			def cls_mthd(cls):
390			return 'called'
391
392			assert Test().ns.cls_mthd() == 'called'
393			assert Test.ns.cls_mthd() == 'called'
394
395
396			def test_get_through_namespace(namespaces):
397			class Test(metaclass=namespaces.Namespaceable):
398			var = 1
399			with namespaces.Namespace() as ns:
400			var2 = var
401
402			assert Test.var == 1
403			assert Test.ns.var2 == 1
404
405
406			def test_multiple_inheritance(namespaces):
407			class Test1(metaclass=namespaces.Namespaceable):
408			with namespaces.Namespace() as ns:
409			with namespaces.Namespace() as ns:
410			var = 1
411
412			class Test2(metaclass=namespaces.Namespaceable):
413			with namespaces.Namespace() as ns:
414			var = 2
415
416			class Test3(Test2, Test1):
417			pass
418
419			assert Test3.ns.ns.var == 1
420			assert Test3.ns.var == 2
421

mwchase / class-namespaces

Push — master ( e9d347...6f0922 )

Test2 A

Complexity

Size/Duplication

Importance

Duplication Side-by-Side

Filter issues like