Python management.newInteraction函数代码示例

    def setUp(test):
        functional.FunctionalTestSetup().setUp()

        newInteraction()

        root = functional.getRootFolder()
        setSite(root)
        sm = root.getSiteManager()
        sm.getUtility(INameChooserConfiglet).short_url_enabled = True

        # IIntIds
        root['ids'] = IntIds()
        sm.registerUtility(root['ids'], IIntIds)
        root['ids'].register(root)

        # catalog
        root['catalog'] = Catalog()
        sm.registerUtility(root['catalog'], ICatalog)

        setattr(root, 'principalId', 'zope.mgr')
        # space
        space = ContentSpace(title=u'Space')
        event.notify(ObjectCreatedEvent(space))
        root['space'] = space

        setattr(root, 'principal', getUtility(IAuthentication).getPrincipal('zope.mgr'))
        # people
        people = PersonalSpaceManager(title=u'People')
        event.notify(ObjectCreatedEvent(people))
        root['people'] = people
        sm.registerUtility(root['people'], IPersonalSpaceManager)

        endInteraction()

    def setUp(test):
        functional.FunctionalTestSetup().setUp()

        newInteraction()

        root = functional.getRootFolder()
        setSite(root)
        sm = root.getSiteManager()
        sm.getUtility(INameChooserConfiglet).short_url_enabled = True

        # IIntIds
        root["ids"] = IntIds()
        sm.registerUtility(root["ids"], IIntIds)
        root["ids"].register(root)

        # catalog
        root["catalog"] = Catalog()
        sm.registerUtility(root["catalog"], ICatalog)

        # space
        space = ContentSpace(title=u"Space")
        event.notify(ObjectCreatedEvent(space))
        root["space"] = space

        # people
        people = PersonalSpaceManager(title=u"People")
        event.notify(ObjectCreatedEvent(people))
        root["people"] = people
        sm.registerUtility(root["people"], IPersonalSpaceManager)

        endInteraction()

 def wrapper(*a, **kw):
     from zope.security.management import newInteraction
     from zope.security.management import endInteraction
     newInteraction(SystemConfigurationParticipation())
     result = func(*a, **kw)
     endInteraction()
     return result

    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 setUp(self):
        super(PlacefulSetup, self).setUp()
        cSetUp()
        setUpTraversal()

        from zope.security.management import newInteraction
        newInteraction()

def publish(request, module_name,
            _get_module_info=get_module_info,  # only for testing
           ):
    (bobo_before,
     bobo_after,
     object,
     realm,
     debug_mode,
     err_hook,
     validated_hook,
     transactions_manager,
    ) = _get_module_info(module_name)

    notify(PubStart(request))
    newInteraction()
    try:
        request.processInputs()
        response = request.response

        if bobo_after is not None:
            response.after_list += (bobo_after,)

        if debug_mode:
            response.debug_mode = debug_mode

        if realm and not request.get('REMOTE_USER', None):
            response.realm = realm

        if bobo_before is not None:
            bobo_before()

        # Get the path list.
        # According to RFC1738 a trailing space in the path is valid.
        path = request.get('PATH_INFO')

        request['PARENTS'] = [object]
        object = request.traverse(path, validated_hook=validated_hook)
        notify(PubAfterTraversal(request))

        if transactions_manager:
            transactions_manager.recordMetaData(object, request)

        result = mapply(object,
                        request.args,
                        request,
                        call_object,
                        1,
                        missing_name,
                        dont_publish_class,
                        request,
                        bind=1,
                        )

        if result is not response:
            response.setBody(result)
    finally:
        endInteraction()

    notify(PubBeforeCommit(request))
    return response

    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 setUp(test):
        functional.FunctionalTestSetup().setUp()

        newInteraction()

        root = functional.getRootFolder()
        setSite(root)
        sm = root.getSiteManager()

        # IIntIds
        root['ids'] = IntIds()
        sm.registerUtility(root['ids'], IIntIds)
        root['ids'].register(root)

        # catalog
        root['catalog'] = Catalog()
        sm.registerUtility(root['catalog'], ICatalog)

        # setup default role
        roles = sm.getUtility(IPortalRoles)
        if 'site.member' not in roles:
            role = PortalRole(title = u'Site Member')
            event.notify(ObjectCreatedEvent(role))

            roles['site.member'] = role
            roleId = role.id
            sm.getUtility(IDefaultPortalRole).roles = [role.id]

        endInteraction()

    def test_project_create_cancel(self):
        login(self.portal, testing.SITE_ADMIN)

        challenges = self.portal["challenges"]
        challenges.invokeFactory(id="challenge", type_name="cnrd.Challenge")
        intids = component.getUtility(IIntIds)
        challenge_intid = intids.getId(challenges["challenge"])

        add_view = self.portal.restrictedTraverse("workspaces/++add++cnrd.Project")
        add_view.request.form["challenge"] = str(challenge_intid)
        add_view.update()

        edit_location = add_view.request.response.getHeader('Location')
        edit_path = add_view.request.physicalPathFromURL(edit_location)

        self.assertEqual(edit_path[-2:], ['project-draft', 'edit'])
        self.assertIn(edit_path[-2], self.portal["workspaces"])

        edit_path[-1] = "@@" + edit_path[-1]
        edit_view = self.portal.restrictedTraverse(edit_path)
        edit_view.request['SESSION'] = {}
        edit_view.request.form = { "form.buttons.cancel": 1 }
        newInteraction()
        edit_view.update()
        endInteraction()

        location = edit_view.request.response.getHeader('Location')
        path = add_view.request.physicalPathFromURL(location)

        self.assertEqual(path[-2:], ['challenges', 'challenge'])
        self.assertNotIn(edit_path[-2], self.portal["workspaces"])

    def setUp(test):
        functional.FunctionalTestSetup().setUp()

        newInteraction()

        root = functional.getRootFolder()
        setSite(root)
        sm = root.getSiteManager()

        # IIntIds
        root['ids'] = IntIds()
        sm.registerUtility(root['ids'], IIntIds)
        root['ids'].register(root)

        # catalog
        root['catalog'] = Catalog()
        sm.registerUtility(root['catalog'], ICatalog)

        # space
        space = ContentSpace(title=u'Space')
        event.notify(ObjectCreatedEvent(space))
        root['space'] = space

        # people
        people = PersonalSpaceManager(title=u'People')
        event.notify(ObjectCreatedEvent(people))
        root['people'] = people
        sm.registerUtility(root['people'], IPersonalSpaceManager)

        endInteraction()

 def start(self):
     """Start the publication process.
     """
     notify(interfaces.PublicationStart(self.request))
     newInteraction()
     noSecurityManager()
     self.app.transaction.begin()
     self.request.processInputs()

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

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

def login(id, request=None):
    if request is None:
        participation = Participation(Principal(id))
        newInteraction(participation)
    else:
        principal = Principal(id)
        request.setPrincipal(principal)
        newInteraction(request)

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)