diff options
Diffstat (limited to 'lib/python2.7/site-packages/Twisted-12.2.0-py2.7-linux-x86_64.egg/twisted/python/test/test_components.py')
-rwxr-xr-x | lib/python2.7/site-packages/Twisted-12.2.0-py2.7-linux-x86_64.egg/twisted/python/test/test_components.py | 770 |
1 files changed, 0 insertions, 770 deletions
diff --git a/lib/python2.7/site-packages/Twisted-12.2.0-py2.7-linux-x86_64.egg/twisted/python/test/test_components.py b/lib/python2.7/site-packages/Twisted-12.2.0-py2.7-linux-x86_64.egg/twisted/python/test/test_components.py deleted file mode 100755 index c4c1b451..00000000 --- a/lib/python2.7/site-packages/Twisted-12.2.0-py2.7-linux-x86_64.egg/twisted/python/test/test_components.py +++ /dev/null @@ -1,770 +0,0 @@ -# Copyright (c) Twisted Matrix Laboratories. -# See LICENSE for details. - - -""" -Test cases for Twisted component architecture. -""" - -from zope.interface import Interface, implements, Attribute -from zope.interface.adapter import AdapterRegistry - -from twisted.trial import unittest -from twisted.python import components -from twisted.python.components import _addHook, _removeHook, proxyForInterface - - -class InterfacesTestCase(unittest.TestCase): - """Test interfaces.""" - -class Compo(components.Componentized): - num = 0 - def inc(self): - self.num = self.num + 1 - return self.num - -class IAdept(Interface): - def adaptorFunc(): - raise NotImplementedError() - -class IElapsed(Interface): - def elapsedFunc(): - """ - 1! - """ - -class Adept(components.Adapter): - implements(IAdept) - def __init__(self, orig): - self.original = orig - self.num = 0 - def adaptorFunc(self): - self.num = self.num + 1 - return self.num, self.original.inc() - -class Elapsed(components.Adapter): - implements(IElapsed) - def elapsedFunc(self): - return 1 - -class AComp(components.Componentized): - pass -class BComp(AComp): - pass -class CComp(BComp): - pass - -class ITest(Interface): - pass -class ITest2(Interface): - pass -class ITest3(Interface): - pass -class ITest4(Interface): - pass -class Test(components.Adapter): - implements(ITest, ITest3, ITest4) - def __init__(self, orig): - pass -class Test2: - implements(ITest2) - temporaryAdapter = 1 - def __init__(self, orig): - pass - - - -class RegistryUsingMixin(object): - """ - Mixin for test cases which modify the global registry somehow. - """ - def setUp(self): - """ - Configure L{twisted.python.components.registerAdapter} to mutate an - alternate registry to improve test isolation. - """ - # Create a brand new, empty registry and put it onto the components - # module where registerAdapter will use it. Also ensure that it goes - # away at the end of the test. - scratchRegistry = AdapterRegistry() - self.patch(components, 'globalRegistry', scratchRegistry) - # Hook the new registry up to the adapter lookup system and ensure that - # association is also discarded after the test. - hook = _addHook(scratchRegistry) - self.addCleanup(_removeHook, hook) - - - -class ComponentizedTestCase(unittest.TestCase, RegistryUsingMixin): - """ - Simple test case for caching in Componentized. - """ - def setUp(self): - RegistryUsingMixin.setUp(self) - - components.registerAdapter(Test, AComp, ITest) - components.registerAdapter(Test, AComp, ITest3) - components.registerAdapter(Test2, AComp, ITest2) - - - def testComponentized(self): - components.registerAdapter(Adept, Compo, IAdept) - components.registerAdapter(Elapsed, Compo, IElapsed) - - c = Compo() - assert c.getComponent(IAdept).adaptorFunc() == (1, 1) - assert c.getComponent(IAdept).adaptorFunc() == (2, 2) - assert IElapsed(IAdept(c)).elapsedFunc() == 1 - - def testInheritanceAdaptation(self): - c = CComp() - co1 = c.getComponent(ITest) - co2 = c.getComponent(ITest) - co3 = c.getComponent(ITest2) - co4 = c.getComponent(ITest2) - assert co1 is co2 - assert co3 is not co4 - c.removeComponent(co1) - co5 = c.getComponent(ITest) - co6 = c.getComponent(ITest) - assert co5 is co6 - assert co1 is not co5 - - def testMultiAdapter(self): - c = CComp() - co1 = c.getComponent(ITest) - co2 = c.getComponent(ITest2) - co3 = c.getComponent(ITest3) - co4 = c.getComponent(ITest4) - self.assertIdentical(None, co4) - self.assertIdentical(co1, co3) - - - def test_getComponentDefaults(self): - """ - Test that a default value specified to Componentized.getComponent if - there is no component for the requested interface. - """ - componentized = components.Componentized() - default = object() - self.assertIdentical( - componentized.getComponent(ITest, default), - default) - self.assertIdentical( - componentized.getComponent(ITest, default=default), - default) - self.assertIdentical( - componentized.getComponent(ITest), - None) - - - -class AdapterTestCase(unittest.TestCase): - """Test adapters.""" - - def testAdapterGetComponent(self): - o = object() - a = Adept(o) - self.assertRaises(components.CannotAdapt, ITest, a) - self.assertEqual(ITest(a, None), None) - - - -class IMeta(Interface): - pass - -class MetaAdder(components.Adapter): - implements(IMeta) - def add(self, num): - return self.original.num + num - -class BackwardsAdder(components.Adapter): - implements(IMeta) - def add(self, num): - return self.original.num - num - -class MetaNumber: - def __init__(self, num): - self.num = num - -class FakeAdder: - def add(self, num): - return num + 5 - -class FakeNumber: - num = 3 - -class ComponentNumber(components.Componentized): - def __init__(self): - self.num = 0 - components.Componentized.__init__(self) - -class ComponentMeta(components.Adapter): - implements(IMeta) - def __init__(self, original): - components.Adapter.__init__(self, original) - self.num = self.original.num - -class ComponentAdder(ComponentMeta): - def add(self, num): - self.num += num - return self.num - -class ComponentDoubler(ComponentMeta): - def add(self, num): - self.num += (num * 2) - return self.original.num - -class IAttrX(Interface): - def x(): - pass - -class IAttrXX(Interface): - def xx(): - pass - -class Xcellent: - implements(IAttrX) - def x(self): - return 'x!' - -class DoubleXAdapter: - num = 42 - def __init__(self, original): - self.original = original - def xx(self): - return (self.original.x(), self.original.x()) - def __cmp__(self, other): - return cmp(self.num, other.num) - - -class TestMetaInterface(RegistryUsingMixin, unittest.TestCase): - def testBasic(self): - components.registerAdapter(MetaAdder, MetaNumber, IMeta) - n = MetaNumber(1) - self.assertEqual(IMeta(n).add(1), 2) - - def testComponentizedInteraction(self): - components.registerAdapter(ComponentAdder, ComponentNumber, IMeta) - c = ComponentNumber() - IMeta(c).add(1) - IMeta(c).add(1) - self.assertEqual(IMeta(c).add(1), 3) - - def testAdapterWithCmp(self): - # Make sure that a __cmp__ on an adapter doesn't break anything - components.registerAdapter(DoubleXAdapter, IAttrX, IAttrXX) - xx = IAttrXX(Xcellent()) - self.assertEqual(('x!', 'x!'), xx.xx()) - - -class RegistrationTestCase(RegistryUsingMixin, unittest.TestCase): - """ - Tests for adapter registration. - """ - def _registerAdapterForClassOrInterface(self, original): - """ - Register an adapter with L{components.registerAdapter} for the given - class or interface and verify that the adapter can be looked up with - L{components.getAdapterFactory}. - """ - adapter = lambda o: None - components.registerAdapter(adapter, original, ITest) - self.assertIdentical( - components.getAdapterFactory(original, ITest, None), - adapter) - - - def test_registerAdapterForClass(self): - """ - Test that an adapter from a class can be registered and then looked - up. - """ - class TheOriginal(object): - pass - return self._registerAdapterForClassOrInterface(TheOriginal) - - - def test_registerAdapterForInterface(self): - """ - Test that an adapter from an interface can be registered and then - looked up. - """ - return self._registerAdapterForClassOrInterface(ITest2) - - - def _duplicateAdapterForClassOrInterface(self, original): - """ - Verify that L{components.registerAdapter} raises L{ValueError} if the - from-type/interface and to-interface pair is not unique. - """ - firstAdapter = lambda o: False - secondAdapter = lambda o: True - components.registerAdapter(firstAdapter, original, ITest) - self.assertRaises( - ValueError, - components.registerAdapter, - secondAdapter, original, ITest) - # Make sure that the original adapter is still around as well - self.assertIdentical( - components.getAdapterFactory(original, ITest, None), - firstAdapter) - - - def test_duplicateAdapterForClass(self): - """ - Test that attempting to register a second adapter from a class - raises the appropriate exception. - """ - class TheOriginal(object): - pass - return self._duplicateAdapterForClassOrInterface(TheOriginal) - - - def test_duplicateAdapterForInterface(self): - """ - Test that attempting to register a second adapter from an interface - raises the appropriate exception. - """ - return self._duplicateAdapterForClassOrInterface(ITest2) - - - def _duplicateAdapterForClassOrInterfaceAllowed(self, original): - """ - Verify that when C{components.ALLOW_DUPLICATES} is set to C{True}, new - adapter registrations for a particular from-type/interface and - to-interface pair replace older registrations. - """ - firstAdapter = lambda o: False - secondAdapter = lambda o: True - class TheInterface(Interface): - pass - components.registerAdapter(firstAdapter, original, TheInterface) - components.ALLOW_DUPLICATES = True - try: - components.registerAdapter(secondAdapter, original, TheInterface) - self.assertIdentical( - components.getAdapterFactory(original, TheInterface, None), - secondAdapter) - finally: - components.ALLOW_DUPLICATES = False - - # It should be rejected again at this point - self.assertRaises( - ValueError, - components.registerAdapter, - firstAdapter, original, TheInterface) - - self.assertIdentical( - components.getAdapterFactory(original, TheInterface, None), - secondAdapter) - - - def test_duplicateAdapterForClassAllowed(self): - """ - Test that when L{components.ALLOW_DUPLICATES} is set to a true - value, duplicate registrations from classes are allowed to override - the original registration. - """ - class TheOriginal(object): - pass - return self._duplicateAdapterForClassOrInterfaceAllowed(TheOriginal) - - - def test_duplicateAdapterForInterfaceAllowed(self): - """ - Test that when L{components.ALLOW_DUPLICATES} is set to a true - value, duplicate registrations from interfaces are allowed to - override the original registration. - """ - class TheOriginal(Interface): - pass - return self._duplicateAdapterForClassOrInterfaceAllowed(TheOriginal) - - - def _multipleInterfacesForClassOrInterface(self, original): - """ - Verify that an adapter can be registered for multiple to-interfaces at a - time. - """ - adapter = lambda o: None - components.registerAdapter(adapter, original, ITest, ITest2) - self.assertIdentical( - components.getAdapterFactory(original, ITest, None), adapter) - self.assertIdentical( - components.getAdapterFactory(original, ITest2, None), adapter) - - - def test_multipleInterfacesForClass(self): - """ - Test the registration of an adapter from a class to several - interfaces at once. - """ - class TheOriginal(object): - pass - return self._multipleInterfacesForClassOrInterface(TheOriginal) - - - def test_multipleInterfacesForInterface(self): - """ - Test the registration of an adapter from an interface to several - interfaces at once. - """ - return self._multipleInterfacesForClassOrInterface(ITest3) - - - def _subclassAdapterRegistrationForClassOrInterface(self, original): - """ - Verify that a new adapter can be registered for a particular - to-interface from a subclass of a type or interface which already has an - adapter registered to that interface and that the subclass adapter takes - precedence over the base class adapter. - """ - firstAdapter = lambda o: True - secondAdapter = lambda o: False - class TheSubclass(original): - pass - components.registerAdapter(firstAdapter, original, ITest) - components.registerAdapter(secondAdapter, TheSubclass, ITest) - self.assertIdentical( - components.getAdapterFactory(original, ITest, None), - firstAdapter) - self.assertIdentical( - components.getAdapterFactory(TheSubclass, ITest, None), - secondAdapter) - - - def test_subclassAdapterRegistrationForClass(self): - """ - Test that an adapter to a particular interface can be registered - from both a class and its subclass. - """ - class TheOriginal(object): - pass - return self._subclassAdapterRegistrationForClassOrInterface(TheOriginal) - - - def test_subclassAdapterRegistrationForInterface(self): - """ - Test that an adapter to a particular interface can be registered - from both an interface and its subclass. - """ - return self._subclassAdapterRegistrationForClassOrInterface(ITest2) - - - -class IProxiedInterface(Interface): - """ - An interface class for use by L{proxyForInterface}. - """ - - ifaceAttribute = Attribute(""" - An example declared attribute, which should be proxied.""") - - def yay(*a, **kw): - """ - A sample method which should be proxied. - """ - -class IProxiedSubInterface(IProxiedInterface): - """ - An interface that derives from another for use with L{proxyForInterface}. - """ - - def boo(self): - """ - A different sample method which should be proxied. - """ - - - -class Yayable(object): - """ - A provider of L{IProxiedInterface} which increments a counter for - every call to C{yay}. - - @ivar yays: The number of times C{yay} has been called. - """ - implements(IProxiedInterface) - - def __init__(self): - self.yays = 0 - self.yayArgs = [] - - def yay(self, *a, **kw): - """ - Increment C{self.yays}. - """ - self.yays += 1 - self.yayArgs.append((a, kw)) - return self.yays - - -class Booable(object): - """ - An implementation of IProxiedSubInterface - """ - implements(IProxiedSubInterface) - yayed = False - booed = False - def yay(self): - """ - Mark the fact that 'yay' has been called. - """ - self.yayed = True - - - def boo(self): - """ - Mark the fact that 'boo' has been called.1 - """ - self.booed = True - - - -class IMultipleMethods(Interface): - """ - An interface with multiple methods. - """ - - def methodOne(): - """ - The first method. Should return 1. - """ - - def methodTwo(): - """ - The second method. Should return 2. - """ - - - -class MultipleMethodImplementor(object): - """ - A precise implementation of L{IMultipleMethods}. - """ - - def methodOne(self): - """ - @return: 1 - """ - return 1 - - - def methodTwo(self): - """ - @return: 2 - """ - return 2 - - - -class ProxyForInterfaceTests(unittest.TestCase): - """ - Tests for L{proxyForInterface}. - """ - - def test_original(self): - """ - Proxy objects should have an C{original} attribute which refers to the - original object passed to the constructor. - """ - original = object() - proxy = proxyForInterface(IProxiedInterface)(original) - self.assertIdentical(proxy.original, original) - - - def test_proxyMethod(self): - """ - The class created from L{proxyForInterface} passes methods on an - interface to the object which is passed to its constructor. - """ - klass = proxyForInterface(IProxiedInterface) - yayable = Yayable() - proxy = klass(yayable) - proxy.yay() - self.assertEqual(proxy.yay(), 2) - self.assertEqual(yayable.yays, 2) - - - def test_proxyAttribute(self): - """ - Proxy objects should proxy declared attributes, but not other - attributes. - """ - yayable = Yayable() - yayable.ifaceAttribute = object() - proxy = proxyForInterface(IProxiedInterface)(yayable) - self.assertIdentical(proxy.ifaceAttribute, yayable.ifaceAttribute) - self.assertRaises(AttributeError, lambda: proxy.yays) - - - def test_proxySetAttribute(self): - """ - The attributes that proxy objects proxy should be assignable and affect - the original object. - """ - yayable = Yayable() - proxy = proxyForInterface(IProxiedInterface)(yayable) - thingy = object() - proxy.ifaceAttribute = thingy - self.assertIdentical(yayable.ifaceAttribute, thingy) - - - def test_proxyDeleteAttribute(self): - """ - The attributes that proxy objects proxy should be deletable and affect - the original object. - """ - yayable = Yayable() - yayable.ifaceAttribute = None - proxy = proxyForInterface(IProxiedInterface)(yayable) - del proxy.ifaceAttribute - self.assertFalse(hasattr(yayable, 'ifaceAttribute')) - - - def test_multipleMethods(self): - """ - [Regression test] The proxy should send its method calls to the correct - method, not the incorrect one. - """ - multi = MultipleMethodImplementor() - proxy = proxyForInterface(IMultipleMethods)(multi) - self.assertEqual(proxy.methodOne(), 1) - self.assertEqual(proxy.methodTwo(), 2) - - - def test_subclassing(self): - """ - It is possible to subclass the result of L{proxyForInterface}. - """ - - class SpecializedProxy(proxyForInterface(IProxiedInterface)): - """ - A specialized proxy which can decrement the number of yays. - """ - def boo(self): - """ - Decrement the number of yays. - """ - self.original.yays -= 1 - - yayable = Yayable() - special = SpecializedProxy(yayable) - self.assertEqual(yayable.yays, 0) - special.boo() - self.assertEqual(yayable.yays, -1) - - - def test_proxyName(self): - """ - The name of a proxy class indicates which interface it proxies. - """ - proxy = proxyForInterface(IProxiedInterface) - self.assertEqual( - proxy.__name__, - "(Proxy for " - "twisted.python.test.test_components.IProxiedInterface)") - - - def test_implements(self): - """ - The resulting proxy implements the interface that it proxies. - """ - proxy = proxyForInterface(IProxiedInterface) - self.assertTrue(IProxiedInterface.implementedBy(proxy)) - - - def test_proxyDescriptorGet(self): - """ - _ProxyDescriptor's __get__ method should return the appropriate - attribute of its argument's 'original' attribute if it is invoked with - an object. If it is invoked with None, it should return a false - class-method emulator instead. - - For some reason, Python's documentation recommends to define - descriptors' __get__ methods with the 'type' parameter as optional, - despite the fact that Python itself never actually calls the descriptor - that way. This is probably do to support 'foo.__get__(bar)' as an - idiom. Let's make sure that the behavior is correct. Since we don't - actually use the 'type' argument at all, this test calls it the - idiomatic way to ensure that signature works; test_proxyInheritance - verifies the how-Python-actually-calls-it signature. - """ - class Sample: - called = False - def hello(self): - self.called = True - fakeProxy = Sample() - testObject = Sample() - fakeProxy.original = testObject - pd = components._ProxyDescriptor("hello", "original") - self.assertEqual(pd.__get__(fakeProxy), testObject.hello) - fakeClassMethod = pd.__get__(None) - fakeClassMethod(fakeProxy) - self.failUnless(testObject.called) - - - def test_proxyInheritance(self): - """ - Subclasses of the class returned from L{proxyForInterface} should be - able to upcall methods by reference to their superclass, as any normal - Python class can. - """ - class YayableWrapper(proxyForInterface(IProxiedInterface)): - """ - This class does not override any functionality. - """ - - class EnhancedWrapper(YayableWrapper): - """ - This class overrides the 'yay' method. - """ - wrappedYays = 1 - def yay(self, *a, **k): - self.wrappedYays += 1 - return YayableWrapper.yay(self, *a, **k) + 7 - - yayable = Yayable() - wrapper = EnhancedWrapper(yayable) - self.assertEqual(wrapper.yay(3, 4, x=5, y=6), 8) - self.assertEqual(yayable.yayArgs, - [((3, 4), dict(x=5, y=6))]) - - - def test_interfaceInheritance(self): - """ - Proxies of subinterfaces generated with proxyForInterface should allow - access to attributes of both the child and the base interfaces. - """ - proxyClass = proxyForInterface(IProxiedSubInterface) - booable = Booable() - proxy = proxyClass(booable) - proxy.yay() - proxy.boo() - self.failUnless(booable.yayed) - self.failUnless(booable.booed) - - - def test_attributeCustomization(self): - """ - The original attribute name can be customized via the - C{originalAttribute} argument of L{proxyForInterface}: the attribute - should change, but the methods of the original object should still be - callable, and the attributes still accessible. - """ - yayable = Yayable() - yayable.ifaceAttribute = object() - proxy = proxyForInterface( - IProxiedInterface, originalAttribute='foo')(yayable) - self.assertIdentical(proxy.foo, yayable) - - # Check the behavior - self.assertEqual(proxy.yay(), 1) - self.assertIdentical(proxy.ifaceAttribute, yayable.ifaceAttribute) - thingy = object() - proxy.ifaceAttribute = thingy - self.assertIdentical(yayable.ifaceAttribute, thingy) - del proxy.ifaceAttribute - self.assertFalse(hasattr(yayable, 'ifaceAttribute')) - |