Python TestRequest.setPrincipal方法代码示例

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
    def testUnauthorized(self):
        component.provideAdapter(DummyTemplate, name="default")
        exception = Exception()
        try:
            raise exception
        except:
            pass
        request = TestRequest()
        request.setPrincipal(DummyPrincipal(23))
        u = Unauthorized(exception, request)
        res = u()

        # Make sure that we rendered the expected template
        self.assertEqual("You are not authorized", res)

        # Make sure the response status was set
        self.assertEqual(request.response.getStatus(), 403)

        # check headers that work around squid "negative_ttl"
        self.assertEqual(request.response.getHeader('Expires'),
                         'Mon, 26 Jul 1997 05:00:00 GMT')
        self.assertEqual(request.response.getHeader('Pragma'),
                         'no-cache')
        self.assertEqual(request.response.getHeader('Cache-Control'),
                         'no-store, no-cache, must-revalidate')

        # Make sure the auth utility was called
        self.failUnless(self.auth.request is request)
        self.assertEqual(self.auth.principal_id, 23)

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
    def testUnauthorized(self):
        exception = Exception()
        try:
            raise exception
        except:
            pass
        request = TestRequest()
        request.setPrincipal(DummyPrincipal(23))
        u = Unauthorized(exception, request)
        u.issueChallenge()

        # Make sure the response status was set
        self.assertEqual(request.response.getStatus(), 403)

        # check headers that work around squid "negative_ttl"
        self.assertEqual(request.response.getHeader('Expires'),
                         'Mon, 26 Jul 1997 05:00:00 GMT')
        self.assertEqual(request.response.getHeader('Pragma'),
                         'no-cache')
        self.assertEqual(request.response.getHeader('Cache-Control'),
                         'no-store, no-cache, must-revalidate')
        
        # Make sure the auth utility was called
        self.failUnless(self.auth.request is request)
        self.assertEqual(self.auth.principal_id, 23)

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
        class Instance(object):
            def __init__(self):
                self.context = context
                self.request = TestRequest()
                self.request.setPrincipal(self)

            title = 'principal'

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
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

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
    def test_make_extra_principal(self):
        class MockPrincipal(object):
            id = 'foo'

        request = TestRequest()
        request.setPrincipal(MockPrincipal())
        reporter = SentryAwareLoggingErrorReporting()
        result = reporter.make_extra(request)
        self.assertTrue('sentry.interfaces.User' in result)
        self.assertEqual('foo', result['sentry.interfaces.User']['id'])

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
class TestErrorViews(TestCase):

    layer = browser_layer

    def setUp(self):
        self.request = TestRequest()

    def test_defaultname(self):
        self.assertEquals(
            getDefaultViewName(Exception(), self.request), 'index.html')
        error = NotFound(object(), self.request)
        self.assertEquals(
            getDefaultViewName(error, self.request), 'index.html')
        self.assertEquals(
            getDefaultViewName(
                Unauthorized(), self.request), 'index.html')

    def test_exceptionview(self):
        view = getMultiAdapter((Exception(), self.request), name='index.html')
        self.assertEquals(view(), 'A system error occurred.')
        self.assertEquals(self.request.response.getStatus(), 500)

    def test_notfoundview(self):
        error = NotFound(object(), self.request)
        view = getMultiAdapter((error, self.request), name='index.html')
        self.failUnless(IHTTPException.providedBy(view))
        self.assertEquals(view(), 'The requested resource can not be found.')
        self.assertEquals(self.request.response.getStatus(), 404)

    def test_unauthorizedview(self):
        self.request.setPrincipal(MockPrincipal())
        view = getMultiAdapter(
            (Unauthorized(), self.request), name='index.html')
        self.failUnless(IHTTPException.providedBy(view))
        self.assertEquals(
            view(), 'Access to the requested resource is forbidden.')
        self.assertEquals(self.request.response.getStatus(), 403)

        getUtility(IAuthentication).status = 401
        self.assertEquals(
            view(), 'Access to the requested resource is forbidden.')
        self.assertEquals(self.request.response.getStatus(), 401)

        getUtility(IAuthentication).status = 302
        self.assertEquals(view(), '')
        self.assertEquals(self.request.response.getStatus(), 302)

        getUtility(IAuthentication).status = 303
        self.assertEquals(view(), '')
        self.assertEquals(self.request.response.getStatus(), 303)

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
    def setUp(test):
        functional.FunctionalTestSetup().setUp()

        root = functional.getRootFolder()
        setSite(root)
        sm = root.getSiteManager()
        interface.alsoProvides(root, IOwnerAware)

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

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

        # auth
        authconfiglet = sm.getUtility(IAuthenticationConfiglet)
        authconfiglet.installUtility()

        auth = sm.getUtility(IAuthentication)
        auth._caching = False

        # portal
        portal = Portal()
        event.notify(ObjectCreatedEvent(portal))
        root['portal'] = portal
        root['portal'].setSiteManager(LocalSiteManager(portal))

        # home folder manager
        manager = PersonalSpaceManager(title=u'People')
        event.notify(ObjectCreatedEvent(manager))

        root['people'] = manager
        sm.registerUtility(root['people'], IPersonalSpaceManager)

        request = TestRequest()
        request.setPrincipal(auth.getPrincipal('zope.mgr'))

        portlets = sm.queryMultiAdapter(
            (portal, TestRequest(), None), IPortletManager, 'columns.left')
        portlets.status = ENABLED
        portlets.portletIds = ('portlet.actions',)

        setSite(None)

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
    def test_calendarRows_no_periods(self):
        from schooltool.timetable.browser.cal import DailyTimetableCalendarRowsView
        from schooltool.person.preference import getPersonPreferences
        from schooltool.app.security import Principal

        prefs = getPersonPreferences(self.person)
        prefs.cal_periods = False # do not show periods
        request = TestRequest()
        principal = Principal('person', 'Some person', person=self.person)
        request.setPrincipal(principal)
        view = DailyTimetableCalendarRowsView(ISchoolToolCalendar(self.person), request)

        result = list(view.calendarRows(date(2004, 11, 5), 8, 19, events=[]))

        expected = [("%d:00" % i, dt('%d:00' % i), timedelta(hours=1))
                    for i in range(8, 19)]
        self.assertEquals(result, expected)

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
    def testPluggableAuthUtility(self):
        exception = Exception()
        try:
            raise exception
        except:
            pass
        request = TestRequest()
        psrc = DummyPrincipalSource()
        request.setPrincipal(DummyPrincipal(23))
        u = Unauthorized(exception, request)
        u.issueChallenge()

        # Make sure the response status was set
        self.assertEqual(request.response.getStatus(), 403)

        # Make sure the auth utility was called
        self.failUnless(self.auth.request is request)
        self.assertEqual(self.auth.principal_id, 23)

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
    def testHEADFuxup(self):
        pub = self.klass(None)

        class User(object):
            id = 'bob'

        # With a normal request, we should get a body:
        request = TestRequest(StringIO(''), {'PATH_INFO': '/'})
        request.setPrincipal(User())
        request.response.setResult(u"spam")
        pub.afterCall(request, None)
        self.assertEqual(request.response.consumeBody(), 'spam' )

        # But with a HEAD request, the body should be empty
        request = TestRequest(StringIO(''), {'PATH_INFO': '/'})
        request.setPrincipal(User())
        request.method = 'HEAD'
        request.response.setResult(u"spam")
        pub.afterCall(request, None)
        self.assertEqual(request.response.consumeBody(), '')

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
    def test_getPeriods(self):
        from schooltool.timetable.browser.cal import DailyTimetableCalendarRowsView

        request = TestRequest()
        view = DailyTimetableCalendarRowsView(ISchoolToolCalendar(self.person), request)

        # if no user has logged we should get an empty list
        self.assertEquals(view.getPeriods(date(2005, 1, 1)), [])

        # same if our user doesn't want to see periods in his calendar
        request.setPrincipal(self.person)
        IPersonPreferences(self.person).cal_periods = False
        self.assertEquals(view.getPeriods(date(2005, 1, 1)), [])

        # if currently logged in user wants to see periods, the
        # parameter is passed to getPeriodsForDay method.
        view.getPeriodsForDay = lambda cursor: ("Yep", cursor)
        IPersonPreferences(self.person).cal_periods = True
        self.assertEquals(view.getPeriods(date(2005, 1, 1)),
                          ("Yep", date(2005, 1, 1)))

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
    def testRedirect(self):
        exception= Exception()
        try:
            raise exception
        except:
            pass
        request = TestRequest()
        request.setPrincipal(DummyPrincipal(23))
        u = Unauthorized(exception, request)

        self.auth.status = 303

        res = u()

        # Make sure that the template was not rendered
        self.assert_(res is None)

        # Make sure the auth's redirect is honored
        self.assertEqual(request.response.getStatus(), 303)

        # Make sure the auth utility was called
        self.failUnless(self.auth.request is request)
        self.assertEqual(self.auth.principal_id, 23)

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
    def process(self, message):
        recipient = IRecipient(self.context, None)
        if recipient is None:
            raise MailInException('Recipent not found.')

        # find principal
        from_hdr = parseaddr(message['From'])[1].lower()
        try:
            principal = getPrincipalByEMail(from_hdr)
        except PrincipalLookupError:
            if IAnonymousSupport.providedBy(recipient):
                principal = getUtility(IUnauthenticatedPrincipal)
            else:
                # member not found
                raise MailInException('Member not found: %s'%from_hdr)

        # set security context
        interaction = queryInteraction()
        if interaction is not None:
            request = copy.copy(interaction.participations[0])
        else:
            request = TestRequest()

        request.setPrincipal(principal)
        request.interaction = None

        endInteraction()
        newInteraction(request)

        # deliver message
        try:
            recipient.process(message)
        except:
            log_exc()

        # restore old security context
        restoreInteraction()

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
    def test_calendarRows_otherTZ(self):
        from schooltool.timetable.browser.cal import DailyTimetableCalendarRowsView
        from schooltool.app.security import Principal

        request = TestRequest()
        principal = Principal('person', 'Some person', person=self.person)
        request.setPrincipal(principal)
        view = DailyTimetableCalendarRowsView(ISchoolToolCalendar(self.person), request)

        km = timezone('Asia/Kamchatka')
        view.getPersonTimezone = lambda: km

        result = list(view.calendarRows(date(2004, 11, 5), 8, 19, events=[]))

        kmdt = lambda arg: km.localize(parse_datetime('2004-11-05 %s:00' %
                                                      arg))

        expected = [('8:00', kmdt('8:00'), timedelta(0, 3600)),
                    ('9:00', kmdt('9:00'), timedelta(0, 3600)),
                    ('10:00', kmdt('10:00'),timedelta(0, 3600)),
                    ('11:00', kmdt('11:00'),timedelta(0, 3600)),
                    ('12:00', kmdt('12:00'),timedelta(0, 3600)),
                    ('13:00', kmdt('13:00'),timedelta(0, 3600)),
                    ('14:00', kmdt('14:00'),timedelta(0, 3600)),
                    ('15:00', kmdt('15:00'),timedelta(0, 3600)),
                    ('16:00', kmdt('16:00'),timedelta(0, 3600)),
                    ('17:00', kmdt('17:00'),timedelta(0, 3600)),
                    ('18:00', kmdt('18:00'),timedelta(0, 3600)),
                    ('19:00', kmdt('19:00'),timedelta(0, 3600)),
                    ('1',  kmdt("20:00"), timedelta(0, 3600)),
                    ('21:00', kmdt("21:00"), timedelta(0, 4500)),
                    ('2',  kmdt("22:15"), timedelta(0, 3600)),
                    ('23:15', kmdt("23:15"), timedelta(0, 900)),
                    ('3', kmdt("23:30"), timedelta(0, 1800))]

        self.assertEquals(result, expected)

# 需要导入模块: from zope.publisher.browser import TestRequest [as 别名]
# 或者: from zope.publisher.browser.TestRequest import setPrincipal [as 别名]
    def test_calendarRows(self):
        from schooltool.timetable.browser.cal import DailyTimetableCalendarRowsView
        from schooltool.app.security import Principal

        request = TestRequest()
        principal = Principal('person', 'Some person', person=self.person)
        request.setPrincipal(principal)
        view = DailyTimetableCalendarRowsView(ISchoolToolCalendar(self.person), request)
        result = list(view.calendarRows(date(2004, 11, 5), 8, 19, events=[]))

        expected = [("1", dt('08:00'), timedelta(hours=1)),
                    ("9:00", dt('09:00'), timedelta(hours=1)),
                    ("10:00", dt('10:00'), timedelta(minutes=15)),
                    ("2", dt('10:15'), timedelta(hours=1)),
                    ("11:15", dt('11:15'), timedelta(minutes=15)),
                    ("3", dt('11:30'), timedelta(hours=1)),
                    ("4", dt('12:30'), timedelta(hours=2)),
                    ("14:30", dt('14:30'), timedelta(minutes=30)),
                    ("15:00", dt('15:00'), timedelta(hours=1)),
                    ("16:00", dt('16:00'), timedelta(hours=1)),
                    ("17:00", dt('17:00'), timedelta(hours=1)),
                    ("18:00", dt('18:00'), timedelta(hours=1))]

        self.assertEquals(result, expected)