zopefoundation / zope.interface / 388 / 1

Source File

98.83

/src/zope/interface/tests/test_odd_declarations.py

##############################################################################
#
# Copyright (c) 2003 Zope Foundation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Test interface declarations against ExtensionClass-like classes.

These tests are to make sure we do something sane in the presence of
classic ExtensionClass classes and instances.
"""
import unittest

from zope.interface.tests import odd
from zope.interface import Interface
from zope.interface import implementer
from zope.interface import directlyProvides
from zope.interface import providedBy
from zope.interface import directlyProvidedBy
from zope.interface import classImplements
from zope.interface import classImplementsOnly
from zope.interface import implementedBy
from zope.interface._compat import _skip_under_py3k

class I1(Interface): pass
class I2(Interface): pass
class I3(Interface): pass
class I31(I3): pass
class I4(Interface): pass
class I5(Interface): pass

class Odd(object):
    pass
Odd = odd.MetaClass('Odd', Odd.__bases__, {})


class B(Odd): __implemented__ = I2


# TODO: We are going to need more magic to make classProvides work with odd
#       classes. This will work in the next iteration. For now, we'll use
#       a different mechanism.

# from zope.interface import classProvides
class A(Odd):
    pass
classImplements(A, I1)

class C(A, B):
    pass
classImplements(C, I31)


class Test(unittest.TestCase):

    def test_ObjectSpecification(self):
        c = C()
        directlyProvides(c, I4)
        self.assertEqual([i.getName() for i in providedBy(c)],
                         ['I4', 'I31', 'I1', 'I2']
                         )
        self.assertEqual([i.getName() for i in providedBy(c).flattened()],
                         ['I4', 'I31', 'I3', 'I1', 'I2', 'Interface']
                         )
        self.assertTrue(I1 in providedBy(c))
        self.assertFalse(I3 in providedBy(c))
        self.assertTrue(providedBy(c).extends(I3))
        self.assertTrue(providedBy(c).extends(I31))
        self.assertFalse(providedBy(c).extends(I5))

        class COnly(A, B):
            pass
        classImplementsOnly(COnly, I31)

        class D(COnly):
            pass
        classImplements(D, I5)

        classImplements(D, I5)

        c = D()
        directlyProvides(c, I4)
        self.assertEqual([i.getName() for i in providedBy(c)],
                         ['I4', 'I5', 'I31'])
        self.assertEqual([i.getName() for i in providedBy(c).flattened()],
                         ['I4', 'I5', 'I31', 'I3', 'Interface'])
        self.assertFalse(I1 in providedBy(c))
        self.assertFalse(I3 in providedBy(c))
        self.assertTrue(providedBy(c).extends(I3))
        self.assertFalse(providedBy(c).extends(I1))
        self.assertTrue(providedBy(c).extends(I31))
        self.assertTrue(providedBy(c).extends(I5))

        class COnly(A, B): __implemented__ = I31
        class D(COnly):
            pass
        classImplements(D, I5)

        classImplements(D, I5)
        c = D()
        directlyProvides(c, I4)
        self.assertEqual([i.getName() for i in providedBy(c)],
                         ['I4', 'I5', 'I31'])
        self.assertEqual([i.getName() for i in providedBy(c).flattened()],
                         ['I4', 'I5', 'I31', 'I3', 'Interface'])
        self.assertFalse(I1 in providedBy(c))
        self.assertFalse(I3 in providedBy(c))
        self.assertTrue(providedBy(c).extends(I3))
        self.assertFalse(providedBy(c).extends(I1))
        self.assertTrue(providedBy(c).extends(I31))
        self.assertTrue(providedBy(c).extends(I5))

    def test_classImplements(self):

        @implementer(I3)
        class A(Odd):
            pass

        @implementer(I4)
        class B(Odd):
            pass

        class C(A, B):
            pass
        classImplements(C, I1, I2)
        self.assertEqual([i.getName() for i in implementedBy(C)],
                         ['I1', 'I2', 'I3', 'I4'])
        classImplements(C, I5)
        self.assertEqual([i.getName() for i in implementedBy(C)],
                         ['I1', 'I2', 'I5', 'I3', 'I4'])

    def test_classImplementsOnly(self):
        @implementer(I3)
        class A(Odd):
            pass

        @implementer(I4)
        class B(Odd):
            pass

        class C(A, B):
            pass
        classImplementsOnly(C, I1, I2)
        self.assertEqual([i.__name__ for i in implementedBy(C)],
                         ['I1', 'I2'])


    def test_directlyProvides(self):
        class IA1(Interface): pass
        class IA2(Interface): pass
        class IB(Interface): pass
        class IC(Interface): pass
        class A(Odd):
            pass
        classImplements(A, IA1, IA2)

        class B(Odd):
            pass
        classImplements(B, IB)

        class C(A, B):
            pass
        classImplements(C, IC)


        ob = C()
        directlyProvides(ob, I1, I2)
        self.assertTrue(I1 in providedBy(ob))
        self.assertTrue(I2 in providedBy(ob))
        self.assertTrue(IA1 in providedBy(ob))
        self.assertTrue(IA2 in providedBy(ob))
        self.assertTrue(IB in providedBy(ob))
        self.assertTrue(IC in providedBy(ob))

        directlyProvides(ob, directlyProvidedBy(ob)-I2)
        self.assertTrue(I1 in providedBy(ob))
        self.assertFalse(I2 in providedBy(ob))
        self.assertFalse(I2 in providedBy(ob))
        directlyProvides(ob, directlyProvidedBy(ob), I2)
        self.assertTrue(I2 in providedBy(ob))

    @_skip_under_py3k
    def test_directlyProvides_fails_for_odd_class(self):
        self.assertRaises(TypeError, directlyProvides, C, I5)

    # see above
    #def TODO_test_classProvides_fails_for_odd_class(self):
    #    try:
    #        class A(Odd):
    #            classProvides(I1)
    #    except TypeError:
    #        pass # Sucess
    #    self.assert_(False,
    #                 "Shouldn't be able to use directlyProvides on odd class."
    #                 )

    def test_implementedBy(self):
        class I2(I1): pass

        class C1(Odd):
            pass
        classImplements(C1, I2)

        class C2(C1):
            pass
        classImplements(C2, I3)

        self.assertEqual([i.getName() for i in implementedBy(C2)],
                         ['I3', 'I2'])

    def test_odd_metaclass_that_doesnt_subclass_type(self):
        # This was originally a doctest in odd.py.
        # It verifies that the metaclass the rest of these tests use
        # works as expected.

        # This is used for testing support for ExtensionClass in new interfaces.

        class A(object):
            a = 1

        A = odd.MetaClass('A', A.__bases__, A.__dict__)

        class B(object):
            b = 1

        B = odd.MetaClass('B', B.__bases__, B.__dict__)

        class C(A, B):
            pass

        self.assertEqual(C.__bases__, (A, B))

        a = A()
        aa = A()
        self.assertEqual(a.a, 1)
        self.assertEqual(aa.a, 1)

        aa.a = 2
        self.assertEqual(a.a, 1)
        self.assertEqual(aa.a, 2)

        c = C()
        self.assertEqual(c.a, 1)
        self.assertEqual(c.b, 1)

        c.b = 2
        self.assertEqual(c.b, 2)

        C.c = 1
        self.assertEqual(c.c, 1)
        c.c

        try:
            from types import ClassType
        except ImportError:
            pass
        else:
            # This test only makes sense under Python 2.x
            assert not isinstance(C, (type, ClassType))

        self.assertIs(C.__class__.__class__, C.__class__)

1	##############################################################################
2	#
3	# Copyright (c) 2003 Zope Foundation and Contributors.
4	# All Rights Reserved.
5	#
6	# This software is subject to the provisions of the Zope Public License,
7	# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
8	# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
9	# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
10	# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
11	# FOR A PARTICULAR PURPOSE.
12	#
13	##############################################################################
14	"""Test interface declarations against ExtensionClass-like classes.	1✔
15
16	These tests are to make sure we do something sane in the presence of
17	classic ExtensionClass classes and instances.
18	"""
19	import unittest	1✔
20
21	from zope.interface.tests import odd	1✔
22	from zope.interface import Interface	1✔
23	from zope.interface import implementer	1✔
24	from zope.interface import directlyProvides	1✔
25	from zope.interface import providedBy	1✔
26	from zope.interface import directlyProvidedBy	1✔
27	from zope.interface import classImplements	1✔
28	from zope.interface import classImplementsOnly	1✔
29	from zope.interface import implementedBy	1✔
30	from zope.interface._compat import _skip_under_py3k	1✔
31
32	class I1(Interface): pass	1✔
33	class I2(Interface): pass	1✔
34	class I3(Interface): pass	1✔
35	class I31(I3): pass	1✔
36	class I4(Interface): pass	1✔
37	class I5(Interface): pass	1✔
38
39	class Odd(object):	1✔
40	pass	1✔
41	Odd = odd.MetaClass('Odd', Odd.__bases__, {})	1✔
42
43
44	class B(Odd): __implemented__ = I2	1✔
45
46
47	# TODO: We are going to need more magic to make classProvides work with odd
48	# classes. This will work in the next iteration. For now, we'll use
49	# a different mechanism.
50
51	# from zope.interface import classProvides
52	class A(Odd):	1✔
53	pass	1✔
54	classImplements(A, I1)	1✔
55
56	class C(A, B):	1✔
57	pass	1✔
58	classImplements(C, I31)	1✔
59
60
61	class Test(unittest.TestCase):	1✔
62
63	def test_ObjectSpecification(self):	1✔
64	c = C()	1✔
65	directlyProvides(c, I4)	1✔
66	self.assertEqual([i.getName() for i in providedBy(c)],	1✔
67	['I4', 'I31', 'I1', 'I2']
68	)
69	self.assertEqual([i.getName() for i in providedBy(c).flattened()],	1✔
70	['I4', 'I31', 'I3', 'I1', 'I2', 'Interface']
71	)
72	self.assertTrue(I1 in providedBy(c))	1✔
73	self.assertFalse(I3 in providedBy(c))	1✔
74	self.assertTrue(providedBy(c).extends(I3))	1✔
75	self.assertTrue(providedBy(c).extends(I31))	1✔
76	self.assertFalse(providedBy(c).extends(I5))	1✔
77
78	class COnly(A, B):	1✔
79	pass	1✔
80	classImplementsOnly(COnly, I31)	1✔
81
82	class D(COnly):	1✔
83	pass	1✔
84	classImplements(D, I5)	1✔
85
86	classImplements(D, I5)	1✔
87
88	c = D()	1✔
89	directlyProvides(c, I4)	1✔
90	self.assertEqual([i.getName() for i in providedBy(c)],	1✔
91	['I4', 'I5', 'I31'])
92	self.assertEqual([i.getName() for i in providedBy(c).flattened()],	1✔
93	['I4', 'I5', 'I31', 'I3', 'Interface'])
94	self.assertFalse(I1 in providedBy(c))	1✔
95	self.assertFalse(I3 in providedBy(c))	1✔
96	self.assertTrue(providedBy(c).extends(I3))	1✔
97	self.assertFalse(providedBy(c).extends(I1))	1✔
98	self.assertTrue(providedBy(c).extends(I31))	1✔
99	self.assertTrue(providedBy(c).extends(I5))	1✔
100
101	class COnly(A, B): __implemented__ = I31	1✔
102	class D(COnly):	1✔
103	pass	1✔
104	classImplements(D, I5)	1✔
105
106	classImplements(D, I5)	1✔
107	c = D()	1✔
108	directlyProvides(c, I4)	1✔
109	self.assertEqual([i.getName() for i in providedBy(c)],	1✔
110	['I4', 'I5', 'I31'])
111	self.assertEqual([i.getName() for i in providedBy(c).flattened()],	1✔
112	['I4', 'I5', 'I31', 'I3', 'Interface'])
113	self.assertFalse(I1 in providedBy(c))	1✔
114	self.assertFalse(I3 in providedBy(c))	1✔
115	self.assertTrue(providedBy(c).extends(I3))	1✔
116	self.assertFalse(providedBy(c).extends(I1))	1✔
117	self.assertTrue(providedBy(c).extends(I31))	1✔
118	self.assertTrue(providedBy(c).extends(I5))	1✔
119
120	def test_classImplements(self):	1✔
121
122	@implementer(I3)	1✔
123	class A(Odd):	1✔
124	pass	1✔
125
126	@implementer(I4)	1✔
127	class B(Odd):	1✔
128	pass	1✔
129
130	class C(A, B):	1✔
131	pass	1✔
132	classImplements(C, I1, I2)	1✔
133	self.assertEqual([i.getName() for i in implementedBy(C)],	1✔
134	['I1', 'I2', 'I3', 'I4'])
135	classImplements(C, I5)	1✔
136	self.assertEqual([i.getName() for i in implementedBy(C)],	1✔
137	['I1', 'I2', 'I5', 'I3', 'I4'])
138
139	def test_classImplementsOnly(self):	1✔
140	@implementer(I3)	1✔
141	class A(Odd):	1✔
142	pass	1✔
143
144	@implementer(I4)	1✔
145	class B(Odd):	1✔
146	pass	1✔
147
148	class C(A, B):	1✔
149	pass	1✔
150	classImplementsOnly(C, I1, I2)	1✔
151	self.assertEqual([i.__name__ for i in implementedBy(C)],	1✔
152	['I1', 'I2'])
153
154
155	def test_directlyProvides(self):	1✔
156	class IA1(Interface): pass
157	class IA2(Interface): pass
158	class IB(Interface): pass	1✔
159	class IC(Interface): pass	1✔
160	class A(Odd):	1✔
161	pass	1✔
162	classImplements(A, IA1, IA2)	1✔
163
164	class B(Odd):	1✔
165	pass	1✔
166	classImplements(B, IB)	1✔
167
168	class C(A, B):	1✔
169	pass	1✔
170	classImplements(C, IC)	1✔
171
172
173	ob = C()	1✔
174	directlyProvides(ob, I1, I2)	1✔
175	self.assertTrue(I1 in providedBy(ob))	1✔
176	self.assertTrue(I2 in providedBy(ob))	1✔
177	self.assertTrue(IA1 in providedBy(ob))	1✔
178	self.assertTrue(IA2 in providedBy(ob))	1✔
179	self.assertTrue(IB in providedBy(ob))	1✔
180	self.assertTrue(IC in providedBy(ob))	1✔
181
182	directlyProvides(ob, directlyProvidedBy(ob)-I2)	1✔
183	self.assertTrue(I1 in providedBy(ob))	1✔
184	self.assertFalse(I2 in providedBy(ob))	1✔
185	self.assertFalse(I2 in providedBy(ob))	1✔
186	directlyProvides(ob, directlyProvidedBy(ob), I2)	1✔
187	self.assertTrue(I2 in providedBy(ob))	1✔
188
189	@_skip_under_py3k	1✔
190	def test_directlyProvides_fails_for_odd_class(self):
191	self.assertRaises(TypeError, directlyProvides, C, I5)	1✔
192
193	# see above
194	#def TODO_test_classProvides_fails_for_odd_class(self):
195	# try:
196	# class A(Odd):
197	# classProvides(I1)
198	# except TypeError:
199	# pass # Sucess
200	# self.assert_(False,
201	# "Shouldn't be able to use directlyProvides on odd class."
202	# )
203
204	def test_implementedBy(self):	1✔
205	class I2(I1): pass	1✔
206
207	class C1(Odd):	1✔
208	pass	1✔
209	classImplements(C1, I2)	1✔
210
211	class C2(C1):	1✔
212	pass	1✔
213	classImplements(C2, I3)	1✔
214
215	self.assertEqual([i.getName() for i in implementedBy(C2)],	1✔
216	['I3', 'I2'])
217
218	def test_odd_metaclass_that_doesnt_subclass_type(self):	1✔
219	# This was originally a doctest in odd.py.
220	# It verifies that the metaclass the rest of these tests use
221	# works as expected.
222
223	# This is used for testing support for ExtensionClass in new interfaces.
224
225	class A(object):	1✔
226	a = 1	1✔
227
228	A = odd.MetaClass('A', A.__bases__, A.__dict__)	1✔
229
230	class B(object):	1✔
231	b = 1	1✔
232
233	B = odd.MetaClass('B', B.__bases__, B.__dict__)	1✔
234
235	class C(A, B):	1✔
236	pass	1✔
237
238	self.assertEqual(C.__bases__, (A, B))	1✔
239
240	a = A()	1✔
241	aa = A()	1✔
242	self.assertEqual(a.a, 1)	1✔
243	self.assertEqual(aa.a, 1)	1✔
244
245	aa.a = 2	1✔
246	self.assertEqual(a.a, 1)	1✔
247	self.assertEqual(aa.a, 2)	1✔
248
249	c = C()	1✔
250	self.assertEqual(c.a, 1)	1✔
251	self.assertEqual(c.b, 1)	1✔
252
253	c.b = 2	1✔
254	self.assertEqual(c.b, 2)	1✔
255
256	C.c = 1	1✔
257	self.assertEqual(c.c, 1)	1✔
258	c.c	1✔
259
260	try:	1✔
261	from types import ClassType	1✔
262	except ImportError:	×
263	pass	×
264	else:
265	# This test only makes sense under Python 2.x
266	assert not isinstance(C, (type, ClassType))	1✔
267
268	self.assertIs(C.__class__.__class__, C.__class__)	1✔