def test_named_hit(self):
     from zope.interface import Interface
     from zope.interface import implementer
     from zope.component import getGlobalSiteManager
     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
     getGlobalSiteManager().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_hit(self):
     from zope.interface import Interface
     from zope.component import getGlobalSiteManager
     class IFoo(Interface):
         pass
     obj = object()
     obj1 = object()
     getGlobalSiteManager().registerUtility(obj, IFoo)
     getGlobalSiteManager().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 zope.component import getGlobalSiteManager
     class IFoo(Interface):
         pass
     @implementer(IFoo)
     class Baz(object):
         def __init__(self, context):
             self.context = context
     getGlobalSiteManager().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_hit_via_sm(self):
     from zope.interface import Interface
     from zope.interface import implementer
     from zope.interface.registry import Components
     from zope.component import getGlobalSiteManager
     from zope.component.tests.examples import ConformsToIComponentLookup
     class IFoo(Interface):
         pass
     class IBar(Interface):
         pass
     @implementer(IFoo)
     class Global(object):
         __init__ = fails_if_called(self)
     @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 = getGlobalSiteManager()
     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_w_None(self):
     from zope.component import hooks
     from zope.component.globalregistry import getGlobalSiteManager
     gsm = getGlobalSiteManager()
     siteinfo = _DummySiteInfo()
     with _Monkey(hooks, siteinfo=siteinfo):
         self.assertTrue(self._callFUT() is None)

 def test_w_conforming_context(self):
     from zope.interface import Interface
     from zope.component import getGlobalSiteManager
     from zope.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)
     getGlobalSiteManager().registerUtility(obj1, IFoo)
     self.assertTrue(self._callFUT(IFoo, context=context) is obj2)

 def test_global(self):
     from zope.component import getGlobalSiteManager
     from zope.component.interface import ComponentLookupError
     gsm = getGlobalSiteManager()
     gutil = _makeMyUtility('global', gsm)
     gsm.registerUtility(gutil, IMyUtility, 'myutil')
     self.assertRaises(ComponentLookupError,
                       self._callFUT, gutil, IMyUtility, 'myutil')

 def test_hit(self):
     from zope.interface import Interface
     from zope.interface.interfaces import IInterface
     from zope.component.globalregistry import getGlobalSiteManager
     gsm = getGlobalSiteManager()
     class IFoo(Interface):
         pass
     gsm.registerUtility(IFoo, IInterface, 'foo')
     self.assertTrue(self._callFUT(object(), 'foo') is IFoo)

    def _getTraverser(self, context, request):
        class FakeCaseInsensitiveConfiglet(object):
            implements(ICaseInsensitiveConfiglet)
            isNonCaseInsensitive = True

        gsm = getGlobalSiteManager()
        fakeCIC = FakeCaseInsensitiveConfiglet()
        gsm.registerUtility(fakeCIC)
        return CaseInsensitiveFolderTraverser(context, request)

 def test_no_search_string_no_base(self):
     from zope.interface import Interface
     from zope.interface.interfaces import IInterface
     from zope.component.globalregistry import getGlobalSiteManager
     gsm = getGlobalSiteManager()
     class IFoo(Interface):
         pass
     gsm.registerUtility(IFoo, IInterface, 'foo')
     self.assertEqual(self._callFUT(object()), [('foo', IFoo)])

 def test_default(self):
     from zope.component import hooks
     from zope.component.globalregistry import getGlobalSiteManager
     gsm = getGlobalSiteManager()
     _SM2 = object()
     siteinfo = _DummySiteInfo()
     siteinfo.sm = _SM2
     with _Monkey(hooks, siteinfo=siteinfo):
         self.assertTrue(self._callFUT() is _SM2)

 def test_w_explicit_context_no_IComponentLookup(self):
     from zope.component import hooks
     from zope.component.globalregistry import getGlobalSiteManager
     gsm = getGlobalSiteManager()
     _SM2 = object()
     siteinfo = _DummySiteInfo()
     siteinfo.sm = _SM2
     with _Monkey(hooks, siteinfo=siteinfo):
         self.assertTrue(self._callFUT(object()) is gsm)

 def test_w_registered(self):
     from zope.interface import Interface
     from zope.interface.interfaces import IInterface
     from zope.component.globalregistry import getGlobalSiteManager
     gsm = getGlobalSiteManager()
     class IFoo(Interface):
         pass
     gsm.registerUtility(IFoo, IInterface, 'foo')
     self.assertEqual(self._callFUT(object(), IFoo),
                      'zope.component.tests.test_interface.IFoo')

 def test_getSiteManager_w_invalid_context_w_adapter(self):
     from zope.interface import Interface
     from zope.component.globalregistry import getGlobalSiteManager
     from zope.interface.interfaces import IComponentLookup
     gsm = getGlobalSiteManager()
     sm = object()
     def _adapt(x):
         return sm
     gsm.registerAdapter(_adapt, (Interface,), IComponentLookup, '')
     self.assertTrue(self._callFUT(object()) is sm)

 def test_w_name_wo_ifact_type(self):
     from zope.interface import Interface
     from zope.interface.interfaces import IInterface
     from zope.component.globalregistry import getGlobalSiteManager
     gsm = getGlobalSiteManager()
     class IFoo(Interface):
         pass
     self._callFUT('foo', IFoo)
     self.assertTrue(IInterface.providedBy(IFoo))
     registered = gsm.getUtility(IInterface, name='foo')
     self.assertTrue(registered is IFoo)

 def test_named_w_provides(self):
     from zope.interface import Interface
     from zope.component.globalregistry import getGlobalSiteManager
     class IFoo(Interface):
         pass
     class Foo(object):
         pass
     foo = Foo()
     self._callFUT(foo, IFoo, 'named')
     gsm = getGlobalSiteManager()
     self.assertTrue(gsm.getUtility(IFoo, 'named') is foo)

    def makeSite(self):
        if IObjectManagerSite.providedBy(self.context):
            raise ValueError('This is already a site')

        enableSite(self.context, iface=IObjectManagerSite)

        # TODO in the future we'll have to walk up to other site
        # managers and put them in the bases
        components = PersistentComponents()
        components.__bases__ = (getGlobalSiteManager(),)
        self.context.setSiteManager(components)

 def test_w_class(self):
     from zope.interface.interfaces import IInterface
     from zope.component.globalregistry import getGlobalSiteManager
     gsm = getGlobalSiteManager()
     class IBar(IInterface):
         pass
     class Foo(object):
         pass
     self._callFUT('', Foo, IBar)
     self.assertFalse(IBar.providedBy(Foo))
     self.assertEqual(len(list(gsm.getUtilitiesFor(IBar))), 0)

 def test_wo_name_w_iface_type(self):
     from zope.interface import Interface
     from zope.interface.interfaces import IInterface
     from zope.component.globalregistry import getGlobalSiteManager
     gsm = getGlobalSiteManager()
     class IFoo(Interface):
         pass
     class IBar(IInterface):
         pass
     self._callFUT('', IFoo, IBar)
     self.assertTrue(IBar.providedBy(IFoo))
     nm = 'zope.component.tests.test_interface.IFoo'
     self.assertTrue(gsm.getUtility(IBar, nm) is IFoo)

 def test_anonymous_no_provides(self):
     from zope.interface import Interface
     from zope.interface import implementer
     from zope.component.globalregistry import getGlobalSiteManager
     class IFoo(Interface):
         pass
     @implementer(IFoo)
     class Foo(object):
         pass
     foo = Foo()
     self._callFUT(foo)
     gsm = getGlobalSiteManager()
     self.assertTrue(gsm.getUtility(IFoo, '') is foo)