def lockingSetUp(test):
    placelesssetup.setUp(test)
    z3c.etree.testing.etreeSetup(test)

    # create principal
    participation = TestRequest(environ = {"REQUEST_METHOD": "PUT"})
    participation.setPrincipal(Principal("michael"))
    if queryInteraction() is not None:
        queryInteraction().add(participation)
    else:
        newInteraction(participation)

    events = test.globs["events"] = []
    zope.event.subscribers.append(events.append)

    gsm = zope.component.getGlobalSiteManager()

    gsm.registerAdapter(DemoKeyReference,
                        (IDemo,),
                        zope.app.keyreference.interfaces.IKeyReference)
    gsm.registerAdapter(PhysicallyLocatable, (Demo,))
    gsm.registerAdapter(PhysicallyLocatable, (DemoFolder,))
    gsm.registerAdapter(DemoKeyReference, (IDemoFolder,),
                        zope.app.keyreference.interfaces.IKeyReference)
    gsm.registerAdapter(SiteManagerAdapter,
                        (zope.interface.Interface,), IComponentLookup)
    gsm.registerAdapter(DemoAbsoluteURL,
                        (IDemo, zope.interface.Interface),
                        zope.traversing.browser.interfaces.IAbsoluteURL)
    gsm.registerAdapter(DemoAbsoluteURL,
                        (IDemoFolder, zope.interface.Interface),
                        zope.traversing.browser.interfaces.IAbsoluteURL)

    # register some IDAVWidgets so that we can render the activelock and
    # supportedlock widgets.
    gsm.registerAdapter(z3c.dav.widgets.ListDAVWidget,
                        (zope.schema.interfaces.IList,
                         z3c.dav.interfaces.IWebDAVRequest))
    gsm.registerAdapter(z3c.dav.widgets.ObjectDAVWidget,
                        (zope.schema.interfaces.IObject,
                         z3c.dav.interfaces.IWebDAVRequest))
    gsm.registerAdapter(z3c.dav.widgets.TextDAVWidget,
                        (zope.schema.interfaces.IText,
                         z3c.dav.interfaces.IWebDAVRequest))
    gsm.registerAdapter(z3c.dav.properties.OpaqueWidget,
                        (z3c.dav.properties.DeadField,
                         z3c.dav.interfaces.IWebDAVRequest))
    gsm.registerAdapter(z3c.dav.widgets.TextDAVWidget,
                        (zope.schema.interfaces.IURI,
                         z3c.dav.interfaces.IWebDAVRequest))

    # Need connection to a database to manage locking
    db = test.globs["db"] = ZODB.DB(ZODB.MappingStorage.MappingStorage())
    test.globs["conn"] = db.open()

    # expose these classes to the test
    test.globs["Demo"] = Demo
    test.globs["DemoFolder"] = DemoFolder

    def test_restoreInteraction_after_new(self):
        from zope.security.management import newInteraction
        from zope.security.management import queryInteraction
        from zope.security.management import restoreInteraction

        newInteraction()
        self.assertTrue(queryInteraction() is not None)
        restoreInteraction()  # restore to no interaction
        self.assertTrue(queryInteraction() is None)

    def test_restoreInteraction_after_end(self):
        from zope.security.management import endInteraction
        from zope.security.management import newInteraction
        from zope.security.management import queryInteraction
        from zope.security.management import restoreInteraction

        newInteraction()
        interaction = queryInteraction()
        endInteraction()
        restoreInteraction()
        self.assertTrue(interaction is queryInteraction())

    def test_endInteraction_repeated(self):
        from zope.security.management import endInteraction
        from zope.security.management import newInteraction
        from zope.security.management import queryInteraction

        newInteraction()
        interaction = queryInteraction()
        endInteraction()
        self.assertEqual(queryInteraction(), None)
        endInteraction()
        self.assertEqual(queryInteraction(), None)

    def test_newInteraction(self):
        from zope.security.management import newInteraction
        from zope.security.management import queryInteraction

        newInteraction()
        interaction = queryInteraction()
        self.assertTrue(interaction is not None)

def getRequest():
    interaction = queryInteraction()

    if interaction is not None:
        for participation in interaction.participations:
            if participation is not None:
                return participation

    def check(self):
        interaction = queryInteraction()
        if interaction is None:
            return False

        request = None
        for participation in interaction.participations:
            request = participation
            if request is not None:
                break

        if request is None:
            return False

        contenttype = self.draftct

        container = queryMultiAdapter(
            (request.principal, contenttype), IDraftContainer)
        if container is None:
            return False

        if contenttype.submit:
            if interaction.checkPermission(contenttype.submit, self.context):
                return True

        if contenttype.publish:
            if interaction.checkPermission(contenttype.publish, self.context):
                return True

        return False

def invitationAcceptedHandler(invitation, event):
    owner = IOwnership(invitation).owner
    if owner is None:
        return

    messaging = IMessageStorage(owner, None)
    if messaging is None:
        return

    interaction = queryInteraction()

    if interaction is not None:
        for request in interaction.participations:
            principal = invitation.principal

            view = queryMultiAdapter(
                (principal, request), IPagelet, 'personal.message')
            if view is None:
                return

            view.update()

            data = {'title': u'Your invitation has been accepted',
                    'text': view.render(),
                    'sender': unicode(principal.id)}
            messaging.create(SERVICE_ID, **data)

    def test_checkPermission(self):
        from zope.security import checkPermission
        from zope.security.management import setSecurityPolicy
        from zope.security.management import queryInteraction
        from zope.security.management import newInteraction, endInteraction
        from zope.security.interfaces import NoInteraction

        permission = 'zope.Test'
        obj = object()

        class PolicyStub(object):

            def checkPermission(s, p, o,):
                self.assert_(p is permission)
                self.assert_(o is obj)
                self.assert_(s is queryInteraction() or s is interaction)
                return s is interaction

        setSecurityPolicy(PolicyStub)
        newInteraction()
        interaction = queryInteraction()
        self.assertEquals(checkPermission(permission, obj), True)
        
        endInteraction()
        self.assertRaises(NoInteraction, checkPermission, permission, obj)

 def testPlacefulAuth(self):
     self.publication.beforeTraversal(self.request)
     self.assertEqual(list(queryInteraction().participations), [self.request])
     self.assertEqual(self.request.principal.id, "anonymous")
     root = self.publication.getApplication(self.request)
     self.publication.callTraversalHooks(self.request, root)
     self.assertEqual(self.request.principal.id, "anonymous")
     ob = self.publication.traverseName(self.request, root, "f1")
     self.publication.callTraversalHooks(self.request, ob)
     self.assertEqual(self.request.principal.id, "test.anonymous")
     ob = self.publication.traverseName(self.request, ob, "f2")
     self.publication.afterTraversal(self.request, ob)
     self.assertEqual(self.request.principal.id, "test.bob")
     self.assertEqual(list(queryInteraction().participations), [self.request])
     self.publication.endRequest(self.request, ob)
     self.assertEqual(queryInteraction(), None)

def resetingPassword(event):
    email = IMailAddress(event.principal, None)
    if email is None:
        return

    request = queryInteraction().participations[0]
    template = getMultiAdapter((event, request), IMailTemplate)
    template.send((formataddr((event.principal.title, email.address)),))

def checkPermissionForPrincipal(principal, permission, object):
    interaction = queryInteraction()

    if IZojaxSecurityPolicy.providedBy(interaction):
        return interaction.cached_decision(
            removeSecurityProxy(object), principal.id,
            interaction._groupsFor(principal), permission)

    return False

 def test_usable_as_contextmanager(self):
     from zope.security.management import getInteraction
     from zope.security.management import queryInteraction
     from zope.security.testing import interaction
     with interaction('foo'):
         ix = getInteraction()
         participation = ix.participations[0]
         self.assertEqual('foo', participation.principal.id)
     self.assertFalse(queryInteraction())

 def test_contextmanager_ends_interaction_on_exception(self):
     from zope.security.management import queryInteraction
     from zope.security.testing import interaction
     try:
         with interaction('foo'):
             raise RuntimeError()
     except RuntimeError:
         pass
     self.assertFalse(queryInteraction())

def isNotSelf(group):
    principal_id = None

    interaction = queryInteraction()
    if interaction is not None:
        for participation in interaction.participations:
            principal_id = participation.principal.id
            break
    return principal_id != group.__principal__.id

    def test_contextmanager_ends_interaction_on_exception(self):
        from zope.security.management import queryInteraction
        class MyError(Exception):
            pass

        with self.assertRaises(MyError):
            with testing.interaction('foo'):
                raise MyError()

        self.assertFalse(queryInteraction())

 def _invalidated_interaction_cache(self):
     # Invalidate this threads interaction cache
     interaction = queryInteraction()
     if interaction is not None:
         try:
             invalidate_cache = interaction.invalidate_cache
         except AttributeError:
             pass
         else:
             invalidate_cache()

def get_interaction_extras():
    """Return the active provider of `IInteractionExtras`.

    This is looked up from the interaction.  If there is no interaction then
    return None.
    """
    interaction = queryInteraction()
    if interaction is None:
        return None
    return interaction.extras

def getPrincipal():
    """ get current interaction principal """
    interaction = queryInteraction()

    if interaction is not None:
        for participation in interaction.participations:
            if participation.principal is not None:
                return participation.principal

    raise UnknownPrincipalException()

def principalLoggingOut(event):
    if IRPXNowPrincipalMarker.providedBy(event.principal):
        request = None
        interaction = queryInteraction()

        if interaction is not None:
            for participation in interaction.participations:
                request =  participation
        if request is not None:
            ISession(request)[SESSION_KEY]['token'] = None