Python component.getSiteManager函数代码示例

def registerBehavior(name, spec, factory, schema=None,
                     type = None, title='', description = '', 
                     configContext=None, info=''):

    usedName = spec.queryTaggedValue('__bh_name__')
    if usedName and usedName != name:
        raise TypeError(
            "Can't use same interface for different behaviors (%s and %s)."%(
                name, spec.getTaggedValue('__bh_name__')))
    elif spec.queryTaggedValue('__sch_name__'):
        raise TypeError(
            "Can't use same interface for schema and behavior (%s and %s)."%(
                name, spec.getTaggedValue('__sch_name__')))

    spec.setTaggedValue('__bh_name__', name)
    if schema is not None:
        spec.setTaggedValue('__bh_schema__', schema)

    if type is None:
        type = (IBehavior,)
    elif isinstance(type, InterfaceClass):
        type = (type,)

    bh = Behavior(name, title, spec, factory, schema, description)

    for tp in type:
        getSiteManager().registerUtility(bh, tp, name)

    # register in internal registry
    registry.registerBehavior(bh)

 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 _initSite(self, with_policy=False):
        site = Folder(id='site').__of__(self.app)
        cpm = CachingPolicyManager()
        getSiteManager().registerUtility(cpm, ICachingPolicyManager)

        if with_policy:
            cpm.addPolicy(policy_id=self.POLICY_ID,
                          predicate=self.PREDICATE,
                          mtime_func=self.MTIME_FUNC,
                          max_age_secs=self.MAX_AGE_SECS,
                          no_cache=True,
                          no_store=True,
                          must_revalidate=True,
                          vary=self.VARY,
                          etag_func=self.ETAG_FUNC,
                          s_max_age_secs=self.S_MAX_AGE_SECS,
                          proxy_revalidate=True,
                          public=True,
                          private=True,
                          no_transform=True,
                          enable_304s=True,
                          last_modified=False,
                          pre_check=self.PRE_CHECK,
                          post_check=self.POST_CHECK)

        return site, cpm

    def test_createMemberArea(self):
        site = self._makeSite()
        mtool = site.portal_membership
        members = site._setObject('Members', PortalFolder('Members'))
        acl_users = site._setObject('acl_users', DummyUserFolder())
        getSiteManager().registerUtility(DummyTool(), IWorkflowTool)

        # permission
        mtool.createMemberArea('user_foo')
        self.assertFalse(hasattr(members.aq_self, 'user_foo'))
        newSecurityManager(None, acl_users.user_bar)
        mtool.createMemberArea('user_foo')
        self.assertFalse(hasattr(members.aq_self, 'user_foo'))
        newSecurityManager(None, acl_users.user_foo)
        mtool.setMemberareaCreationFlag()
        mtool.createMemberArea('user_foo')
        self.assertFalse(hasattr(members.aq_self, 'user_foo'))
        newSecurityManager(None, acl_users.all_powerful_Oz)
        mtool.setMemberareaCreationFlag()
        mtool.createMemberArea('user_foo')
        self.assertTrue(hasattr(members.aq_self, 'user_foo'))

        # default content
        f = members.user_foo
        ownership = acl_users.user_foo
        localroles = (('user_foo', ('Owner',)),)
        self.assertEqual(f.getOwner(), ownership)
        self.assertEqual(f.get_local_roles(), localroles,
                         'CMF Collector issue #162 (LocalRoles broken): %s'
                         % str(f.get_local_roles()))

def register_sequence(name, session, impl=SequenceImplementation):
    """
    Register a sequence for later user.

    :param name:
       A string containing the name of the sequence.

    :param session:
       A :class:`~sqlalchemy.orm.session.Session` instance that
       will be used to set up anything needed in the database
       for the sequence to be functional. It will not be retained
       and may be closed and discarded once this function has
       returned.

    :param impl:
       A class whose instances implement
       :class:`~mortar_rdb.interfaces.ISequence`.
       Defaults to
       :class:`mortar_rdb.sequence.generic.SequenceImplementation`.
       
    """
    getSiteManager().registerUtility(
        impl(name,session),
        provided=ISequence,
        name=name,
        ) 

 def test_portal_object(self):
     view = self._makeOne()
     portal = DummyContext()
     tool = DummyURLTool()
     tool.getPortalObject = lambda: portal
     getSiteManager().registerUtility(tool, IURLTool)
     self.assertTrue(view.portal_object is portal)

 def tearDown(self):
     root = self.layer.getRootFolder()
     del root['page']
     for product_id in self.product_ids:
         component.getSiteManager().unregisterUtility(self.sdc, ISessionDataContainer,
                                                      name=product_id)
     super(ZPTSessionTest, self).tearDown()

    def snapshotPortal(self, portal):
        portal_types = getToolByName(portal, 'portal_types')
        portal_skins = getToolByName(portal, 'portal_skins')
        portal_actions = getToolByName(portal, 'portal_actions')
        portal_workflow = getToolByName(portal, 'portal_workflow')
        type_registry = getToolByName(portal, 'content_type_registry')

        state = {}
        state['leftslots'] = getattr(portal, 'left_slots', [])
        if callable(state['leftslots']):
            state['leftslots'] = state['leftslots']()
        state['rightslots'] = getattr(portal, 'right_slots', [])
        if callable(state['rightslots']):
            state['rightslots'] = state['rightslots']()
        state['registrypredicates'] = [
            pred[0] for pred in type_registry.listPredicates()
        ]

        state['types'] = portal_types.objectIds()
        state['skins'] = portal_skins.objectIds()
        actions = set()
        for category in portal_actions.objectIds():
            for action in portal_actions[category].objectIds():
                actions.add((category, action))
        state['actions'] = actions
        state['workflows'] = portal_workflow.objectIds()
        state['portalobjects'] = portal.objectIds()
        state['adapters'] = tuple(getSiteManager().registeredAdapters())
        state['utilities'] = tuple(getSiteManager().registeredUtilities())

        jstool = getToolByName(portal, 'portal_javascripts', None)
        state['resources_js'] = jstool and jstool.getResourceIds() or []
        csstool = getToolByName(portal, 'portal_css', None)
        state['resources_css'] = csstool and csstool.getResourceIds() or []
        return state

    def test_getNextUtility(self):
        # test local site vs. global site
        global_dummy = DummyUtility()
        provideUtility(global_dummy, IDummyUtility)

        local_dummy = DummyUtility()
        sm = getSiteManager()
        sm.registerUtility(IDummyUtility, local_dummy)

        self.assertEquals(zapi.getUtility(IDummyUtility), local_dummy)
        self.assertEquals(getNextUtility(self.folder.site, IDummyUtility),
                          global_dummy)

        # test local site vs. nested local site
        manage_addDummySite(self.folder.site, 'subsite')
        import warnings
        showwarning = warnings.showwarning
        warnings.showwarning = lambda *a, **k: None
        enableLocalSiteHook(self.folder.site.subsite)
        warnings.showwarning = showwarning

        sublocal_dummy = DummyUtility()
        sm = getSiteManager()
        sm.registerUtility(IDummyUtility, sublocal_dummy)

        self.assertEquals(zapi.getUtility(IDummyUtility), sublocal_dummy)
        self.assertEquals(getNextUtility(self.folder.site.subsite, IDummyUtility),
                          local_dummy)
        self.assertEquals(getNextUtility(self.folder.site, IDummyUtility),
                          global_dummy)

    def _initSite(self, foo=2):
        site = Folder(id='site').__of__(self.app)
        ctool = CatalogTool()
        getSiteManager().registerUtility(ctool, ICatalogTool)

        for obj_id in ctool.objectIds():
            ctool._delObject(obj_id)
        for idx_id in ctool.indexes():
            ctool.delIndex(idx_id)
        for col in ctool.schema()[:]:
            ctool.delColumn(col)

        if foo > 0:
            ctool._setObject('foo_plexicon', PLexicon('foo_plexicon'))
            lex = ctool.foo_plexicon
            lex._pipeline = (Splitter(), CaseNormalizer(), StopWordRemover())

            extra = _extra()
            extra.lexicon_id = 'foo_plexicon'
            extra.index_type = 'Okapi BM25 Rank'
            ctool.addIndex('foo_zctext', 'ZCTextIndex', extra)

            ctool.addColumn('foo_zctext')

        return site, ctool

    def test_tracker261(self):
        #
        #   Tracker issue #261 says that content in a deleted folder
        #   is not being uncatalogued.  Try creating a subfolder with
        #   content object, and test.
        #
        from ..PortalFolder import PortalFolder

        acl_users = self.site._setObject('acl_users', DummyUserFolder())
        newSecurityManager(None, acl_users.all_powerful_Oz)
        test = self._makeOne('test')
        ctool = DummyCatalogTool()
        getSiteManager().registerUtility(ctool, ICatalogTool)
        self.assertEqual(len(ctool), 0)

        test._setObject('sub', PortalFolder('sub', ''))
        sub = test.sub

        sub._setObject('foo', DummyContent('foo', catalog=1))
        foo = sub.foo

        self.assertTrue(foo.after_add_called)
        self.assertFalse(foo.before_delete_called)
        self.assertEqual(len(ctool), 1)

        foo.reset()
        test._delObject('sub')
        self.assertFalse(foo.after_add_called)
        self.assertTrue(foo.before_delete_called)
        self.assertEqual(len(ctool), 0)

    def test_contentPasteAllowedTypes(self):
        #
        #   _verifyObjectPaste() should honor allowed content types
        #
        ttool = TypesTool()
        getSiteManager().registerUtility(ttool, ITypesTool)
        fti = FTIDATA_DUMMY[0].copy()
        ttool._setObject('Dummy Content', FTI(**fti))
        ttool._setObject('Folder', FTI(**fti))
        sub1 = self._makeOne('sub1')
        sub1._setObject('dummy', DummyContent('dummy'))
        sub2 = self._makeOne('sub2')
        sub2.all_meta_types = extra_meta_types()

        # Allow adding of Dummy Content
        ttool.Folder.manage_changeProperties(filter_content_types=False)

        # Copy/paste should work fine
        cookie = sub1.manage_copyObjects(ids=['dummy'])
        sub2.manage_pasteObjects(cookie)

        # Disallow adding of Dummy Content
        ttool.Folder.manage_changeProperties(filter_content_types=True)

        # Now copy/paste should raise a ValueError
        cookie = sub1.manage_copyObjects(ids=('dummy',))
        self.assertRaises(ValueError, sub2.manage_pasteObjects, cookie)

 def test_publisher_with_metadata_tool(self):
     PUBLISHER = 'Some Publisher'
     site = DummySite('site').__of__(self.app)
     tool = DummyMetadataTool(publisher=PUBLISHER)
     getSiteManager().registerUtility(tool, IMetadataTool)
     item = self._makeDummyContent('item').__of__(site)
     self.assertEqual(item.Publisher(), PUBLISHER)

    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 test_enabled_uninstalled(self):
        dsb = DummyStorageBackend()
        getSiteManager().registerUtility(
            dsb, IStorageBackend, name='dummy_storage')

        utilities = queryUtility(IUtilityRegistry, 'repodono.storage.backends')
        utilities.enable('dummy_storage')

        vocab = queryUtility(
            IVocabularyFactory, name='repodono.storage.backends')(None)
        self.assertEqual(vocab.getTermByToken(
            'dummy_storage').token, 'dummy_storage')

        getSiteManager().unregisterUtility(
            dsb, IStorageBackend, name='dummy_storage')

        vocab = queryUtility(
            IVocabularyFactory, name='repodono.storage.backends')(None)
        self.assertEqual(list(vocab), [])

        # registry should be untouched at this point
        registry = queryUtility(IRegistry)
        self.assertEqual(
            registry['repodono.storage.backends'], [u'dummy_storage'])

        # shouldn't break anything.
        utilities.disable('unrelated')
        self.assertEqual(list(vocab), [])

        # The bad value is no longer stored.
        self.assertEqual(registry['repodono.storage.backends'], [])