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.assertIs(
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.assertIs(
components.getAdapterFactory(original, TheInterface, None),
secondAdapter)
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.assertIs(
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.assertIs(
components.getAdapterFactory(original, TheInterface, None),
secondAdapter)
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.assertIs(components.getAdapterFactory(original, ITest, None), adapter)
self.assertIs(components.getAdapterFactory(original, ITest2, None), adapter)
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.assertIs(
components.getAdapterFactory(original, ITest, None), adapter)
self.assertIs(
components.getAdapterFactory(original, ITest2, None), adapter)
def _multipleInterfacesForClassOrInterface(self, original):
adapter = lambda o: None
class FirstInterface(Interface):
pass
class SecondInterface(Interface):
pass
components.registerAdapter(adapter, original, FirstInterface, SecondInterface)
self.assertIdentical(
components.getAdapterFactory(original, FirstInterface, None),
adapter)
self.assertIdentical(
components.getAdapterFactory(original, SecondInterface, None),
adapter)
def _multipleInterfacesForClassOrInterface(self, original):
adapter = lambda o: None
class FirstInterface(Interface):
pass
class SecondInterface(Interface):
pass
components.registerAdapter(adapter, original, FirstInterface, SecondInterface)
self.assertIdentical(
components.getAdapterFactory(original, FirstInterface, None),
adapter)
self.assertIdentical(
components.getAdapterFactory(original, SecondInterface, None),
adapter)
def _subclassAdapterRegistrationForClassOrInterface(self, original):
firstAdapter = lambda o: True
secondAdapter = lambda o: False
class TheSubclass(original):
pass
class TheInterface(Interface):
pass
components.registerAdapter(firstAdapter, original, TheInterface)
components.registerAdapter(secondAdapter, TheSubclass, TheInterface)
self.assertIdentical(
components.getAdapterFactory(original, TheInterface, None),
firstAdapter)
self.assertIdentical(
components.getAdapterFactory(TheSubclass, TheInterface, None),
secondAdapter)
def _subclassAdapterRegistrationForClassOrInterface(self, original):
firstAdapter = lambda o: True
secondAdapter = lambda o: False
class TheSubclass(original):
pass
class TheInterface(Interface):
pass
components.registerAdapter(firstAdapter, original, TheInterface)
components.registerAdapter(secondAdapter, TheSubclass, TheInterface)
self.assertIdentical(
components.getAdapterFactory(original, TheInterface, None),
firstAdapter)
self.assertIdentical(
components.getAdapterFactory(TheSubclass, TheInterface, None),
secondAdapter)
def __conform__(self, interface, registry=None, default=None):
for providedInterface in self.provided:
if providedInterface.isOrExtends(interface):
return self.load()
if getAdapterFactory(providedInterface, interface, None) is not None:
return interface(self.load(), default)
return default
def __conform__(self, interface, registry=None, default=None):
for providedInterface in self.provided:
if providedInterface.isOrExtends(interface):
return self.load()
if getAdapterFactory(providedInterface, interface, None) is not None:
return interface(self.load(), default)
return default
def _registerAdapterForClassOrInterface(self, original):
adapter = lambda o: None
class TheInterface(Interface):
pass
components.registerAdapter(adapter, original, TheInterface)
self.assertIdentical(
components.getAdapterFactory(original, TheInterface, None),
adapter)
def _registerAdapterForClassOrInterface(self, original):
adapter = lambda o: None
class TheInterface(Interface):
pass
components.registerAdapter(adapter, original, TheInterface)
self.assertIdentical(
components.getAdapterFactory(original, TheInterface, None),
adapter)
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.assertIs(components.getAdapterFactory(original, ITest, None), adapter)
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.assertIs(components.getAdapterFactory(original, ITest, None),
firstAdapter)
self.assertIs(components.getAdapterFactory(TheSubclass, ITest, None),
secondAdapter)
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.assertIs(
components.getAdapterFactory(original, ITest, None),
firstAdapter)
self.assertIs(
components.getAdapterFactory(TheSubclass, ITest, None),
secondAdapter)
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.assertIs(
components.getAdapterFactory(original, ITest, None),
adapter)
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.assertIs(components.getAdapterFactory(original, ITest, None),
firstAdapter)
def _duplicateAdapterForClassOrInterface(self, original):
firstAdapter = lambda o: False
secondAdapter = lambda o: True
class TheInterface(Interface):
pass
components.registerAdapter(firstAdapter, original, TheInterface)
self.assertRaises(
ValueError,
components.registerAdapter,
secondAdapter, original, TheInterface)
# Make sure that the original adapter is still around as well
self.assertIdentical(
components.getAdapterFactory(original, TheInterface, None),
firstAdapter)
def _duplicateAdapterForClassOrInterface(self, original):
firstAdapter = lambda o: False
secondAdapter = lambda o: True
class TheInterface(Interface):
pass
components.registerAdapter(firstAdapter, original, TheInterface)
self.assertRaises(ValueError, components.registerAdapter,
secondAdapter, original, TheInterface)
# Make sure that the original adapter is still around as well
self.assertIdentical(
components.getAdapterFactory(original, TheInterface, None),
firstAdapter)
def _duplicateAdapterForClassOrInterfaceAllowed(self, original):
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 _duplicateAdapterForClassOrInterfaceAllowed(self, original):
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 __init__(self, portal, config):
assert isinstance(portal, Portal)
assert isinstance(config, ConfigParser)
self.portal = portal
self.privateKeys = {
'ssh-rsa': keys.Key.fromFile(config.get("DEFAULT", "privateKeyLocation"))
}
self.publicKeys = {
'ssh-rsa': keys.Key.fromFile(config.get("DEFAULT", "publicKeyLocation"))
}
if components.getAdapterFactory(ConchUser, ISession, None) is None:
components.registerAdapter(Session, ConchUser, ISession)
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.assertIs(
components.getAdapterFactory(original, ITest, None),
firstAdapter)
def registerIfNotRegistered(adapter, from_, to):
if not components.getAdapterFactory(from_, to, None):
components.registerAdapter(adapter, from_, to)
def registerIfNotRegistered(adapter, from_, to):
if not components.getAdapterFactory(from_, to, None):
components.registerAdapter(adapter, from_, to)
