5
5
"""Test cases for Twisted component architecture."""
7
7
from zope import interface as zinterface
8
from zope.interface import Interface, implements
9
10
from twisted.trial import unittest, util
10
11
from twisted.python import components
13
compWarn = {'category':components.ComponentsDeprecationWarning}
14
suppress = [util.suppress(**compWarn)]
16
# Also filter warnings generated by top-level code
17
warnings.filterwarnings('ignore', **compWarn)
19
class IAdder(components.Interface):
20
"""A sample interface that adds stuff."""
23
"""Returns the sub of a and b."""
24
raise NotImplementedError
29
class IMultiply(components.Interface):
30
"""Interface that multiplies stuff."""
32
def multiply(self, a, b):
33
"""Multiply two items."""
34
raise NotImplementedError
38
"""Class that implements IAdder interface."""
40
zinterface.implements(IAdder)
46
"""Class that implements ISub."""
48
zinterface.implements(ISub)
54
class IntMultiplyWithAdder:
55
"""Multiply, using Adder object."""
57
zinterface.implements(IMultiply)
59
def __init__(self, adder):
62
def multiply(self, a, b):
65
result = self.adder.add(result, b)
68
components.registerAdapter(IntMultiplyWithAdder, IntAdder, IMultiply)
71
"""Multiply and add."""
73
zinterface.implements(IAdder, IMultiply)
78
def multiply(self, a, b):
84
class FooAdapterForMAA:
86
zinterface.implements(IFoo)
88
def __init__(self, instance):
89
self.instance = instance
92
return self.instance.add(a, b)
94
components.registerAdapter(FooAdapterForMAA, MultiplyAndAdd, IFoo)
97
14
class InterfacesTestCase(unittest.TestCase):
98
15
"""Test interfaces."""
100
def testModules(self):
101
self.assertEquals(components.Interface.__module__, "twisted.python.components")
102
self.assertEquals(IAdder.__module__, "twisted.test.test_components")
103
self.assertEquals(IFoo.__module__, "twisted.test.test_components")
105
def testClasses(self):
106
components.fixClassImplements(Sub)
107
components.fixClassImplements(MultiplyAndAdd)
108
self.assert_( IMultiply.implementedBy(MultiplyAndAdd) )
109
self.assert_( IAdder.implementedBy(MultiplyAndAdd) )
110
self.assert_( IAdder.implementedBy(Sub) )
111
self.assert_( ISub.implementedBy(Sub) )
113
def testInstances(self):
115
self.assert_( IMultiply.providedBy(o) )
116
self.assert_( IMultiply.providedBy(o) )
119
self.assert_( IAdder.providedBy(o) )
120
self.assert_( ISub.providedBy(o) )
123
self.assert_( not ISub.providedBy(3) )
124
self.assert_( not ISub.providedBy("foo") )
127
17
class Compo(components.Componentized):
130
20
self.num = self.num + 1
133
class IAdept(components.Interface):
134
def adaptorFunc(self):
23
class IAdept(Interface):
135
25
raise NotImplementedError()
137
class IElapsed(components.Interface):
138
def elapsedFunc(self):
27
class IElapsed(Interface):
143
33
class Adept(components.Adapter):
144
zinterface.implements(IAdept)
145
35
def __init__(self, orig):
146
36
self.original = orig
221
111
assert co4 == None
222
112
assert co1 is co3
115
def test_getComponentDefaults(self):
117
Test that a default value specified to Componentized.getComponent if
118
there is no component for the requested interface.
120
componentized = components.Componentized()
122
self.assertIdentical(
123
componentized.getComponent(ITest, default),
125
self.assertIdentical(
126
componentized.getComponent(ITest, default=default),
128
self.assertIdentical(
129
componentized.getComponent(ITest),
224
134
class AdapterTestCase(unittest.TestCase):
225
135
"""Test adapters."""
227
def testNoAdapter(self):
229
multiplier = IMultiply(o, None)
230
self.assertEquals(multiplier, None)
232
def testSelfIsAdapter(self):
234
adder = IAdder(o, None)
235
self.assert_( o is adder )
237
def testGetAdapter(self):
239
self.assertEquals(o.add(3, 4), 7)
241
# get an object implementing IMultiply
242
multiplier = IMultiply(o, None)
244
# check that it complies with the IMultiply interface
245
self.assertEquals(multiplier.multiply(3, 4), 12)
247
def testGetAdapterClass(self):
248
mklass = components.getAdapterClass(IntAdder, IMultiply, None)
249
self.assertEquals(mklass, IntMultiplyWithAdder)
251
def testGetSubAdapter(self):
253
self.assert_( not IFoo.providedBy(o) )
255
self.assert_( isinstance(foo, FooAdapterForMAA) )
257
def testParentInterface(self):
259
adder = IAdder(o, None)
260
self.assertIdentical(o, adder)
262
def testBadRegister(self):
263
# should fail because we already registered an IMultiply adapter for IntAdder
264
self.assertRaises(ValueError, components.registerAdapter, IntMultiplyWithAdder, IntAdder, IMultiply)
266
def testAllowDuplicates(self):
267
components.ALLOW_DUPLICATES = 1
269
components.registerAdapter(IntMultiplyWithAdder, IntAdder,
272
self.fail("Should have allowed re-registration")
274
# should fail because we already registered an IMultiply adapter
276
components.ALLOW_DUPLICATES = 0
277
self.assertRaises(ValueError, components.registerAdapter,
278
IntMultiplyWithAdder, IntAdder, IMultiply)
280
137
def testAdapterGetComponent(self):
283
self.assertRaises(components.CannotAdapt, IAdder, a)
284
self.assertEquals(IAdder(a, default=None), None)
286
def testMultipleInterfaceRegistration(self):
287
class IMIFoo(components.Interface):
289
class IMIBar(components.Interface):
291
class MIFooer(components.Adapter):
292
zinterface.implements(IMIFoo, IMIBar)
295
components.registerAdapter(MIFooer, Blegh, IMIFoo, IMIBar)
296
self.assert_(isinstance(IMIFoo(Blegh()), MIFooer))
297
self.assert_(isinstance(IMIBar(Blegh()), MIFooer))
299
class IMeta(components.Interface):
140
self.assertRaises(components.CannotAdapt, ITest, a)
141
self.assertEquals(ITest(a, None), None)
145
class IMeta(Interface):
302
148
class MetaAdder(components.Adapter):
303
zinterface.implements(IMeta)
304
150
def add(self, num):
305
151
return self.original.num + num
307
153
class BackwardsAdder(components.Adapter):
308
zinterface.implements(IMeta)
309
155
def add(self, num):
310
156
return self.original.num - num
386
232
self.assertEqual(('x!', 'x!'), xx.xx())
389
class IISource1(components.Interface): pass
390
class IISource2(components.Interface): pass
391
class IIDest1(components.Interface): pass
393
class Dest1Impl(components.Adapter):
394
zinterface.implements(IIDest1)
396
class Dest1Impl2(components.Adapter):
397
zinterface.implements(IIDest1)
400
zinterface.implements(IISource1, IISource2)
403
zinterface.implements(IISource2, IISource1)
405
components.registerAdapter(Dest1Impl, IISource1, IIDest1)
406
components.registerAdapter(Dest1Impl2, IISource2, IIDest1)
408
class TestInterfaceInterface(unittest.TestCase):
413
self.failUnless(isinstance(d, Dest1Impl), str(s12))
416
self.failUnless(isinstance(d, Dest1Impl2), str(s21))
419
class IZope(zinterface.Interface):
426
components.registerAdapter(lambda o: id(o), Zopeable, IZope)
428
class TestZope(unittest.TestCase):
430
def testAdapter(self):
432
self.assertEquals(id(x), IZope(x))
434
def testSignatureString(self):
435
# Make sure it cuts off the self from old t.p.c signatures.
436
self.assertEquals(IAdder['add'].getSignatureString(), "(a, b)")
437
self.assertEquals(IZope['amethod'].getSignatureString(), "(a, b)")
439
def testClassIsGCd(self):
442
zinterface.implements(IZope)
443
# Do some stuff with it
444
components.backwardsCompatImplements(Test)
447
# Make a weakref to it, then ensure the weakref goes away
448
r = weakref.ref(Test)
451
self.assertEquals(r(), None)
453
warnings.filterwarnings('default', **compWarn)
235
class RegistrationTestCase(unittest.TestCase):
237
Tests for adapter registration.
239
def _registerAdapterForClassOrInterface(self, original):
240
adapter = lambda o: None
241
class TheInterface(Interface):
243
components.registerAdapter(adapter, original, TheInterface)
244
self.assertIdentical(
245
components.getAdapterFactory(original, TheInterface, None),
249
def test_registerAdapterForClass(self):
251
Test that an adapter from a class can be registered and then looked
254
class TheOriginal(object):
256
return self._registerAdapterForClassOrInterface(TheOriginal)
259
def test_registerAdapterForInterface(self):
261
Test that an adapter from an interface can be registered and then
264
class TheOriginal(Interface):
266
return self._registerAdapterForClassOrInterface(TheOriginal)
269
def _duplicateAdapterForClassOrInterface(self, original):
270
firstAdapter = lambda o: False
271
secondAdapter = lambda o: True
272
class TheInterface(Interface):
274
components.registerAdapter(firstAdapter, original, TheInterface)
277
components.registerAdapter,
278
secondAdapter, original, TheInterface)
279
# Make sure that the original adapter is still around as well
280
self.assertIdentical(
281
components.getAdapterFactory(original, TheInterface, None),
285
def test_duplicateAdapterForClass(self):
287
Test that attempting to register a second adapter from a class
288
raises the appropriate exception.
290
class TheOriginal(object):
292
return self._duplicateAdapterForClassOrInterface(TheOriginal)
295
def test_duplicateAdapterForInterface(self):
297
Test that attempting to register a second adapter from an interface
298
raises the appropriate exception.
300
class TheOriginal(Interface):
302
return self._duplicateAdapterForClassOrInterface(TheOriginal)
305
def _duplicateAdapterForClassOrInterfaceAllowed(self, original):
306
firstAdapter = lambda o: False
307
secondAdapter = lambda o: True
308
class TheInterface(Interface):
310
components.registerAdapter(firstAdapter, original, TheInterface)
311
components.ALLOW_DUPLICATES = True
313
components.registerAdapter(secondAdapter, original, TheInterface)
314
self.assertIdentical(
315
components.getAdapterFactory(original, TheInterface, None),
318
components.ALLOW_DUPLICATES = False
320
# It should be rejected again at this point
323
components.registerAdapter,
324
firstAdapter, original, TheInterface)
326
self.assertIdentical(
327
components.getAdapterFactory(original, TheInterface, None),
330
def test_duplicateAdapterForClassAllowed(self):
332
Test that when L{components.ALLOW_DUPLICATES} is set to a true
333
value, duplicate registrations from classes are allowed to override
334
the original registration.
336
class TheOriginal(object):
338
return self._duplicateAdapterForClassOrInterfaceAllowed(TheOriginal)
341
def test_duplicateAdapterForInterfaceAllowed(self):
343
Test that when L{components.ALLOW_DUPLICATES} is set to a true
344
value, duplicate registrations from interfaces are allowed to
345
override the original registration.
347
class TheOriginal(Interface):
349
return self._duplicateAdapterForClassOrInterfaceAllowed(TheOriginal)
352
def _multipleInterfacesForClassOrInterface(self, original):
353
adapter = lambda o: None
354
class FirstInterface(Interface):
356
class SecondInterface(Interface):
358
components.registerAdapter(adapter, original, FirstInterface, SecondInterface)
359
self.assertIdentical(
360
components.getAdapterFactory(original, FirstInterface, None),
362
self.assertIdentical(
363
components.getAdapterFactory(original, SecondInterface, None),
367
def test_multipleInterfacesForClass(self):
369
Test the registration of an adapter from a class to several
372
class TheOriginal(object):
374
return self._multipleInterfacesForClassOrInterface(TheOriginal)
377
def test_multipleInterfacesForInterface(self):
379
Test the registration of an adapter from an interface to several
382
class TheOriginal(Interface):
384
return self._multipleInterfacesForClassOrInterface(TheOriginal)
387
def _subclassAdapterRegistrationForClassOrInterface(self, original):
388
firstAdapter = lambda o: True
389
secondAdapter = lambda o: False
390
class TheSubclass(original):
392
class TheInterface(Interface):
394
components.registerAdapter(firstAdapter, original, TheInterface)
395
components.registerAdapter(secondAdapter, TheSubclass, TheInterface)
396
self.assertIdentical(
397
components.getAdapterFactory(original, TheInterface, None),
399
self.assertIdentical(
400
components.getAdapterFactory(TheSubclass, TheInterface, None),
404
def test_subclassAdapterRegistrationForClass(self):
406
Test that an adapter to a particular interface can be registered
407
from both a class and its subclass.
409
class TheOriginal(object):
411
return self._subclassAdapterRegistrationForClassOrInterface(TheOriginal)
414
def test_subclassAdapterRegistrationForInterface(self):
416
Test that an adapter to a particular interface can be registered
417
from both an interface and its subclass.
419
class TheOriginal(Interface):
421
return self._subclassAdapterRegistrationForClassOrInterface(TheOriginal)
added
removed
twisted/test/test_components.py
