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.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 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 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) )