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'], [])

    def test_defaults(self):
        dummy = self.makeDummy()
        request = FakeRequest()
        field = dummy.Schema().fields()[0]

        # Default
        self.assertEqual(field.getDefault(dummy), None)

        # Value
        field.default = "Hello"
        self.assertEqual(field.getDefault(dummy), 'Hello')

        # Method
        field.default = None
        field.default_method = 'default_val'
        self.assertEqual(field.getDefault(dummy), 'World')

        # Adapter
        field.default_method = None

        class DefaultFor(object):
            implements(IFieldDefaultProvider)

            def __init__(self, context):
                self.context = context

            def __call__(self):
                return "Adapted"

        getSiteManager().registerAdapter(factory=DefaultFor, required=(Dummy,), name=field.__name__)
        self.assertEqual(field.getDefault(dummy), 'Adapted')
        getSiteManager().unregisterAdapter(factory=DefaultFor, required=(Dummy,), name=field.__name__)

def uninstall(context):
    # Note: this function is registered as a pre_handler instead of a
    # post_handler, because otherwise toolset.xml has already been applied,
    # which removes the portal_placeful_workflow tool.
    portal = getToolByName(context, 'portal_url').getPortalObject()
    tool = getattr(portal, 'portal_placeful_workflow', None)
    if tool is not None:
        getSiteManager(portal).unregisterUtility(
            tool,
            IPlacefulWorkflowTool)
        logger.info('Unregistered portal_placeful_workflow')
    # uninstall configlets
    try:
        cptool = getToolByName(portal, 'portal_controlpanel')
        cptool.unregisterConfiglet(placeful_prefs_configlet['id'])
        logger.info('Removing CMFPlacefulWorkflow Configlet')
    except:
        logger.info('Failed to remove CMFPlacefulWorkflow Configlet')

    wf_tool = getToolByName(portal, 'portal_workflow')
    if IPlacefulMarker.providedBy(wf_tool):
        noLongerProvides(wf_tool, IPlacefulMarker)
        logger.info('Removed placeful marker from portal_workflow.')
    # Mark our base profile as uninstalled, because:
    # 1. It is good practice.
    # 2. Otherwise when the user installs CMFPlacefulWorkflow again,
    #    portal_setup will not apply our base profile.
    portal_setup = getToolByName(portal, 'portal_setup')
    portal_setup.unsetLastVersionForProfile(
        'Products.CMFPlacefulWorkflow:base')

    def helper_test_sub(self, v):
        """ Test that the event subscriber receives a tick. """

        # global ugly variables work fow now
        global success
        success = False

        def my_tick(event):
            global success
            success = True

        component.getSiteManager().registerHandler(my_tick, [v[1]])

        # First
        self.loginAsPortalOwner()
        portal = self.portal
        view = portal.restrictedTraverse(v[0])
        view()

        self.assertEqual(success, True)

        # All ticks have effect. Interval is handled by the external
        # trigger (cron or clockserver)
        success = False
        view()
        self.assertEqual(success, True)

        # Must unregister, otherwise piclking errors - ZODB tries to store this entry?
        component.getSiteManager().unregisterHandler(my_tick, [v[1]])

    def test_subscription(self):
        """ Test that the event subscriber receives a tick. """

        # global ugly variables work fow now
        global success
        success = False

        def my_tick(event):
            global success
            success = True

        component.getSiteManager().registerHandler(my_tick, [ITickEvent])

        # First
        self.loginAsPortalOwner()
        portal = self.portal
        view = portal.restrictedTraverse("@@tick")
        view()

        self.assertEqual(success, True)

        # Subsequent ticks should have no effect until interval has passed
        success = False
        view()
        self.assertEqual(success, False)

        # Must unregister, otherwise piclking errors - ZODB tries to store this entry?
        component.getSiteManager().unregisterHandler(my_tick, [ITickEvent])

    def test_index_html_with_304_and_caching(self):
        # See collector #355
        cpm = DummyCachingManager()
        getSiteManager().registerUtility(cpm, ICachingPolicyManager)
        original_len = len(self.RESPONSE.headers)
        _path, ref = self._extractFile()
        self.app.image = self._makeOne('test_image', 'test_image.gif', file=ref)
        image = self.app.image
        transaction.savepoint(optimistic=True)

        mod_time = image.modified()

        self.REQUEST.environ['IF_MODIFIED_SINCE'
                            ] = '%s;' % rfc1123_date(mod_time + 1)

        data = image.index_html(self.REQUEST, self.RESPONSE)

        self.assertEqual(data, '')
        self.assertEqual(self.RESPONSE.getStatus(), 304)

        headers = self.RESPONSE.headers
        self.failUnless(len(headers) >= original_len + 3)
        self.failUnless('foo' in headers.keys())
        self.failUnless('bar' in headers.keys())
        self.assertEqual(headers['test_path'], '/test_image')