def test_proxyName(self):
     """
     The name of a proxy class indicates which interface it proxies.
     """
     proxy = proxyForInterface(IProxiedInterface)
     self.assertEqual(proxy.__name__,
         "(Proxy for seishub.core.tests." + \
         "test_core_twisted_compatibility.IProxiedInterface)")

 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_proxyName(self):
     """
     The name of a proxy class indicates which interface it proxies.
     """
     proxy = proxyForInterface(IProxiedInterface)
     self.assertEquals(
         proxy.__name__,
         "(Proxy for "
         "twisted.python.test.test_components.IProxiedInterface)")

 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.assertEquals(proxy.methodOne(), 1)
     self.assertEquals(proxy.methodTwo(), 2)

 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_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_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_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.assertEquals(proxy.yay(), 2)
     self.assertEquals(yayable.yays, 2)

 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 repeat_call_proxy_for(interface, provider):
    """
    Constructs an implementation of interface that calls the corresponding
    method on implementation twice for every call to a method.

    :interface param: The zope interface that the proxy should implement.
    :provider param: The underlying provider to proxy all method calls to.
    """
    # proxyForInterface used so that only the methods of the interface are
    # exposed. The naive implementation of _RepeatProxy forwards all methods
    # rather than just the methods that are part of the interface.
    return proxyForInterface(interface, originalAttribute="_original")(_RepeatProxy(_provider=provider))

def loggedReactor(reactor):
    """
    Construct and return a wrapper around the given C{reactor} which provides
    all of the same interfaces, but which will log all traffic over outgoing
    TCP connections it establishes.
    """
    bases = []
    for iface in providedBy(reactor):
        if iface is IReactorTCP:
            bases.append(_TCPTrafficLoggingReactor)
        else:
            bases.append(proxyForInterface(iface, '_reactor'))
    if bases:
        return type('(Logged Reactor)', tuple(bases), {})(reactor)
    return reactor

    def test_decoratedProxyMethod(self):
        """
        Methods of the class created from L{proxyForInterface} can be used with
        the decorator-helper L{functools.wraps}.
        """
        base = proxyForInterface(IProxiedInterface)
        class klass(base):
            @wraps(base.yay)
            def yay(self):
                self.original.yays += 1
                return base.yay(self)

        original = Yayable()
        yayable = klass(original)
        yayable.yay()
        self.assertEqual(2, original.yays)

    def service(self, services=None):
        if services is None:
            services = (self.xmlService(),)

        #
        # Make sure aggregate DirectoryService isn't making
        # implementation assumptions about the IDirectoryService
        # objects it gets.
        #
        services = tuple((
            proxyForInterface(IDirectoryService)(s)
            for s in services
        ))

        class TestService(DirectoryService, QueryMixIn):
            pass

        return TestService("xyzzy", services)

    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.assertEquals(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'))

 def test_implements(self):
     """
     The resulting proxy implements the interface that it proxies.
     """
     proxy = proxyForInterface(IProxiedInterface)
     self.assertTrue(IProxiedInterface.implementedBy(proxy))

 def test_provides(self):
     """
     The resulting proxy provides the Interface that it proxies.
     """
     proxy = proxyForInterface(IProxiedInterface)
     self.assertTrue(IProxiedInterface.providedBy(proxy))