Python Components.registerUtility方法代码示例

# 需要导入模块: from zope.interface.registry import Components [as 别名]
# 或者: from zope.interface.registry.Components import registerUtility [as 别名]
 def test_init_forwards_kw(self):
     from zope.interface import Interface
     from zope.interface.registry import Components
     dummy = object()
     c = Components()
     c.registerUtility(dummy, Interface)
     registry = self._makeOne(bases=(c,))
     self.assertEqual(registry.getUtility(Interface), dummy)

# 需要导入模块: from zope.interface.registry import Components [as 别名]
# 或者: from zope.interface.registry.Components import registerUtility [as 别名]
    def test_extendning(self):
        c1 = Components('1')
        self.assertEqual(c1.__bases__, ())

        c2 = Components('2', (c1, ))
        self.assertTrue(c2.__bases__ == (c1, ))

        test_object1 = U1(1)
        test_object2 = U1(2)
        test_object3 = U12(1)
        test_object4 = U12(3)

        self.assertEqual(len(list(c1.registeredUtilities())), 0)
        self.assertEqual(len(list(c2.registeredUtilities())), 0)

        c1.registerUtility(test_object1)
        self.assertEqual(len(list(c1.registeredUtilities())), 1)
        self.assertEqual(len(list(c2.registeredUtilities())), 0)
        self.assertEqual(c1.queryUtility(I1), test_object1)
        self.assertEqual(c2.queryUtility(I1), test_object1)

        c1.registerUtility(test_object2)
        self.assertEqual(len(list(c1.registeredUtilities())), 1)
        self.assertEqual(len(list(c2.registeredUtilities())), 0)
        self.assertEqual(c1.queryUtility(I1), test_object2)
        self.assertEqual(c2.queryUtility(I1), test_object2)


        c3 = Components('3', (c1, ))
        c4 = Components('4', (c2, c3))
        self.assertEqual(c4.queryUtility(I1), test_object2)
    
        c1.registerUtility(test_object3, I2)
        self.assertEqual(c4.queryUtility(I2), test_object3)

        c3.registerUtility(test_object4, I2)
        self.assertEqual(c4.queryUtility(I2), test_object4)

        @adapter(I1)
        def handle1(x):
            self.assertEqual(x, test_object1)

        def handle(*objects):
            self.assertEqual(objects, (test_object1,))

        @adapter(I1)
        def handle3(x):
            self.assertEqual(x, test_object1)

        @adapter(I1)
        def handle4(x):
            self.assertEqual(x, test_object1)

        c1.registerHandler(handle1, info=u'First handler')
        c2.registerHandler(handle, required=[U])
        c3.registerHandler(handle3)
        c4.registerHandler(handle4)

        c4.handle(test_object1)

# 需要导入模块: from zope.interface.registry import Components [as 别名]
# 或者: from zope.interface.registry.Components import registerUtility [as 别名]
 def test_nested(self):
     from zope.component import getGlobalSiteManager
     from zope.interface.interfaces import IComponentLookup
     from zope.interface.registry import Components
     gsm = getGlobalSiteManager()
     gutil = _makeMyUtility('global', gsm)
     gsm.registerUtility(gutil, IMyUtility, 'myutil')
     sm1 = Components('sm1', bases=(gsm, ))
     sm1_1 = Components('sm1_1', bases=(sm1, ))
     util1 = _makeMyUtility('one', sm1)
     sm1.registerUtility(util1, IMyUtility, 'myutil')
     self.assertTrue(IComponentLookup(util1) is sm1)
     self.assertTrue(self._callFUT(util1, IMyUtility, 'myutil') is gutil)
     util1_1 = _makeMyUtility('one-one', sm1_1)
     sm1_1.registerUtility(util1_1, IMyUtility, 'myutil')
     self.assertTrue(IComponentLookup(util1_1) is sm1_1)
     self.assertTrue(self._callFUT(util1_1, IMyUtility, 'myutil') is util1)

# 需要导入模块: from zope.interface.registry import Components [as 别名]
# 或者: from zope.interface.registry.Components import registerUtility [as 别名]
class PackageConfigurator(object):
    default_depth = 3

    def __init__(self, registry, resolve=None, target='includeme'):
        self.registry = registry
        self._resolve = resolve
        self._target = target
        self._depth = self.default_depth
        self._configurator_registry = Components()

    def add_configurator(self, configurator, name=''):
        self._configurator_registry.registerUtility(configurator, IConfigurator, name)

    def include(self, name, *args, **kwargs):
        _logger.debug('start include: name=%s, args=%s, kwds=%s', name, args, kwargs)
        includeme = name if callable(name) else get_includeme(name, resolve=self._resolve, depth=self._depth)
        _logger.debug('include -> %s.%s', includeme.__module__, includeme.__name__)
        return includeme(self)

    def scan(self, package=None, **kw):
        name = 'scan'
        if package is None:
            package = '.'

        if isinstance(package, (six.string_types, six.text_type, six.binary_type)):
            package = get_abs_dotted_name_caller_module(package, **kw)

        for cfg in self._configurator_registry.getAllUtilitiesRegisteredFor(IConfigurator):
            if hasattr(cfg, name) and callable(getattr(cfg, name)):
                _logger.debug('scanning...: %s: %s', cfg.__module__, package)
                cfg.scan(package)

    def __getattr__(self, name):
        if name.startswith('_'):
            raise AttributeError(name)

        configs = [cfg
                   for cfg in self._configurator_registry.getAllUtilitiesRegisteredFor(IConfigurator)
                   if hasattr(cfg, name) and callable(getattr(cfg, name))]

        if configs:
            for config in configs:
                return getattr(config, name)
        else:
            raise AttributeError(name)

# 需要导入模块: from zope.interface.registry import Components [as 别名]
# 或者: from zope.interface.registry.Components import registerUtility [as 别名]
 def test_passwords(self):
     from zope.interface.registry import Components
     from alpaca.common.domain.user import User
     from alpaca.common.utilities.interfaces import IPasswordProcessor
     from alpaca.common.utilities.pbkdf2_password_processor import (
         PBKDF2PasswordProcessor
     )
     processor = PBKDF2PasswordProcessor()
     registry = Components()
     registry.registerUtility(
         processor,
         IPasswordProcessor,
         'pbkdf2'
     )
     user = User()
     user.set_password('łąki łan 123', 'pbkdf2', processor)
     self.assertEqual(user.password_processor, 'pbkdf2')
     self.assertTrue(bool(user.password_hash))
     self.assertLessEqual(len(user.password_hash), 100)
     self.assertFalse(user.password_equals('łąki łany 123', registry))
     self.assertTrue(user.password_equals('łąki łan 123', registry))

# 需要导入模块: from zope.interface.registry import Components [as 别名]
# 或者: from zope.interface.registry.Components import registerUtility [as 别名]
def main(argv=sys.argv[1:]):
    reg = Components()
    reg.registerUtility(GoogleVisionAPIFaceDetection(),
                        IDetection, 'gcp')
    reg.registerUtility(MSProjectoxfordDetection(get_ms_param()['API_TOKEN']),
                        IDetection, 'ms')
    reg.registerUtility(AkamaiCrop(),
                        ICrop, 'akamai')

    parser = argparse.ArgumentParser()
    parser.add_argument('mode', help='gcp or ms')
    parser.add_argument('target', help='url or path')
    parser.add_argument('--crop', default='akamai')
    args = parser.parse_args(argv)

    detect = reg.queryUtility(IDetection, args.mode)
    result = detect(args.target)
    crop = AkamaiCrop()
    url = crop(result)
    print(url)

# 需要导入模块: from zope.interface.registry import Components [as 别名]
# 或者: from zope.interface.registry.Components import registerUtility [as 别名]
class TestUtility(unittest.TestCase):

    def setUp(self):
        self.components = Components('comps')

    def test_register_utility(self):
        test_object = U1(1)
        self.components.registerUtility(test_object)
        self.assertEqual(self.components.getUtility(I1), test_object)

    def test_register_utility_with_factory(self):
        test_object = U1(1)
        def factory():
           return test_object
        self.components.registerUtility(factory=factory)
        self.assertEqual(self.components.getUtility(I1), test_object)
        self.assertTrue(self.components.unregisterUtility(factory=factory))

    def test_register_utility_with_component_and_factory(self):
        def factory():
            return U1(1)
        self.assertRaises(
            TypeError,
            self.components.registerUtility, U1(1), factory=factory)

    def test_unregister_utility_with_and_without_component_and_factory(self):
        def factory():
            return U1(1)
        self.assertRaises(
            TypeError,
            self.components.unregisterUtility, U1(1), factory=factory)
        self.assertRaises(TypeError, self.components.unregisterUtility)

    def test_register_utility_with_no_interfaces(self):
        self.assertRaises(TypeError, self.components.registerUtility, A)

    def test_register_utility_with_two_interfaces(self):
        self.assertRaises(TypeError, self.components.registerUtility, U12(1))

    def test_register_utility_with_arguments(self):
        test_object1 = U12(1)
        test_object2 = U12(2)
        self.components.registerUtility(test_object1, I2)
        self.components.registerUtility(test_object2, I2, 'name')
        self.assertEqual(self.components.getUtility(I2), test_object1)
        self.assertEqual(self.components.getUtility(I2, 'name'), test_object2)

    def test_get_none_existing_utility(self):
        from zope.interface.interfaces import ComponentLookupError
        self.assertRaises(ComponentLookupError, self.components.getUtility, I3)

    def test_query_none_existing_utility(self):
        self.assertTrue(self.components.queryUtility(I3) is None)
        self.assertEqual(self.components.queryUtility(I3, default=42), 42)

    def test_registered_utilities_and_sorting(self):
        test_object1 = U1(1)
        test_object2 = U12(2)
        test_object3 = U12(3)
        self.components.registerUtility(test_object1)
        self.components.registerUtility(test_object3, I2, u'name')
        self.components.registerUtility(test_object2, I2)

        sorted_utilities = sorted(self.components.registeredUtilities())
        sorted_utilities_name = map(lambda x: getattr(x, 'name'),
                                    sorted_utilities)
        sorted_utilities_component = map(lambda x: getattr(x, 'component'),
                                         sorted_utilities)
        sorted_utilities_provided = map(lambda x: getattr(x, 'provided'),
                                        sorted_utilities)

        self.assertEqual(len(sorted_utilities), 3)
        self.assertEqual(sorted_utilities_name, [u'', u'', u'name'])
        self.assertEqual(
            sorted_utilities_component,
            [test_object1, test_object2, test_object3])
        self.assertEqual(sorted_utilities_provided, [I1, I2, I2])

    def test_duplicate_utility(self):
        test_object1 = U1(1)
        test_object2 = U12(2)
        test_object3 = U12(3)
        test_object4 = U1(4)
        self.components.registerUtility(test_object1)
        self.components.registerUtility(test_object2, I2)
        self.components.registerUtility(test_object3, I2, u'name')
        self.assertEqual(self.components.getUtility(I1), test_object1)

        self.components.registerUtility(test_object4, info=u'use 4 now')
        self.assertEqual(self.components.getUtility(I1), test_object4)

    def test_unregister_utility(self):
        test_object = U1(1)
        self.components.registerUtility(test_object)
        self.assertEqual(self.components.getUtility(I1), test_object)
        self.assertTrue(self.components.unregisterUtility(provided=I1))
        self.assertFalse(self.components.unregisterUtility(provided=I1))

    def test_unregister_utility_extended(self):
        test_object = U1(1)
#.........这里部分代码省略.........