def setUp(self):
        super(AuthZopePublicationTests, self).setUp()
        principalRegistry.defineDefaultPrincipal('anonymous', '')

        root = self.db.open().root()
        app = root[ZopePublication.root_name]
        app['f1'] = rootFolder()
        f1 = app['f1']
        f1['f2'] = Folder()
        if not ISite.providedBy(f1):
            f1.setSiteManager(LocalSiteManager(f1))
        sm1 = f1.getSiteManager()
        addUtility(sm1, '', IAuthentication, AuthUtility1())

        f2 = f1['f2']
        if not ISite.providedBy(f2):
            f2.setSiteManager(LocalSiteManager(f2))
        sm2 = f2.getSiteManager()
        addUtility(sm2, '', IAuthentication, AuthUtility2())
        transaction.commit()

        from zope.container.interfaces import ISimpleReadContainer
        from zope.container.traversal import ContainerTraverser

        component.provideAdapter(ContainerTraverser,
                                 (ISimpleReadContainer, IRequest),
                                 IPublishTraverse, name='')

        from zope.site.interfaces import IFolder
        from zope.security.checker import defineChecker, InterfaceChecker
        defineChecker(Folder, InterfaceChecker(IFolder))

 def test_get_and_set(self):
     smc = self.makeTestObject()
     self.failIf(ISite.providedBy(smc))
     sm = site.LocalSiteManager(smc)
     smc.setSiteManager(sm)
     self.failUnless(ISite.providedBy(smc))
     self.failUnless(smc.getSiteManager() is sm)
     zope.interface.verify.verifyObject(ISite, smc)

    def test_registry_assignment(self):
        setRoles(self.portal, TEST_USER_ID, ['Manager'])
        self.oid = self.portal.invokeFactory('Folder', 'folder')
        setRoles(self.portal, TEST_USER_ID, ['Member'])

        folder = self.portal[self.oid]
        registry = getUtility(IRegistry)

        if not ISite.providedBy(folder):
            make_objectmanager_site(folder)

        setSite(folder)

        pc = getToolByName(folder, 'portal_catalog')
        pc.reindexObject(folder, idxs=['object_provides'])

        enableRegistry(folder)
        self.assertIn(REGISTRY_NAME, folder.objectIds())

        registry = getUtility(IRegistry)
        self.assertTrue(isinstance(registry, LineageRegistry))

        disableRegistry(folder)
        registry = getUtility(IRegistry)
        self.assertTrue(isinstance(registry, Registry))

def setUp(self):
    """Test setUp based on z3c.form.testing.setUp minus their globals.
    """
    from zope.component.testing import setUp
    setUp()
    from zope.container.testing import setUp
    setUp()
    from zope.component import hooks
    hooks.setHooks()
    from zope.traversing.testing import setUp
    setUp()

    from zope.publisher.browser import BrowserLanguages
    from zope.publisher.interfaces.http import IHTTPRequest
    from zope.i18n.interfaces import IUserPreferredLanguages
    import zope.component
    zope.component.provideAdapter(
        BrowserLanguages, [IHTTPRequest], IUserPreferredLanguages)

    from zope.site.folder import rootFolder
    site = rootFolder()
    from zope.site.site import LocalSiteManager
    from zope.component.interfaces import ISite
    if not ISite.providedBy(site):
        site.setSiteManager(LocalSiteManager(site))
    hooks.setSite(site)

    def __init__(self, context):
        permissions = [VIEW_ORDERS_PERMISSION]
        super(ShopPortletOrdersLink, self).__init__(
            context, view_permissions=permissions)
        # check if authenticated user is vendor
        if self.display and not get_vendors_for():
            self.display = False

        # Find the nearest context, where this functionality can be bound to.
        def _find_context(ctx):
            return ctx\
                if ISite.providedBy(ctx) or IVendor.providedBy(ctx)\
                else _find_context(aq_parent(ctx))
        context = _find_context(context)

        if IPloneSiteRoot.providedBy(context):
            self.title = _(
                'orders_global',
                default=u'Orders (global)'
            )
        elif ISite.providedBy(context):
            self.title = _(
                'orders_site',
                default=u'Orders (site-wide)'
            )
        elif IVendor.providedBy(context):
            self.title = _(
                'orders_vendor',
                default=u'Orders (vendor specific)'
            )

        self.url = '%s/@@orders' % context.absolute_url()
        self.order = 10
        self.cssclass = 'orders'

def createSiteManager(folder, setsite=False):
    "Make the given folder a site, and optionally make it the current site."
    if not ISite.providedBy(folder):
        folder.setSiteManager(LocalSiteManager(folder))
    if setsite:
        setSite(folder)
    return traverse(folder, "++etc++site")

def setUp(test):
    from zope.component.testing import setUp
    setUp()
    from zope.container.testing import setUp
    setUp()
    from zope.component import hooks
    hooks.setHooks()
    from zope.traversing.testing import setUp
    setUp()

    from zope.publisher.browser import BrowserLanguages
    from zope.publisher.interfaces.http import IHTTPRequest
    from zope.i18n.interfaces import IUserPreferredLanguages
    zope.component.provideAdapter(BrowserLanguages, [IHTTPRequest],
                   IUserPreferredLanguages)

    from zope.site.folder import rootFolder
    site = rootFolder()
    from zope.site.site import LocalSiteManager
    from zope.component.interfaces import ISite
    if not ISite.providedBy(site):
        site.setSiteManager(LocalSiteManager(site))
    hooks.setSite(site)
    test.globs = {
        'print_function': print_function,
        'root': site,
        'pprint': pprint.pprint}

def get_top_site_from_url(context, request):
    """Find the top-most site, which is still in the url path.

    If the current context is within a subsite within a PloneSiteRoot and no
    virtual hosting is in place, the PloneSiteRoot is returned.
    When at the same context but in a virtual hosting environment with the
    virtual host root pointing to the subsites, it returns the subsite instead
    of the PloneSiteRoot.

    For this given content structure:

    /Plone/Subsite

    It should return the following in these cases:

    - Naked Plone without virtual hosting, /Plone: Plone
    - Naked Plone without virtual hosting, /Plone/Subsite: Plone
    - Virtual hosting which roots to the subsite: Subsite
    """
    url_path = urlparse(context.absolute_url()).path.split('/')

    site = getSite()
    for idx in range(len(url_path)):
        _path = '/'.join(url_path[:idx + 1]) or '/'
        site_path = request.physicalPathFromURL(_path)
        site = context.restrictedTraverse('/'.join(site_path) or '/')
        if ISite.providedBy(site):
            break
    return site

    def test_migration_preserves_references(self):
        portal = self.layer['portal']
        z2.login(portal['acl_users'], 'manager')
        portal.invokeFactory("Child Folder", "cf1")
        cf1 = portal.cf1
        cf1.setTitle("CF 1")
        make_objectmanager_site(cf1)
        pw = portal.portal_workflow
        pw.doActionFor(cf1, "publish")
        self.failUnless(cf1.Title() == "CF 1")
        self.failUnless(pw.getInfoFor(cf1, "review_state") == "published")
        self.failUnless(ISite.providedBy(cf1))

        cf1.invokeFactory("Document", "doc1", Title="Doc 1")
        doc1 = cf1["doc1"]
        cf1.setDefaultPage("doc1")

        doc2_text = (
            '<p><a href="resolveuid/%s" class="internal">Link to doc 1'
            '</a></p>') % doc1.UID()
        cf1.invokeFactory("Document", "doc2", Title="Doc 2", text=doc2_text)
        doc2 = cf1["doc2"]
        # I'm not sure what layer of Plone code adds these
        doc2.addReference(doc1, 'isReferencing', updateReferences=True)
        self.assertEquals(
            len(doc2._getReferenceAnnotations().objectItems()), 1)

        self.run_migration_step()

        cf1 = portal.cf1
        doc2 = cf1["doc2"]
        self.assertEquals(
            len(doc2._getReferenceAnnotations().objectItems()), 1)

def enableFolder(folder):
    zope.event.notify(ChildSiteWillBeCreatedEvent(folder))
    if not ISite.providedBy(folder):
        make_objectmanager_site(folder)
    # reindex so that the object_provides index is aware of our
    # new interface
    reindexObjectProvides(folder)
    zope.event.notify(ChildSiteCreatedEvent(folder))

 def __init__(self, context):
     permissions = [MANAGE_DISCOUNT_PERMISSION]
     super(ShopPortletCartItemDiscountLink, self).__init__(context, view_permissions=permissions)
     if self.display:
         self.display = ISite.providedBy(context) or IDiscountSettingsEnabled.providedBy(context)
     self.url = "%s/@@item_discount" % context.absolute_url()
     self.title = _("item_discount", default=u"Item Discount")
     self.order = 70
     self.cssclass = "item_discount"

 def test_component_registry(self):
     portal = self.layer['portal']
     z2.login(portal['acl_users'], 'contributor')
     portal.invokeFactory('Folder', 'site1')
     zope.component.provideUtility(engine.Subtyper())
     subtyper = zope.component.getUtility(interfaces.ISubtyper)
     subtyper.change_type(
         portal.site1,
         u'collective.lineage.childsite')
     self.failUnless(ISite.providedBy(portal.site1))

    def setUp(self):
        self.portal = portal = self.layer['portal']
        setRoles(self.portal, TEST_USER_ID, ['Manager'])

        portal.invokeFactory('Folder', 'newsite')
        portal.newsite.invokeFactory('Folder', 'subfolder')
        portal.invokeFactory('Folder', 'subfolder2')
        portal.subfolder2.invokeFactory('Folder', 'subfolder3')

        directlyProvides(portal.newsite, ISite)
        self.assertTrue(ISite.providedBy(portal.newsite))

def _extend_destaques(portal):
    folder = portal['destaques']
    if not ISite.providedBy(folder):
        make_objectmanager_site(folder)
    sm = folder.getSiteManager()
    sm.registerAdapter(
        DestaquesExtender,
        (IATNewsItem,),
        ISchemaModifier,
        name=u'DestaqueExtended'
    )

def find_next_sitemanager(site):
    """Find the closest sitemanager that is not the specified site's
    sitemanager.
    """
    while True:
        site = get_parent(site, default=None)
        if site is None:
            return None

        if ISite.providedBy(site):
            return site.getSiteManager()

    def bootstrapSchoolTool(self, db):
        """Bootstrap SchoolTool database."""
        connection = db.open()
        root = connection.root()
        app_obj = root.get(ZopePublication.root_name)
        if app_obj is None:
            app = SchoolToolApplication()

            # Run school specific initialization code
            initializationUtility = getUtility(
                ISchoolToolInitializationUtility)
            initializationUtility.initializeApplication(app)

            directlyProvides(app, directlyProvidedBy(app) + IContainmentRoot)
            root[ZopePublication.root_name] = app
            # savepoint to make sure that the app object has
            # a _p_jar. This is needed to make things like
            # KeyReference work, which in turn is needed to
            # make the catalog work. We make this savepoint
            # optimistic because it will then work with any registered
            # data managers that do not support this feature.
            transaction.savepoint(optimistic=True)

            # set up the site so that local utility setups and catalog
            # indexing would work properly
            if not ISite.providedBy(app):
                app.setSiteManager(LocalSiteManager(app))

            setSite(app)

            # We must set up the int ids utility before setting up any
            # of the plugin specific catalogs, as catalogs rely on
            # IntIds being present
            setUpUtilities(app, [UtilitySpecification(IntIds, IIntIds)])

            # tell plugins to initialize their catalogs, must be done
            # before initializing plugins themselves or else all the
            # initial groups, persons, resources will not get indexed
            notify(CatalogSetUpEvent(app))
            notify(CatalogStartUpEvent(app))

            # initialize plugins themselves
            notify(ApplicationInitializationEvent(app))

            notify(ObjectAddedEvent(app))

            # unset the site so we would not confuse other
            # bootstraping code
            setSite(None)

            self.restoreManagerUser(app, MANAGER_PASSWORD)
            self.initializePreferences(app)
        transaction.commit()
        connection.close()

def enable_childsite(context):
    notify(ChildSiteWillBeCreatedEvent(context))

    # enable site
    if not ISite.providedBy(context):
        make_objectmanager_site(context)

    # provide IChildSite
    alsoProvides(context, IChildSite)

    context.reindexObject(idxs=('object_provides'))
    notify(ChildSiteCreatedEvent(context))

def acquire_vendor_or_shop_root(context):
    """Returns the acquired vendor or the main shop by traversing up the
    content tree, starting from a context.

    :param context: The context to start searching for the nearest vendor.
    :type context: Content object
    :returns: The vendor, a shop item is belonging to.
    :rtype: Content object
    """
    while not IVendor.providedBy(context) and not ISite.providedBy(context):
        context = aq_parent(aq_inner(context))
    return context

    def _maybePlacefullyAuthenticate(self, request, ob):
        if not IUnauthenticatedPrincipal.providedBy(request.principal):
            # We've already got an authenticated user. There's nothing to do.
            # Note that beforeTraversal guarentees that user is not None.
            return

        if not ISite.providedBy(ob):
            # We won't find an authentication utility here, so give up.
            return

        sm = removeSecurityProxy(ob).getSiteManager()
        self.authenticate(request, sm)

 def create_app(db):
     conn = db.open()
     try:
         root = conn.root()
         if not name in root:
             with transaction_manager:
                 app = root[name] = model()
                 if (not ISite.providedBy(app) and
                         IPossibleSite.providedBy(app)):
                     LocalSiteManager(app)
                 notify(events.ApplicationInitializedEvent(app))
     finally:
         conn.close()