test_set() - Code Metrics - Inspection of "Expand set coverage." - mwchase/class-namespaces - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 440d09...1286dd )

by Max

created 2016-11-20 06:03 UTC

test_set() B

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	7
c	1
b	0
f	0
dl	0
loc	15
rs	7.3333

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


@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
        assert ns.foo == 1
        ns.bar = 2
        assert ns.bar == 2
    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


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
61
62			@pytest.mark.xfail(sys.version_info < (3, 4),
63			reason="python3.4 api changes?", strict=True)
64			def test_dir(namespaces):
65			class Test(metaclass=namespaces.Namespaceable):
66			with namespaces.Namespace() as ns:
67			a = 1
68			assert ns
69			assert dir(Test.ns) == ['a']
70			assert dir(Test().ns) == ['a']
71
72
73			def test_shadow(namespaces):
74			class Test(metaclass=namespaces.Namespaceable):
75			foo = 1
76			with namespaces.Namespace() as ns:
77			foo = 2
78			assert foo == 2
79			assert foo == 1
80			assert Test().foo == 1
81			assert Test().ns.foo == 2
82
83
84			def test_resume(namespaces):
85			class Test(metaclass=namespaces.Namespaceable):
86			foo = 1
87			with namespaces.Namespace() as ns:
88			foo = 2
89			assert foo == 2
90			foo = 3
91			with ns:
92			foo = 4
93			assert foo == 3
94			assert Test().foo == 3
95			assert Test().ns.foo == 4
96
97
98			def test_redundant_resume(namespaces):
99			class Test(metaclass=namespaces.Namespaceable):
100			foo = 1
101			with namespaces.Namespace() as ns:
102			foo = 2
103			assert foo == 2
104			foo = 3
105			ns = ns
106			with ns as ns:
107			foo = 4
108			assert foo == 3
109			assert Test().foo == 3
110			assert Test().ns.foo == 4
111
112
113			def test_basic_inherit(namespaces):
114			class Test(metaclass=namespaces.Namespaceable):
115			foo = 1
116			with namespaces.Namespace() as ns:
117			foo = 2
118
119			class Subclass(Test):
120			pass
121			assert Subclass().foo == 1
122			assert Subclass().ns.foo == 2
123
124
125			def test_basic_super(namespaces):
126			class Test(metaclass=namespaces.Namespaceable):
127			with namespaces.Namespace() as ns:
128			def hello(self):
129			return 1
130
131			class Subclass(Test):
132			with namespaces.Namespace() as ns:
133			def hello(self):
134			return super().ns.hello()
135
136			assert Test().ns.hello() == 1
137			assert Subclass().ns.hello() == 1
138
139
140			def test_private(namespaces):
141			class Test(metaclass=namespaces.Namespaceable):
142			with namespaces.Namespace() as __ns:
143			foo = 2
144
145			def foo(self):
146			return self.__ns.foo
147
148			class Subclass(Test):
149			pass
150
151			assert Test().foo() == 2
152			assert Subclass().foo() == 2
153
154
155			def test_nested_namespace(namespaces):
156			class Test(metaclass=namespaces.Namespaceable):
157			with namespaces.Namespace() as ns:
158			with namespaces.Namespace() as ns:
159			a = 1
160			assert Test().ns.ns.a == 1
161
162
163			def test_basic_shadow(namespaces):
164			class Test(metaclass=namespaces.Namespaceable):
165			with namespaces.Namespace() as ns:
166			foo = 2
167
168			class Subclass(Test):
169			ns = 1
170			assert Subclass().ns == 1
171
172
173			def test_double_shadow(namespaces):
174			class Test(metaclass=namespaces.Namespaceable):
175			with namespaces.Namespace() as ns:
176			foo = 2
177
178			class Subclass(Test):
179			ns = 1
180
181			class DoubleSubclass(Subclass):
182			with namespaces.Namespace() as ns:
183			bar = 1
184			assert not hasattr(DoubleSubclass().ns, 'foo')
185
186
187			def test_overlap(namespaces):
188			class Test(metaclass=namespaces.Namespaceable):
189			with namespaces.Namespace() as ns:
190			foo = 2
191
192			class Subclass(Test):
193			with namespaces.Namespace() as ns:
194			bar = 3
195			assert Subclass().ns.foo == 2
196			assert Subclass().ns.bar == 3
197
198
199			def test_advanced_overlap(namespaces):
200			class Test(metaclass=namespaces.Namespaceable):
201			with namespaces.Namespace() as ns:
202			foo = 2
203			with namespaces.Namespace() as ns:
204			qux = 4
205
206			class Subclass(Test):
207			with namespaces.Namespace() as ns:
208			bar = 3
209			assert Subclass().ns.foo == 2
210			assert Subclass().ns.bar == 3
211			assert Subclass().ns.ns.qux == 4
212
213
214			def test_empty_nameless(namespaces):
215			class Test(metaclass=namespaces.Namespaceable):
216			with pytest.raises(RuntimeError):
217			with namespaces.Namespace():
218			pass
219
220
221			def test_non_empty_nameless(namespaces):
222			class Test(metaclass=namespaces.Namespaceable):
223			with pytest.raises(RuntimeError):
224			with namespaces.Namespace():
225			a = 1
226
227
228			def test_rename(namespaces):
229			class Test(metaclass=namespaces.Namespaceable):
230			with namespaces.Namespace() as ns:
231			pass
232			with pytest.raises(ValueError):
233			with ns as ns2:
234			pass
235
236
237			def test_use_namespace(namespaces):
238			class Test(metaclass=namespaces.Namespaceable):
239			with namespaces.Namespace() as ns:
240			foo = 1
241			assert ns.foo == 1
242			ns.bar = 2
243			assert ns.bar == 2
244			assert Test.ns.foo == 1
245			assert Test.ns.bar == 2
246
247
248			def test_basic_prop(namespaces):
249			class Test(metaclass=namespaces.Namespaceable):
250			with namespaces.Namespace() as ns:
251			@property
252			def foo(self):
253			return 1
254			assert Test().ns.foo == 1
255
256
257			def test_override_method(namespaces):
258			class Test(metaclass=namespaces.Namespaceable):
259			with namespaces.Namespace() as ns:
260			def foo(self):
261			return 1
262			test = Test()
263			assert test.ns.foo() == 1
264			test.ns.foo = 2
265			print(vars(test))
266			assert test.ns.foo == 2
267			del test.ns.foo
268			assert test.ns.foo() == 1
269			Test.ns.foo = 3
270			assert Test.ns.foo == 3
271			assert test.ns.foo == 3
272
273
274			def test_can_t_preload_with_namespace(namespaces):
275			with pytest.raises(ValueError):
276			namespaces.Namespace(ns=namespaces.Namespace())
277
278
279			def test_add_later(namespaces):
280			class Test(metaclass=namespaces.Namespaceable):
281			pass
282
283			Test.ns = namespaces.Namespace()
284			Test.ns.ns = namespaces.Namespace()
285			Test.ns.value = 1
286			Test.ns.ns.value = 2
287			assert Test.ns.value == 1
288			assert Test.ns.ns.value == 2
289
290
291			@pytest.mark.xfail(sys.version_info < (3, 6),
292			reason="python3.6 api changes", strict=True)
293			def test_3_6_descriptor(namespaces):
294			class Descriptor:
295			def __set_name__(self, owner, name):
296			self.owner = owner
297			self.name = name
298			assert namespaces.namespaces._DescriptorInspector(
299			Descriptor()).is_descriptor
300
301			class Test(metaclass=namespaces.Namespaceable):
302			with namespaces.Namespace() as ns:
303			d = Descriptor()
304
305			assert Test.ns.d.name == 'd'
306
307
308			def test_basic_meta(namespaces):
309			class Meta(type, metaclass=namespaces.Namespaceable):
310			with namespaces.Namespace() as ns:
311			meta_var = 1
312
313			class Test(metaclass=Meta):
314			pass
315
316			assert Meta.ns.meta_var == 1
317			assert Test.ns.meta_var == 1
318
319
320			def test_somewhat_weird_meta(namespaces):
321			class Meta(namespaces.Namespaceable, metaclass=namespaces.Namespaceable):
322			with namespaces.Namespace() as ns:
323			meta_var = 1
324
325			class Test(metaclass=Meta):
326			pass
327
328			assert Meta.ns.meta_var == 1
329			assert Test.ns.meta_var == 1
330			with pytest.raises(AttributeError):
331			Test().ns.meta_var
332
333
334			def test_somewhat_weirder_meta(namespaces):
335			class Meta(namespaces.Namespaceable, metaclass=namespaces.Namespaceable):
336			with namespaces.Namespace() as ns:
337			meta_var = 1
338
339			class Test(metaclass=Meta):
340			with namespaces.Namespace() as ns:
341			cls_var = 2
342
343			assert Meta.ns.meta_var == 1
344			assert Test.ns.meta_var == 1
345			assert Test.ns.cls_var == 2
346			assert Test().ns.cls_var == 2
347			with pytest.raises(AttributeError):
348			Test().ns.meta_var
349

mwchase / class-namespaces

Push — master ( 440d09...1286dd )

test_set() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like