def test_write_without_permission_gives_Unauthorized(self):
     distro = self.factory.makeDistribution()
     endInteraction()
     lp = launchpadlib_for("anonymous-access")
     lp_distro = lp.load(api_url(distro))
     lp_distro.active = False
     self.assertRaises(Unauthorized, lp_distro.lp_save)

    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_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 publish_and_retry(self):
     """Publish the request into the response and retry if it
     fails.
     """
     try:
         data = self.publish_and_render_errors()
     except (ConflictError, Retry):
         self.abort()
         self.publication_done = True
         if self.request.supports_retry() and not self.data_sent:
             # If can still retry, and didn't send any data yet, do it.
             logger.info('Conflict, retrying request %s' % (
                     reconstruct_url_from_environ(self.request.environ)))
             endInteraction()
             request = self.request.retry()
             try:
                 publication = self.__class__(
                     self.app, request, self.response)
                 data = publication.publish_and_retry()
                 self.publication_done = publication.publication_done
             finally:
                 request.close()
         else:
             # Otherwise, just render a plain error.
             logger.error('Conflict error for request %s' % (
                     reconstruct_url_from_environ(self.request.environ)))
             self.response.setStatus(503)
             self.response.setBody(RETRY_FAIL_ERROR_TEMPLATE)
             data = self.result()
     return data

 def setUp(self):
     super(TestGetBranchTips, self).setUp()
     self.distro = self.factory.makeDistribution()
     series_1 = self.series_1 = self.factory.makeDistroSeries(self.distro)
     series_2 = self.series_2 = self.factory.makeDistroSeries(self.distro)
     source_package = self.factory.makeSourcePackage(distroseries=series_1)
     branch = self.factory.makeBranch(sourcepackage=source_package)
     unofficial_branch = self.factory.makeBranch(
         sourcepackage=source_package)
     registrant = self.factory.makePerson()
     now = datetime.now(pytz.UTC)
     sourcepackagename = self.factory.makeSourcePackageName()
     SeriesSourcePackageBranchSet.new(
         series_1, PackagePublishingPocket.RELEASE, sourcepackagename,
         branch, registrant, now)
     SeriesSourcePackageBranchSet.new(
         series_2, PackagePublishingPocket.RELEASE, sourcepackagename,
         branch, registrant, now)
     self.factory.makeRevisionsForBranch(branch)
     self.branch_name = branch.unique_name
     self.unofficial_branch_name = unofficial_branch.unique_name
     self.branch_last_scanned_id = branch.last_scanned_id
     endInteraction()
     self.lp = launchpadlib_for("anonymous-access")
     self.lp_distro = self.lp.distributions[self.distro.name]

    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 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 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()
        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 run_with_login(login_id, function, *args, **kwargs):
    """Run 'function' logged in with 'login_id'.

    The first argument passed to 'function' will be the Launchpad
    `Person` object corresponding to 'login_id'.

    The exception is when the requesting login ID is `LAUNCHPAD_SERVICES`. In
    that case, we'll pass through the `LAUNCHPAD_SERVICES` variable and the
    method will do whatever security proxy hackery is required to provide read
    privileges to the Launchpad services.
    """
    if login_id == LAUNCHPAD_SERVICES or login_id == LAUNCHPAD_ANONYMOUS:
        # Don't pass in an actual user. Instead pass in LAUNCHPAD_SERVICES
        # and expect `function` to use `removeSecurityProxy` or similar.
        return function(login_id, *args, **kwargs)
    if isinstance(login_id, basestring):
        requester = getUtility(IPersonSet).getByName(login_id)
    else:
        requester = getUtility(IPersonSet).get(login_id)
    if requester is None:
        raise NotFoundError("No person with id %s." % login_id)
    setupInteractionForPerson(requester)
    try:
        return function(requester, *args, **kwargs)
    finally:
        endInteraction()

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 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 setUpDebug(test):
    placelesssetup.setUp(test)
    test.real_stderr = sys.stderr
    test.real_argv = list(sys.argv)
    test.olddir = os.getcwd()
    os.chdir(os.path.join(os.path.dirname(__file__), 'testdata'))
    from zope.security.management import endInteraction
    endInteraction()

    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 setUp(self):
     super(DebugLayer, self).setUp()
     self.stderr = sys.stderr
     self.argv = list(sys.argv)
     self.olddir = os.getcwd()
     os.chdir(os.path.join(os.path.dirname(__file__), 'testdata'))
     from zope.security.management import endInteraction
     endInteraction()

 def test_distroseries_architectures_anonymous(self):
     """Test anonymous DistroArchSeries API Access."""
     distroseries = self._makeDistroArchSeries()
     endInteraction()
     launchpad = launchpadlib_for('test', person=None, version='devel')
     ws_distroseries = ws_object(launchpad, distroseries)
     # Note, we test the length of architectures.entries, not
     # architectures due to the removal of the entries by lazr
     self.assertEqual(1, len(ws_distroseries.architectures.entries))

 def _call_manage_main(self):
     self.setRoles(['Manager'])
     # temporaryPlacelessSetUp insists in creating an interaction
     # which the WSGI publisher does not expect.
     endInteraction()
     response = self.publish(
         '/{0.folder_name}/manage_main'.format(Testing.ZopeTestCase),
         basic=basic_auth)
     return str(response)

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

        newInteraction()

        def fake_utcnow(self):
            return datetime.datetime(2015, 7, 30, 8, 0, 0)
        curse(datetime.datetime, 'utcnow', classmethod(fake_utcnow))

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

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

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

        # PluggableAuthentication
        pau = PluggableAuthentication(u'')
        event.notify(ObjectCreatedEvent(pau))
        sm[u'auth'] = pau
        sm.registerUtility(pau, IAuthentication)

        # Credentials Plugin
        defaultCreds.install()
        defaultCreds.activate()

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

        user = sm.getUtility(IAuthentication).getPrincipal('zope.mgr')
        people.assignPersonalSpace(user)

        user = sm.getUtility(IAuthentication).getPrincipal('zope.user')
        people.assignPersonalSpace(user)

        # default content
        content = Content(u'Content1', u'Some Content1')
        event.notify(ObjectCreatedEvent(content))
        IOwnership(content).ownerId = 'zope.user'
        root['content1'] = content

        content = Content(u'Content2', u'Some Content2')
        event.notify(ObjectCreatedEvent(content))
        IOwnership(content).ownerId = 'zope.user'
        root['content2'] = content

        endInteraction()

def transaction_pubevents(request, response, tm=transaction.manager):
    try:
        setDefaultSkin(request)
        newInteraction()
        tm.begin()
        notify(pubevents.PubStart(request))

        yield

        notify(pubevents.PubBeforeCommit(request))
        if tm.isDoomed():
            tm.abort()
        else:
            tm.commit()
        notify(pubevents.PubSuccess(request))
    except Exception as exc:
        # Normalize HTTP exceptions
        # (For example turn zope.publisher NotFound into zExceptions NotFound)
        exc_type, _ = upgradeException(exc.__class__, None)
        if not isinstance(exc, exc_type):
            exc = exc_type(str(exc))

        # Create new exc_info with the upgraded exception.
        exc_info = (exc_type, exc, sys.exc_info()[2])

        try:
            # Raise exception from app if handle-errors is False
            # (set by zope.testbrowser in some cases)
            if request.environ.get('x-wsgiorg.throw_errors', False):
                reraise(*exc_info)

            if isinstance(exc, Unauthorized):
                # _unauthorized modifies the response in-place. If this hook
                # is used, an exception view for Unauthorized has to merge
                # the state of the response and the exception instance.
                exc.setRealm(response.realm)
                response._unauthorized()
                response.setStatus(exc.getStatus())

            # Handle exception view
            exc_view_created = _exc_view_created_response(
                exc, request, response)

            notify(pubevents.PubBeforeAbort(
                request, exc_info, request.supports_retry()))
            tm.abort()
            notify(pubevents.PubFailure(
                request, exc_info, request.supports_retry()))

            if not (exc_view_created or isinstance(exc, Unauthorized)):
                reraise(*exc_info)
        finally:
            # Avoid traceback / exception reference cycle.
            del exc, exc_info
    finally:
        endInteraction()

    def _get_bug_for_user(self, user=None):
        """Convenience function to get the api bug reference."""
        endInteraction()
        if user is not None:
            lp = launchpadlib_for("test", user)
        else:
            lp = launchpadlib_for("test")

        bug_entry = lp.load('/bugs/%s/' % self.bug.id)
        return bug_entry