def setUp(self):
        self.etree = etreeSetup(key = "py25")

        foofield = schema.Object(__name__ = self.name,
                                 title = u"Foo Title",
                                 description = u"Foo field",
                                 schema = ISimpleInterface)
        class IDemoContent(Interface):
            foo = foofield

        class DemoContent(object):
            implements(IDemoContent)

        self.field_content = SimpleObject(name = u"Michael Kerrin",
                                          age = 26)
        self.content = DemoContent()
        field = IDemoContent['foo']
        self.field = field.bind(self.content)
        self.setUpWidget()

        component.getGlobalSiteManager().registerAdapter(
            widgets.TextDAVWidget,
            (zope.schema.interfaces.ITextLine,
             z3c.dav.interfaces.IWebDAVRequest))
        component.getGlobalSiteManager().registerAdapter(
            widgets.IntDAVWidget,
            (zope.schema.interfaces.IInt,
             z3c.dav.interfaces.IWebDAVRequest))

    def test_query(self):
        from zope.site import SiteManagerAdapter
        from zope import component
        component.provideAdapter(SiteManagerAdapter)
        top_site = SiteManagerContainer()
        top_sm = LocalSiteManager(top_site)
        top_site.setSiteManager(top_sm)
        assert_that(top_sm.__parent__, is_(top_site))
        assert_that(top_site, provides(ISite))
        interface.alsoProvides(top_site, ILocationInfo)

        child_site = SiteManagerContainer()
        child_site.__parent__ = top_site
        child_site.getParent = lambda: child_site.__parent__
        interface.alsoProvides(child_site, ILocationInfo)
        child_sm = LocalSiteManager(child_site)
        child_site.setSiteManager(child_sm)

        assert_that(child_sm.__bases__, is_((top_sm,)))


        class IFoo(Interface):
            pass

        @interface.implementer(IFoo)
        class Foo(Contained):
            pass

        child_foo = Foo()
        top_foo = Foo()

        child_foo.__parent__ = child_site
        top_foo.__parent__ = top_site

        top_sm.registerUtility(top_foo, IFoo)
        child_sm.registerUtility(child_foo, IFoo)

        child_foo.__conform__ = lambda self, _:  child_sm
        from zope import component
        component.getSiteManager(child_foo)


        x = queryNextUtility(child_foo, IFoo)
        assert_that(x, is_(top_foo))

        class IBaz(Interface): pass

        x = queryNextUtility(child_foo, IBaz)
        assert_that(x, is_(none()))

        x = queryNextUtility(top_foo, IFoo)
        assert_that(x, is_(none()))

        x = queryNextUtility(component.getGlobalSiteManager(), IFoo)
        assert_that(x, is_(none()))

        global_foo = Foo()
        component.provideUtility(global_foo, IFoo)
        x = queryNextUtility(component.getGlobalSiteManager(), IFoo)
        assert_that(x, is_(global_foo))

 def testFacetDependencies(self):
     cfg = SolrConnectionConfig()
     provideUtility(cfg, ISolrConnectionConfig)
     # dependency info can be set via the configuration utility...
     cfg.facets = ['foo:bar']
     context = Dummy()
     request = {}
     view = DummyView(context, request)
     self.assertEqual(facetParameters(view),
                      (['foo:bar'], dict(foo=['bar'])))
     # overridden on the context
     context.facet_fields = ['bar:foo']
     self.assertEqual(facetParameters(view),
                      (['bar:foo'], dict(bar=['foo'])))
     # and via the request
     request['facet.field'] = ['foo:bar', 'bar:foo']
     self.assertEqual(
         facetParameters(view),
         (['foo:bar', 'bar:foo'], dict(foo=['bar'], bar=['foo']))
     )
     # white space shouldn't matter
     request['facet.field'] = ['foo : bar', 'bar  :foo']
     self.assertEqual(
         facetParameters(view),
         (['foo : bar', 'bar  :foo'], dict(foo=['bar'], bar=['foo']))
     )
     # clean up...
     getGlobalSiteManager().unregisterUtility(cfg, ISolrConnectionConfig)

 def _registerTraversable(self):
     from zope.component import getGlobalSiteManager
     from zope.interface import Interface
     from zope.traversing.interfaces import ITraversable
     from zope.traversing.adapters import DefaultTraversable
     getGlobalSiteManager().registerAdapter(
         DefaultTraversable, [Interface], ITraversable)

    def testObject_pasteUncommitOnException(self):
        """Ensure that pasted objects aren't commited if an IObjectMovedEvent raises an exception.
        See https://dev.plone.org/ticket/9365
        """
        # register event handler
        provideHandler(failingEventHandler, [IContentish, IObjectMovedEvent])
        try:
            browser = self.getBrowser()
            browser.open(self.folder['source-folder']['doc'].absolute_url())
            browser.getLink('Cut').click()
            browser.open(self.folder['destination-folder'].absolute_url())
            try:
                browser.getLink('Paste').click()
            except HTTPError:
                # a HTTP 500 Server error is currently expected,
                # unless we find a better way to abort the
                # transaction.
                pass

            # test if document is not moved
            self.assertTrue('doc' in self.folder['source-folder'])
            self.assertFalse('doc' in self.folder['destination-folder'])

        finally:
            # unregister event handler
            getGlobalSiteManager().unregisterHandler(
                failingEventHandler, [IContentish, IObjectMovedEvent])

 def test_behavior_default_page_layout(self):
     import os.path
     
     from zope.component import provideUtility
     from zope.component import getGlobalSiteManager
     
     from plone.resource.directory import FilesystemResourceDirectory
     from plone.resource.interfaces import IResourceDirectory
     
     from plone.app.blocks.layoutbehavior import ILayoutAware
     
     basePath = os.path.dirname(__file__)
     resourcePath = os.path.join(basePath, 'resources', 'pagelayout', 'default')
     
     resourceDir = FilesystemResourceDirectory(resourcePath)
     provideUtility(resourceDir, provides=IResourceDirectory, name=u'++pagelayout++default')
     
     self.layer['folder'].invokeFactory('page', 'dp')
     
     obj = self.layer['folder']['dp']
     layout = ILayoutAware(obj)
     
     self.assertEqual(layout.content, u"<div>a page</div>")
     self.assertEqual(layout.pageSiteLayout, None)
     self.assertEqual(layout.sectionSiteLayout, None)
     
     getGlobalSiteManager().unregisterUtility(resourceDir,
             provided=IResourceDirectory,
             name=u'++pagelayout++default',
         )
     

def getCrowdsUtility():
    """Helper - returns crowds utility and registers new one if missing."""
    utility = queryUtility(ICrowdsUtility)
    if not utility:
        utility = CrowdsUtility()
        getGlobalSiteManager().registerUtility(utility, ICrowdsUtility)
    return utility

 def testSetUp(self):
     super(TestLayer, self).testSetUp()
     # Because it is difficult to dynamically register a
     # entry_point in tests, we do the setup by hand:
     resource_factory = create_factory(foo)
     getGlobalSiteManager().registerAdapter(
         resource_factory, (IBrowserRequest,), Interface, foo.name)

 def setUp(self):
     from Products.Reflecto.catalog import \
         FileProxyIndexableContentAdapter
     self.reflector = MockReflector()
     provideAdapter(FileProxyIndexableContentAdapter) 
     getGlobalSiteManager().registerUtility(FakeConverter, IConverter,
             'image/jpeg')

 def test_getSiteManager(self):
     self.assertEqual(getSiteManager(None), getGlobalSiteManager())
     self.assertEqual(getSiteManager(self.root), getGlobalSiteManager())
     self.assertEqual(getSiteManager(self.f1), self.sm1)
     self.assertEqual(getSiteManager(self.f2), self.sm2)
     setSite(self.f2)
     self.assertEqual(getSiteManager(None), self.sm2)

    def test_FileResource_GET_works_without_IETag_adapter(self):
        # Test backwards compatibility with users of <3.11 that do not provide an ETagAdatper

        getGlobalSiteManager().unregisterAdapter(MyETag)
        factory = FileResourceFactory(self.testFilePath, self.nullChecker, 'test.txt')
        request = TestRequest()
        resource = factory(request)
        self.assertTrue(resource.GET())
        self.assertIsNone(request.response.getHeader('ETag'))

def getDescriptionUtility():
    """Helper - returns crowd description utility and registers
    a new one if missing.
    """
    utility = queryUtility(IDescriptionUtility)
    if not utility:
        utility = DescriptionUtility()
        getGlobalSiteManager().registerUtility(utility, IDescriptionUtility)
    return utility

def setUp( test ):
    _setUp( test )
    from ore.contentmirror import interfaces
    from mirror.async import operation, interfaces as async_interfaces
    
    component.getGlobalSiteManager().unregisterUtility( provided=interfaces.IOperationBufferFactory )
    component.provideUtility( operation.AsyncOperationBufferFactory() )
    component.provideAdapter( operation.OperationIO, ( interfaces.IOperation, ), async_interfaces.IOperationSerializer)
    component.provideUtility( operation.OperationIO(), async_interfaces.IOperationLoader )

    def __init__(self, paster_variables):
        setHooks()

        self.paster = toargs(self, IPasterVariables, paster_variables)

        getGlobalSiteManager().registerUtility(provided=IConfiguration,
            component=self)
        
        load_configuration(self.paster['configure_zcml'])

def getReportRegistrationUtility():
    """Helper - returns report registration utility and registers a new one
    if missing."""
    utility = queryUtility(IRegisteredReportsUtility)
    if not utility:
        utility = RegisteredReportsUtility()
        getGlobalSiteManager().registerUtility(utility,
            IRegisteredReportsUtility)
    return utility

 def tearDown(self):
     # unregister IRedisStoreConfig utils, if they are registered.
     for name in ("psj.content.redis-GND", "psj.content.redis_conf"):
         util = queryUtility(IRedisStoreConfig, name=name)
         if util is None:
             continue
         getGlobalSiteManager().unregisterUtility(
             util, provided=IRedisStoreConfig, name=name)
     super(MetadataBehaviorsTests, self).tearDown()

 def setUp(self):
     # Typically this would be done by zope.app.principalannotation's
     # bootstrap.zcml but we don't have a dep on that.
     super(_AppComponentBrowserLayer, self).setUp()
     from zope.principalannotation.utility import PrincipalAnnotationUtility
     from zope.principalannotation.interfaces import IPrincipalAnnotationUtility
     from zope import component
     component.getGlobalSiteManager().registerUtility(PrincipalAnnotationUtility(),
                                                      IPrincipalAnnotationUtility)

 def setUp(self):
     super(BrowserTestCase, self).setUp()
     self._testapp = TestApp(self.layer.make_wsgi_app())
     # Typically this would be done by zope.app.principalannotation's
     # bootstrap.zcml but we don't have a dep on that.
     from zope.principalannotation.utility import PrincipalAnnotationUtility
     from zope.principalannotation.interfaces import IPrincipalAnnotationUtility
     component.getGlobalSiteManager().registerUtility(PrincipalAnnotationUtility(),
                                                      IPrincipalAnnotationUtility)

 def testVetoRegisteredForOtherType(self):
     self.createContent()
     provideAdapter(factory=Veto, name="euphorie.solution")
     try:
         fti = getattr(self.portal.portal_types, "euphorie.module")
         self.assertEqual(fti.isConstructionAllowed(self.module), True)
     finally:
         from zope.component import getGlobalSiteManager
         getGlobalSiteManager().unregisterAdapter(
                 Veto, name="euphorie.solution")

def get_graph():
    """ returns the graph database connection object
    """
    global_registry = component.getGlobalSiteManager()
    graph = global_registry.queryUtility(IGraph)
    if not graph:
        global_registry = component.getGlobalSiteManager()
        graph = graph_factory()
        global_registry.registerUtility(graph)
    return graph