def test_adapts(self):
from zope.component import adaptedBy
from Products.CMFCore.interfaces import ICatalogTool
w = self._getTargetClass()
adapts = adaptedBy(w)
self.assertEqual(adapts, (IContentish, ICatalogTool))
def test_adapts(self):
from zope.component import adaptedBy
from Products.CMFCore.interfaces import ICatalogTool
w = self._getTargetClass()
adapts = adaptedBy(w)
self.assertEqual(adapts, (IContentish, ICatalogTool))
def test_adapts_correct(self):
descriminators = adaptedBy(self.adapter_class)
self.assertEqual(len(descriminators), 3)
context_iface, request_iface, layout_iface = descriminators
self.assertTrue(issubclass(context_iface, Interface))
self.assertTrue(issubclass(request_iface, Interface))
self.assertTrue(issubclass(layout_iface, ICustomizableLayout))
def register_adapter(cls, from_=None, to_=None, name=None):
from_ = from_ or adaptedBy(cls)
if not isinstance(from_, (list, tuple)):
from_ = (from_, )
reg = get_registry()
reg.registerAdapter(cls,
required=from_,
provided=to_ or get_interface(cls),
name=name or getattr(cls, 'name', ''))
def test_long_poll_event(self):
# long_poll_event is a class decorator that declares a class as an
# ILongPollEvent.
@long_poll_event(IEventSourceInterface)
class Something:
"""An example event source."""
self.assertTrue(ILongPollEvent.implementedBy(Something))
self.assertEqual((IEventSourceInterface, ), adaptedBy(Something))
def test_long_poll_event(self):
# long_poll_event is a class decorator that declares a class as an
# ILongPollEvent.
@long_poll_event(IEventSourceInterface)
class Something:
"""An example event source."""
self.assertTrue(ILongPollEvent.implementedBy(Something))
self.assertEqual(
(IEventSourceInterface,),
adaptedBy(Something))
def test_datamap_applied_time_logger(t, log):
'''notify(DatamapAppliedEvent) triggers rate_gauge
'''
t.assertIn(DatamapAppliedEvent,
component.adaptedBy(datamap_applied_time_logger))
t0, t1 = 1, 3
datamap = Mock(start_time=t0, end_time=t1)
event = DatamapAppliedEvent(datamap)
datamap_applied_time_logger(event)
log.info.assert_called_with(
"{'meta_type': '%s', 'start_time': %s, 'end_time': %s, 'dt': %s}",
datamap.target.meta_type, t0, t1, t1 - t0)
def test_onHubCreated(self):
'''this method gets triggered by a IHubCreatedEvent event
'''
# Is an adapter for IHubCreatedEvent type events
self.assertEqual(list(adaptedBy(InvalidationProcessor.onHubCreated)),
[IHubCreatedEvent])
IHubCreatedEventMock = create_interface_mock(IHubCreatedEvent)
event = IHubCreatedEventMock()
self.ip._hub_ready = Mock(spec_set=defer.Deferred)
self.ip.onHubCreated(event)
# _hub is set to the hub specified in the IHubCreatedEvent
self.assertEqual(self.ip._hub, event.hub)
# the _hub_ready deffered gets called back / triggered
self.ip._hub_ready.callback.assert_called_with(self.ip._hub)
def test_onHubCreated(self):
'''this method gets triggered by a IHubCreatedEvent event
'''
# Is an adapter for IHubCreatedEvent type events
self.assertEqual(
list(adaptedBy(InvalidationProcessor.onHubCreated)),
[IHubCreatedEvent]
)
IHubCreatedEventMock = create_interface_mock(IHubCreatedEvent)
event = IHubCreatedEventMock()
self.ip._hub_ready = Mock(spec_set=defer.Deferred)
self.ip.onHubCreated(event)
# _hub is set to the hub specified in the IHubCreatedEvent
self.assertEqual(self.ip._hub, event.hub)
# the _hub_ready deffered gets called back / triggered
self.ip._hub_ready.callback.assert_called_with(self.ip._hub)
def adapter(_context, factory, provides=None, for_=None, name=''):
if for_ is None:
if len(factory) == 1:
for_ = adaptedBy(factory[0])
if for_ is None:
raise TypeError("No for attribute was provided and can't "
"determine what the factory adapts.")
for_ = tuple(for_)
if provides is None:
if len(factory) == 1:
p = list(implementedBy(factory[0]))
if len(p) == 1:
provides = p[0]
if provides is None:
raise TypeError("Missing 'provides' attribute")
# Generate a single factory from multiple factories:
factories = factory
if len(factories) == 1:
factory = factories[0]
elif len(factories) < 1:
raise ValueError("No factory specified")
elif len(factories) > 1 and len(for_) != 1:
raise ValueError("Can't use multiple factories and multiple for")
else:
factory = _rolledUpFactory(factories)
_context.action(
discriminator = ('adapter', for_, provides, name),
callable = handler,
args = ('registerAdapter',
factory, for_, provides, name, _context.info),
)
def execute(self, factory, config, provides, name, **kw):
specs = adaptedBy(factory)
context = grokcore.component.context.bind(get_default=lambda *args, **kwargs: None).get(factory)
validated_specs = []
if specs is None:
if context is not None:
validated_specs = [context]
else:
default = context is not None and context or Interface
for value in specs:
if value is None:
validated_specs.append(default)
elif ISpecification.providedBy(value) or isclass(value):
validated_specs.append(value)
else:
raise GrokError(u"Invalid adaption argument %r for %r" % (value, factory))
validated_specs = tuple(validated_specs)
config.action(
discriminator=("component", validated_specs, provides, name),
callable=getSite().register,
args=(factory, validated_specs, provides, name),
)
return True
def subscriber(_context, for_=None, factory=None, handler=None, provides=None):
if factory is None:
if handler is None:
raise TypeError("No factory or handler provided")
if provides is not None:
raise TypeError("Cannot use handler with provides")
factory = handler
else:
if handler is not None:
raise TypeError("Cannot use handler with factory")
if provides is None:
raise TypeError(
"You must specify a provided interface when registering "
"a factory")
if for_ is None:
for_ = adaptedBy(factory)
if for_ is None:
raise TypeError("No for attribute was provided and can't "
"determine what the factory (or handler) adapts.")
for_ = tuple(for_)
if handler is not None:
_context.action(
discriminator = None,
callable = _handler,
args = ('registerHandler',
handler, for_, BLANK, _context.info),
)
else:
_context.action(
discriminator = None,
callable = _handler,
args = ('registerSubscriptionAdapter',
factory, for_, provides, BLANK, _context.info),
)
def adapter(_context, factory, provides=None, for_=None, name=''):
if for_ is None:
if len(factory) == 1:
for_ = adaptedBy(factory[0])
if for_ is None:
raise TypeError("No for attribute was provided and can't "
"determine what the factory adapts.")
for_ = tuple(for_)
if provides is None:
if len(factory) == 1:
p = list(implementedBy(factory[0]))
if len(p) == 1:
provides = p[0]
if provides is None:
raise TypeError("Missing 'provides' attribute")
# Generate a single factory from multiple factories:
factories = factory
if len(factories) == 1:
factory = factories[0]
elif len(factories) < 1:
raise ValueError("No factory specified")
elif len(factories) > 1 and len(for_) != 1:
raise ValueError("Can't use multiple factories and multiple for")
else:
factory = _rolledUpFactory(factories)
_context.action(
discriminator=('adapter', for_, provides, name),
callable=handler,
args=('registerAdapter', factory, for_, provides, name, _context.info),
)
def subscriber(_context, for_=None, factory=None, handler=None, provides=None):
if factory is None:
if handler is None:
raise TypeError("No factory or handler provided")
if provides is not None:
raise TypeError("Cannot use handler with provides")
factory = handler
else:
if handler is not None:
raise TypeError("Cannot use handler with factory")
if provides is None:
raise TypeError(
"You must specify a provided interface when registering "
"a factory")
if for_ is None:
for_ = adaptedBy(factory)
if for_ is None:
raise TypeError("No for attribute was provided and can't "
"determine what the factory (or handler) adapts.")
for_ = tuple(for_)
if handler is not None:
_context.action(
discriminator=None,
callable=_handler,
args=('registerHandler', handler, for_, BLANK, _context.info),
)
else:
_context.action(
discriminator=None,
callable=_handler,
args=('registerSubscriptionAdapter', factory, for_, provides,
BLANK, _context.info),
)
def subscriber(_context, for_=None, factory=None, handler=None, provides=None,
permission=None, trusted=False):
if factory is None:
if handler is None:
raise TypeError("No factory or handler provided")
if provides is not None:
raise TypeError("Cannot use handler with provides")
factory = handler
else:
if handler is not None:
raise TypeError("Cannot use handler with factory")
if provides is None:
import warnings
warnings.warn(
"Use of factory without provides to indicate a handler "
"is deprecated and will change it's meaning in Zope X3.3. "
"Use the handler attribute instead.",
DeprecationWarning)
if for_ is None:
for_ = component.adaptedBy(factory)
if for_ is None:
raise TypeError("No for attribute was provided and can't "
"determine what the factory (or handler) adapts.")
factory = [factory]
if permission is not None:
if permission == PublicPermission:
permission = CheckerPublic
checker = InterfaceChecker(provides, permission)
factory.append(lambda c: proxify(c, checker))
for_ = tuple(for_)
# Generate a single factory from multiple factories:
factories = factory
if len(factories) == 1:
factory = factories[0]
elif len(factories) < 1:
raise ValueError("No factory specified")
elif len(factories) > 1 and len(for_) != 1:
raise ValueError("Can't use multiple factories and multiple for")
else:
def factory(ob):
for f in factories:
ob = f(ob)
return ob
if trusted:
factory = TrustedAdapterFactory(factory)
_context.action(
discriminator = None,
callable = _handler,
args = ('subscribe',
for_, provides, factory),
)
if provides is not None:
_context.action(
discriminator = None,
callable = provideInterface,
args = ('', provides)
)
# For each interface, state that the adapter provides that interface.
for iface in for_:
if iface is not None:
_context.action(
discriminator = None,
callable = provideInterface,
args = ('', iface)
)
def test_adapts_ZenHub(t):
t.assertIn(ZenHub, adaptedBy(DefaultHubHeartBeatCheck))
def test_adapts_ZenHub(t):
t.assertEqual(
adaptedBy(DefaultConfProvider), (ZenHub, )
)
t.assertIn(ZenHub, adaptedBy(DefaultConfProvider))
def test_adapts_ZenHub(t):
t.assertIn(ZenHub, adaptedBy(DefaultHubHeartBeatCheck))
def test_adapts_ZenHub(t):
t.assertEqual(
adaptedBy(DefaultConfProvider),
(ZenHub, ),
)
t.assertIn(ZenHub, adaptedBy(DefaultConfProvider))
def test_adapts_landscape_request_layer(self):
self.replay()
adapts = adaptedBy(LandscapeLayout)
self.assertEqual(len(adapts), 3)
self.assertEqual(adapts[1], ILandscapeLayer)
def test_adapts_PrimaryPathObjectManager(self):
self.assertEqual(list(adaptedBy(DefaultOidTransform)),
[PrimaryPathObjectManager])
def test_adapts(self):
# BaseLayout should adapt three things (context, request, builder).
self.assertEquals(len(adaptedBy(BaseLayout)), 3)
def test_adapts_layer(self):
self.replay()
context_iface, request_iface, layout_iface = adaptedBy(
opentaskreport.OpenTaskReportLaTeXView)
self.assertEqual(request_iface, opentaskreport.IOpenTaskReportLayer)
def adapter(_context, factory, provides=None, for_=None, permission=None,
name='', trusted=False, locate=False):
if for_ is None:
if len(factory) == 1:
for_ = component.adaptedBy(factory[0])
if for_ is None:
raise TypeError("No for attribute was provided and can't "
"determine what the factory adapts.")
for_ = tuple(for_)
if provides is None:
if len(factory) == 1:
p = list(zope.interface.implementedBy(factory[0]))
if len(p) == 1:
provides = p[0]
if provides is None:
raise TypeError("Missing 'provides' attribute")
# Generate a single factory from multiple factories:
factories = factory
if len(factories) == 1:
factory = factories[0]
elif len(factories) < 1:
raise ValueError("No factory specified")
elif len(factories) > 1 and len(for_) != 1:
raise ValueError("Can't use multiple factories and multiple for")
else:
factory = _rolledUpFactory(factories)
if permission is not None:
if permission == PublicPermission:
permission = CheckerPublic
checker = InterfaceChecker(provides, permission)
factory = _protectedFactory(factory, checker)
# invoke custom adapter factories
if locate or (permission is not None and permission is not CheckerPublic):
if trusted:
factory = LocatingTrustedAdapterFactory(factory)
else:
factory = LocatingUntrustedAdapterFactory(factory)
else:
if trusted:
factory = TrustedAdapterFactory(factory)
_context.action(
discriminator = ('adapter', for_, provides, name),
callable = handler,
args = ('provideAdapter',
for_, provides, name, factory, _context.info),
)
_context.action(
discriminator = None,
callable = provideInterface,
args = ('', provides)
)
if for_:
for iface in for_:
if iface is not None:
_context.action(
discriminator = None,
callable = provideInterface,
args = ('', iface)
)
def test_adapts_layer(self):
context_iface, request_iface, layout_iface = adaptedBy(
dossierlisting.DossierListingLaTeXView)
self.assertEqual(request_iface, dossierlisting.IDossierListingLayer)
def test_adapts_layer(self):
context_iface, request_iface, layout_iface = adaptedBy(
dossierlisting.DossierListingLaTeXView)
self.assertEqual(request_iface, dossierlisting.IDossierListingLayer)
def check_adapts(class_):
if component.adaptedBy(class_) is None:
raise GrokError("%r must specify which contexts it adapts "
"(use grok.adapts to specify)."
% class_, class_)
def test_adapts_layer(self):
self.replay()
context_iface, request_iface, layout_iface = adaptedBy(
opentaskreport.OpenTaskReportLaTeXView)
self.assertEqual(request_iface, opentaskreport.IOpenTaskReportLayer)
def subscriber(_context, for_=None, factory=None, handler=None, provides=None,
permission=None, trusted=False, locate=False):
if factory is None:
if handler is None:
raise TypeError("No factory or handler provided")
if provides is not None:
raise TypeError("Cannot use handler with provides")
factory = handler
else:
if handler is not None:
raise TypeError("Cannot use handler with factory")
if provides is None:
import warnings
warnings.warn(
"\n %s\n"
"Use of factory without provides to indicate a handler "
"is deprecated and will change it's meaning in Zope 3.3. "
"Use the handler attribute instead."
% _context.info,
DeprecationWarning)
if for_ is None:
for_ = component.adaptedBy(factory)
if for_ is None:
raise TypeError("No for attribute was provided and can't "
"determine what the factory (or handler) adapts.")
if permission is not None:
if permission == PublicPermission:
permission = CheckerPublic
checker = InterfaceChecker(provides, permission)
factory = _protectedFactory(factory, checker)
for_ = tuple(for_)
# invoke custom adapter factories
if locate or (permission is not None and permission is not CheckerPublic):
if trusted:
factory = LocatingTrustedAdapterFactory(factory)
else:
factory = LocatingUntrustedAdapterFactory(factory)
else:
if trusted:
factory = TrustedAdapterFactory(factory)
_context.action(
discriminator = None,
callable = _handler,
args = ('subscribe',
for_, provides, factory, _context.info),
)
if provides is not None:
_context.action(
discriminator = None,
callable = provideInterface,
args = ('', provides)
)
# For each interface, state that the adapter provides that interface.
for iface in for_:
if iface is not None:
_context.action(
discriminator = None,
callable = provideInterface,
args = ('', iface)
)
def test_adapts_landscape_request_layer(self):
self.replay()
adapts = adaptedBy(LandscapeLayout)
self.assertEqual(len(adapts), 3)
self.assertEqual(adapts[1], ILandscapeLayer)
