def test_named_hit(self):
from zope.interface import Interface
from zope.interface import implementer
from guillotina.component import get_global_components
class IFoo(Interface):
pass
class IBar(Interface):
pass
class IBaz(Interface):
pass
@implementer(IBar)
class Bar(object):
pass
@implementer(IBaz)
class Baz(object):
pass
@implementer(IFoo)
class FooAdapter(object):
def __init__(self, first, second):
self.first, self.second = first, second
get_global_components().registerAdapter(
FooAdapter, (IBar, IBaz), IFoo, 'named')
bar = Bar()
baz = Baz()
adapted = self._callFUT((bar, baz), IFoo, 'named')
self.assertTrue(adapted.__class__ is FooAdapter)
self.assertTrue(adapted.first is bar)
self.assertTrue(adapted.second is baz)
def test_anonymous_hit(self):
from zope.interface import Interface
from zope.interface import implementer
from guillotina.component import get_global_components
class IFoo(Interface):
pass
class IBar(Interface):
pass
@implementer(IBar)
class Bar(object):
pass
@implementer(IFoo)
class Baz(object):
def __init__(self, context):
self.context = context
get_global_components().registerAdapter(Baz, (IBar, ), IFoo, "")
bar = Bar()
adapted = self._callFUT(bar, IFoo, "")
self.assertTrue(adapted.__class__ is Baz)
self.assertTrue(adapted.context is bar)
def test_named_hit(self):
from zope.interface import Interface
from guillotina.component import get_global_components
class IFoo(Interface):
pass
obj = object()
get_global_components().registerUtility(obj, IFoo, name='bar')
self.assertTrue(self._callFUT(IFoo, name='bar') is obj)
def test_hit(self):
from zope.interface import Interface
from guillotina.component import get_global_components
class IFoo(Interface):
pass
obj = object()
obj1 = object()
get_global_components().registerUtility(obj, IFoo)
get_global_components().registerUtility(obj1, IFoo, name='bar')
tuples = list(self._callFUT(IFoo))
self.assertEqual(len(tuples), 2)
self.assertTrue(('', obj) in tuples)
self.assertTrue(('bar', obj1) in tuples)
def test_anonymous_hit_registered_for_None(self):
from zope.interface import Interface
from zope.interface import implementer
from guillotina.component import get_global_components
class IFoo(Interface):
pass
@implementer(IFoo)
class Baz(object):
def __init__(self, context):
self.context = context
get_global_components().registerAdapter(Baz, (None,), IFoo, '')
ctx = object()
adapted = self._callFUT(ctx, IFoo, '')
self.assertTrue(adapted.__class__ is Baz)
self.assertTrue(adapted.context is ctx)
def test_named_w_provides_w_adapts(self):
from zope.interface import Interface
from zope.interface import implementer
from guillotina.component.globalregistry import get_global_components
class IFoo(Interface):
pass
class IBar(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
class Bar(object):
def __init__(self, context):
self.context = context
self._callFUT(Bar, (IFoo, ), IBar, "test")
gsm = get_global_components()
foo = Foo()
adapted = gsm.getAdapter(foo, IBar, name="test")
self.assertTrue(isinstance(adapted, Bar))
self.assertTrue(adapted.context is foo)
def test_w_provides_w_adapts(self):
from zope.interface import Interface
from zope.interface import implementer
from guillotina.component.globalregistry import get_global_components
class IFoo(Interface):
pass
class IBar(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
class Bar(object):
def __init__(self, context):
self.context = context
self._callFUT(Bar, (IFoo, ), IBar)
gsm = get_global_components()
foo = Foo()
adapted = gsm.subscribers((foo, ), IBar)
self.assertEqual(len(adapted), 1)
self.assertTrue(isinstance(adapted[0], Bar))
self.assertTrue(adapted[0].context is foo)
def test_no_adapts(self):
from zope.interface import Interface
from zope.interface import implementer
from zope.interface import providedBy
from guillotina.component.globalregistry import get_global_components
from guillotina.component._declaration import adapter
class IFoo(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
@adapter(IFoo)
def _handler(context):
assert 0, "DON'T GO HERE"
self._callFUT(_handler)
gsm = get_global_components()
regs = list(gsm.registeredHandlers())
self.assertEqual(len(regs), 1)
hr = regs[0]
self.assertEqual(list(hr.required), list(providedBy(Foo())))
self.assertEqual(hr.name, "")
self.assertTrue(hr.factory is _handler)
def test_nested(self):
from zope.interface import Interface
from zope.interface import implementer
from zope.interface.registry import Components
from guillotina.component import get_global_components
from guillotina.component.tests.examples import ConformsToIComponentLookup
class IFoo(Interface):
pass
class IBar(Interface):
pass
@implementer(IFoo)
class Global(object):
def __init__(self, context):
self.context = context
@implementer(IFoo)
class Local(object):
def __init__(self, context):
self.context = context
@implementer(IBar)
class Bar(object):
pass
class Context(ConformsToIComponentLookup):
def __init__(self, sm):
self.sitemanager = sm
gsm = get_global_components()
gsm.registerAdapter(Global, (IBar,), IFoo, '')
sm1 = Components('sm1', bases=(gsm, ))
sm1.registerAdapter(Local, (IBar,), IFoo, '')
bar = Bar()
adapted = self._callFUT(bar, IFoo, '', context=Context(sm1))
self.assertTrue(adapted.__class__ is Local)
self.assertTrue(adapted.context is bar)
def test_hit(self):
from guillotina.component import get_global_components
from zope.interface import Interface
from zope.interface import implementer
class IFoo(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
_called = []
def _bar(context):
_called.append("_bar")
def _baz(context):
_called.append("_baz")
gsm = get_global_components()
gsm.registerHandler(_bar, (IFoo, ))
gsm.registerHandler(_baz, (IFoo, ))
self._callFUT(Foo())
self.assertEqual(len(_called), 2, _called)
self.assertTrue("_bar" in _called)
self.assertTrue("_baz" in _called)
def test_anonymous_no_provides_no_adapts(self):
from zope.interface import Interface
from zope.interface import implementer
from guillotina.component.globalregistry import get_global_components
from guillotina.component._declaration import adapter
class IFoo(Interface):
pass
class IBar(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
@adapter(IFoo)
@implementer(IBar)
class Bar(object):
def __init__(self, context):
self.context = context
self._callFUT(Bar)
gsm = get_global_components()
foo = Foo()
adapted = gsm.getAdapter(foo, IBar)
self.assertTrue(isinstance(adapted, Bar))
self.assertTrue(adapted.context is foo)
def test_w_conforming_context(self):
from zope.interface import Interface
from guillotina.component import get_global_components
from guillotina.component.tests.examples import ConformsToIComponentLookup
class SM(object):
def __init__(self, obj):
self._obj = obj
def queryUtility(self, interface, name, default):
return self._obj
class IFoo(Interface):
pass
obj1 = object()
obj2 = object()
sm = SM(obj2)
context = ConformsToIComponentLookup(sm)
get_global_components().registerUtility(obj1, IFoo)
self.assertTrue(self._callFUT(IFoo, context=context) is obj2)
def test_get_component_registry_w_invalid_context_w_adapter(self):
from zope.interface import Interface
from guillotina.component.globalregistry import get_global_components
from guillotina.component.interfaces import IComponentLookup
gsm = get_global_components()
sm = object()
def _adapt(x):
return sm
gsm.registerAdapter(_adapt, (Interface,), IComponentLookup, '')
self.assertTrue(self._callFUT(object()) is sm)
def test_anonymous_hit(self):
from zope.interface import Interface
from zope.interface import implementer
from guillotina.component import get_global_components
class IFoo(Interface):
pass
class IBar(Interface):
pass
@implementer(IBar)
class Bar(object):
pass
@implementer(IFoo)
class Baz(object):
def __init__(self, context):
self.context = context
get_global_components().registerAdapter(Baz, (IBar,), IFoo, '')
bar = Bar()
adapted = self._callFUT(bar, IFoo, '')
self.assertTrue(adapted.__class__ is Baz)
self.assertTrue(adapted.context is bar)
def test_named_w_provides(self):
from zope.interface import Interface
from guillotina.component.globalregistry import get_global_components
class IFoo(Interface):
pass
class Foo(object):
pass
foo = Foo()
self._callFUT(foo, IFoo, 'named')
gsm = get_global_components()
self.assertTrue(gsm.getUtility(IFoo, 'named') is foo)
def test_anonymous_no_provides(self):
from zope.interface import Interface
from zope.interface import implementer
from guillotina.component.globalregistry import get_global_components
class IFoo(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
foo = Foo()
self._callFUT(foo)
gsm = get_global_components()
self.assertTrue(gsm.getUtility(IFoo, '') is foo)
def test_it(self):
from zope.interface import Interface
from guillotina.component.globalregistry import get_global_components
from guillotina.component.event import dispatch
_adapted = []
def _adapter(context):
_adapted.append(context)
return object()
gsm = get_global_components()
gsm.registerHandler(_adapter, (Interface,))
del _adapted[:] # clear handler reg
event = object()
dispatch(event)
self.assertEqual(_adapted, [event])
def test_named_w_provides(self):
from zope.interface import Interface
from guillotina.component.globalregistry import get_global_components
class IFoo(Interface):
pass
class Foo(object):
pass
foo = Foo()
self._callFUT(foo, IFoo, "named")
gsm = get_global_components()
self.assertTrue(gsm.getUtility(IFoo, "named") is foo)
def test_w_adapts(self):
from zope.interface import Interface
from guillotina.component.globalregistry import get_global_components
class IFoo(Interface):
pass
def _handler(context):
assert 0, "DON'T GO HERE"
self._callFUT(_handler, (IFoo,))
gsm = get_global_components()
regs = list(gsm.registeredHandlers())
self.assertEqual(len(regs), 1)
hr = regs[0]
self.assertEqual(list(hr.required), [IFoo])
self.assertEqual(hr.name, '')
self.assertTrue(hr.factory is _handler)
def test_anonymous_no_provides(self):
from zope.interface import Interface
from zope.interface import implementer
from guillotina.component.globalregistry import get_global_components
class IFoo(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
foo = Foo()
self._callFUT(foo)
gsm = get_global_components()
self.assertTrue(gsm.getUtility(IFoo, "") is foo)
def test_it(self):
from zope.interface import Interface
from guillotina.component.globalregistry import get_global_components
from guillotina.component.event import dispatch
_adapted = []
def _adapter(context):
_adapted.append(context)
return object()
gsm = get_global_components()
gsm.registerHandler(_adapter, (Interface, ))
del _adapted[:] # clear handler reg
event = object()
dispatch(event)
self.assertEqual(_adapted, [event])
def test_w_adapts(self):
from zope.interface import Interface
from guillotina.component.globalregistry import get_global_components
class IFoo(Interface):
pass
def _handler(context):
assert 0, "DON'T GO HERE"
self._callFUT(_handler, (IFoo, ))
gsm = get_global_components()
regs = list(gsm.registeredHandlers())
self.assertEqual(len(regs), 1)
hr = regs[0]
self.assertEqual(list(hr.required), [IFoo])
self.assertEqual(hr.name, "")
self.assertTrue(hr.factory is _handler)
def test_hit(self):
from zope.interface import Interface
from guillotina.component import get_global_components
class IFoo(Interface):
pass
class BarAdapter(object):
def __init__(self, context):
self.context = context
class BazAdapter(object):
def __init__(self, context):
self.context = context
gsm = get_global_components()
gsm.registerAdapter(BarAdapter, (None,), IFoo)
gsm.registerAdapter(BazAdapter, (None,), IFoo, name='bar')
tuples = list(self._callFUT((object(),), IFoo))
self.assertEqual(len(tuples), 2)
names = [(x, y.__class__.__name__) for x, y in tuples]
self.assertTrue(('', 'BarAdapter') in names)
self.assertTrue(('bar', 'BazAdapter') in names)
def test_hit(self):
from zope.interface import Interface
from guillotina.component import get_global_components
class IFoo(Interface):
pass
class BarAdapter(object):
def __init__(self, context):
self.context = context
class BazAdapter(object):
def __init__(self, context):
self.context = context
gsm = get_global_components()
gsm.registerSubscriptionAdapter(BarAdapter, (None,), IFoo)
gsm.registerSubscriptionAdapter(BazAdapter, (None,), IFoo)
subscribers = self._callFUT((object(),), IFoo)
self.assertEqual(len(subscribers), 2)
names = [(x.__class__.__name__) for x in subscribers]
self.assertTrue('BarAdapter' in names)
self.assertTrue('BazAdapter' in names)
def test_named_w_provides_w_adapts(self):
from zope.interface import Interface
from zope.interface import implementer
from guillotina.component.globalregistry import get_global_components
class IFoo(Interface):
pass
class IBar(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
class Bar(object):
def __init__(self, context):
self.context = context
self._callFUT(Bar, (IFoo,), IBar, 'test')
gsm = get_global_components()
foo = Foo()
adapted = gsm.getAdapter(foo, IBar, name='test')
self.assertTrue(isinstance(adapted, Bar))
self.assertTrue(adapted.context is foo)
def test_hit(self):
from guillotina.component import get_global_components
from zope.interface import Interface
from zope.interface import implementer
class IFoo(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
_called = []
def _bar(context):
_called.append('_bar')
def _baz(context):
_called.append('_baz')
gsm = get_global_components()
gsm.registerHandler(_bar, (IFoo,))
gsm.registerHandler(_baz, (IFoo,))
self._callFUT(Foo())
self.assertEqual(len(_called), 2, _called)
self.assertTrue('_bar' in _called)
self.assertTrue('_baz' in _called)
def test_w_provides_w_adapts(self):
from zope.interface import Interface
from zope.interface import implementer
from guillotina.component.globalregistry import get_global_components
class IFoo(Interface):
pass
class IBar(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
class Bar(object):
def __init__(self, context):
self.context = context
self._callFUT(Bar, (IFoo,), IBar)
gsm = get_global_components()
foo = Foo()
adapted = gsm.subscribers((foo,), IBar)
self.assertEqual(len(adapted), 1)
self.assertTrue(isinstance(adapted[0], Bar))
self.assertTrue(adapted[0].context is foo)
def test_no_adapts(self):
from zope.interface import Interface
from zope.interface import implementer
from zope.interface import providedBy
from guillotina.component.globalregistry import get_global_components
from guillotina.component._declaration import adapter
class IFoo(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
@adapter(IFoo)
def _handler(context):
assert 0, "DON'T GO HERE"
self._callFUT(_handler)
gsm = get_global_components()
regs = list(gsm.registeredHandlers())
self.assertEqual(len(regs), 1)
hr = regs[0]
self.assertEqual(list(hr.required), list(providedBy(Foo())))
self.assertEqual(hr.name, '')
self.assertTrue(hr.factory is _handler)
def test_anonymous_no_provides_no_adapts(self):
from zope.interface import Interface
from zope.interface import implementer
from guillotina.component.globalregistry import get_global_components
from guillotina.component._declaration import adapter
class IFoo(Interface):
pass
class IBar(Interface):
pass
@implementer(IFoo)
class Foo(object):
pass
@adapter(IFoo)
@implementer(IBar)
class Bar(object):
def __init__(self, context):
self.context = context
self._callFUT(Bar)
gsm = get_global_components()
foo = Foo()
adapted = gsm.getAdapter(foo, IBar)
self.assertTrue(isinstance(adapted, Bar))
self.assertTrue(adapted.context is foo)
def test_hit(self):
from zope.interface import Interface
from guillotina.component import get_global_components
class IFoo(Interface):
pass
class IBar(IFoo):
pass
obj = object()
obj1 = object()
obj2 = object()
get_global_components().registerUtility(obj, IFoo)
get_global_components().registerUtility(obj1, IFoo, name='bar')
get_global_components().registerUtility(obj2, IBar)
uts = list(self._callFUT(IFoo))
self.assertEqual(len(uts), 3)
self.assertTrue(obj in uts)
self.assertTrue(obj1 in uts)
self.assertTrue(obj2 in uts)
def _callFUT(self):
from guillotina.component.globalregistry import get_global_components
return get_global_components()
def _callFUT(self):
from guillotina.component.globalregistry import get_global_components
return get_global_components()
