############################################################################## # # Copyright (c) 2001, 2002 Zope Corporation and Contributors. # All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE. # ############################################################################## """Browser Publication Tests $Id: test_browserpublication.py 110812 2010-04-13 16:30:31Z thefunny42 $ """ import unittest from StringIO import StringIO from zope import component from zope.security.interfaces import ForbiddenAttribute from zope.interface import Interface, implements from zope.publisher.publish import publish from zope.publisher.browser import TestRequest, BrowserView from zope.publisher.interfaces.browser import (IBrowserPublisher, IDefaultBrowserLayer) from zope.proxy import getProxiedObject from zope.security.proxy import Proxy, removeSecurityProxy from zope.security.checker import defineChecker, NamesChecker from zope.principalregistry.principalregistry import principalRegistry from zope.app.publication.browser import BrowserPublication from zope.app.publication.httpfactory import HTTPPublicationRequestFactory from zope.app.publication.traversers import TestTraverser from zope.app.publication.tests.test_zopepublication \ import BasePublicationTests as BasePublicationTests_ from zope.app.publication.tests import support from persistent import Persistent def foo(): "I am an otherwise empty docstring." return 'hello base fans' class DummyPublished(object): implements(IBrowserPublisher) def publishTraverse(self, request, name): if name == 'bruce': return foo raise KeyError(name) def browserDefault(self, request): return self, ['bruce'] class DummyView(DummyPublished, BrowserView): __Security_checker__ = NamesChecker(["browserDefault", "publishTraverse"]) class BasePublicationTests(BasePublicationTests_): def _createRequest(self, path, publication, **kw): request = TestRequest(PATH_INFO=path, **kw) request.setPublication(publication) return request class SimpleObject(object): def __init__(self, v): self.v = v class I1(Interface): pass class mydict(dict): implements(I1) class O1(Persistent): implements(I1) class BrowserDefaultTests(BasePublicationTests): """ test browser default many views lead to a default view """ klass = BrowserPublication def testBaseTagNoBase(self): self._testBaseTags('/somepath/@@view/', '') def testBaseTag1(self): self._testBaseTags('/somepath/@@view', 'http://127.0.0.1/somepath/@@view/bruce') def testBaseTag2(self): self._testBaseTags('/somepath/', 'http://127.0.0.1/somepath/@@view/bruce') def testBaseTag3(self): self._testBaseTags('/somepath', 'http://127.0.0.1/somepath/@@view/bruce') def _testBaseTags(self, url, expected): # Make sure I1 and O1 are visible in the module namespace # so that the classes can be pickled. import transaction pub = BrowserPublication(self.db) component.provideAdapter(DummyView, (I1, IDefaultBrowserLayer), Interface, name='view') support.setDefaultViewName(I1, 'view') component.provideAdapter(TestTraverser, (None, IDefaultBrowserLayer), IBrowserPublisher) ob = O1() ## the following is for running the tests standalone principalRegistry.defineDefaultPrincipal( 'tim', 'timbot', 'ai at its best') # now place our object inside the application connection = self.db.open() app = connection.root()['Application'] app.somepath = ob transaction.commit() connection.close() defineChecker(app.__class__, NamesChecker(somepath='xxx')) req = self._createRequest(url, pub) response = req.response publish(req, handle_errors=0) self.assertEqual(response.getBase(), expected) def _createRequest(self, path, publication, **kw): request = TestRequest(PATH_INFO=path, **kw) request.setPublication(publication) return request class BrowserPublicationTests(BasePublicationTests): klass = BrowserPublication def testAdaptedTraverseNameWrapping(self): class Adapter(object): implements(IBrowserPublisher) def __init__(self, context, request): self.context = context self.counter = 0 def publishTraverse(self, request, name): self.counter += 1 return self.context[name] component.provideAdapter(Adapter, (I1, IDefaultBrowserLayer), IBrowserPublisher) ob = mydict() ob['bruce'] = SimpleObject('bruce') ob['bruce2'] = SimpleObject('bruce2') pub = self.klass(self.db) ob2 = pub.traverseName(self._createRequest('/bruce', pub), ob, 'bruce') self.assertRaises(ForbiddenAttribute, getattr, ob2, 'v') self.assertEqual(removeSecurityProxy(ob2).v, 'bruce') def testAdaptedTraverseDefaultWrapping(self): # Test default content and make sure that it's wrapped. class Adapter(object): implements(IBrowserPublisher) def __init__(self, context, request): self.context = context def browserDefault(self, request): return (self.context['bruce'], 'dummy') component.provideAdapter(Adapter, (I1, IDefaultBrowserLayer), IBrowserPublisher) ob = mydict() ob['bruce'] = SimpleObject('bruce') ob['bruce2'] = SimpleObject('bruce2') pub = self.klass(self.db) ob2, x = pub.getDefaultTraversal(self._createRequest('/bruce',pub), ob) self.assertEqual(x, 'dummy') self.assertRaises(ForbiddenAttribute, getattr, ob2, 'v') self.assertEqual(removeSecurityProxy(ob2).v, 'bruce') def testTraverseName(self): pub = self.klass(self.db) class C(object): x = SimpleObject(1) ob = C() r = self._createRequest('/x',pub) component.provideAdapter(TestTraverser, (None, IDefaultBrowserLayer), IBrowserPublisher) ob2 = pub.traverseName(r, ob, 'x') self.assertRaises(ForbiddenAttribute, getattr, ob2, 'v') self.assertEqual(removeSecurityProxy(ob2).v, 1) self.assert_(pub.traverseName(r, ob, '.') is ob) def testTraverseNameView(self): pub = self.klass(self.db) class I(Interface): pass class C(object): implements(I) ob = C() class V(object): def __init__(self, context, request): pass r = self._createRequest('/@@spam',pub) component.provideAdapter(V, (I, IDefaultBrowserLayer), Interface, name='spam') ob2 = pub.traverseName(r, ob, '@@spam') self.assertEqual(ob2.__class__, V) def testTraverseNameSiteManager(self): pub = self.klass(self.db) class C(object): def getSiteManager(self): return SimpleObject(1) ob = C() r = self._createRequest('/++etc++site',pub) ob2 = pub.traverseName(r, ob, '++etc++site') self.assertRaises(ForbiddenAttribute, getattr, ob2, 'v') self.assertEqual(removeSecurityProxy(ob2).v, 1) def testTraverseNameApplicationControl(self): from zope.applicationcontrol.applicationcontrol \ import applicationController, applicationControllerRoot from zope.traversing.interfaces import IEtcNamespace component.provideUtility(applicationController, IEtcNamespace, name='process') pub = self.klass(self.db) r = self._createRequest('/++etc++process',pub) ac = pub.traverseName(r, applicationControllerRoot, '++etc++process') self.assertEqual(ac, applicationController) r = self._createRequest('/++etc++process',pub) app = r.publication.getApplication(r) self.assertEqual(app, applicationControllerRoot) 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(), '') def testUnicode_NO_HTTP_CHARSET(self): # Test so that a unicode body doesn't cause a UnicodeEncodeError request = TestRequest(StringIO(''), {}) request.response.setResult(u"\u0442\u0435\u0441\u0442") headers = request.response.getHeaders() headers.sort() self.assertEqual( headers, [('Content-Length', '8'), ('Content-Type', 'text/plain;charset=utf-8'), ('X-Content-Type-Warning', 'guessed from content'), ('X-Powered-By', 'Zope (www.zope.org), Python (www.python.org)')]) self.assertEqual( request.response.consumeBody(), '\xd1\x82\xd0\xb5\xd1\x81\xd1\x82') class HTTPPublicationRequestFactoryTests(BasePublicationTests): def setUp(self): super(BasePublicationTests, self).setUp() from zope.app.publication.requestpublicationregistry import \ factoryRegistry from zope.app.publication.requestpublicationfactories \ import SOAPFactory, XMLRPCFactory, HTTPFactory, BrowserFactory factoryRegistry.register('*', '*', 'HTTP', 0, HTTPFactory()) factoryRegistry.register('POST', 'text/xml', 'SOAP', 20, SOAPFactory()) factoryRegistry.register('POST', 'text/xml', 'XMLRPC', 10, XMLRPCFactory()) factoryRegistry.register('GET', '*', 'BROWSER', 10, BrowserFactory()) factoryRegistry.register('POST', '*', 'BROWSER', 10, BrowserFactory()) factoryRegistry.register('HEAD', '*', 'BROWSER', 10, BrowserFactory()) def testGetBackSamePublication(self): factory = HTTPPublicationRequestFactory(db=None) args = (StringIO(''), {}) self.assert_(id(factory(*args).publication) == id(factory(*args).publication)) def test_suite(): return unittest.TestSuite(( unittest.makeSuite(BrowserPublicationTests, 'test'), unittest.makeSuite(BrowserDefaultTests, 'test'), unittest.makeSuite(HTTPPublicationRequestFactoryTests, 'test'), )) if __name__ == '__main__': unittest.TextTestRunner().run(test_suite())