############################################################################## # # Copyright (c) 2003 Zope Foundation 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. # ############################################################################## """Functional tests for virtual hosting. """ import os import unittest from io import StringIO import transaction import zope.component import zope.interface from zope.browserresource.resource import Resource from zope.configuration import xmlconfig from zope.location.interfaces import IRoot from zope.publisher.browser import BrowserRequest, BrowserView from zope.publisher.interfaces import NotFound from zope.publisher.interfaces.browser import IBrowserPublisher from zope.publisher.publish import publish from zope.publisher.skinnable import setDefaultSkin from zope.security.checker import defineChecker, NamesChecker, NoProxy from zope.security.checker import _checkers, undefineChecker from zope.tales import expressions from zope.tales.tales import ExpressionEngine from zope.testing.cleanup import cleanUp from zope.traversing.adapters import traversePathElement from zope.traversing.api import traverse from zope.traversing.testing import browserResource, Contained class MyObj(Contained): def __getitem__(self, key): return traverse(self, '/foo/bar/' + key) class IFolder(zope.interface.Interface): pass @zope.interface.implementer(IFolder, IBrowserPublisher) class Folder(Contained, dict): def __init__(self): dict.__init__(self, {}) def __setitem__(self, name, value): value.__parent__ = self value.__name__ = name dict.__setitem__(self, name, value) def publishTraverse(self, request, name): subob = self.get(name, None) if subob is None: raise NotFound(self.context, name, request) # pragma: no cover return subob @zope.interface.implementer(IRoot) class RootFolder(Folder): pass # Copy some code from zope.pagetemplate to avoid the depedency (break circle) class ZopeTraverser(object): def __call__(self, object, path_items, econtext): request = econtext._vars_stack[0].get('request', None) path_items = list(path_items) path_items.reverse() while path_items: name = path_items.pop() assert getattr(object, '__class__', None) != dict object = traversePathElement(object, name, path_items, request=request) return object zopeTraverser = ZopeTraverser() class PathExpr(expressions.PathExpr): def __init__(self, name, expr, engine): super(PathExpr, self).__init__(name, expr, engine, zopeTraverser) def Engine(): e = ExpressionEngine() for pt in PathExpr._default_type_names: e.registerType(pt, PathExpr) return e Engine = Engine() class MyTalesPage(object): def __init__(self, source): self.source = source def pt_getContext(self, instance, request, **_kw): # instance is a View component namespace = {} namespace['template'] = self namespace['request'] = request namespace['container'] = namespace['context'] = instance return namespace def render(self, instance, request, *args, **kw): context = self.pt_getContext(instance, request) code = Engine.compile(self.source) return str(code(Engine.getContext(context))) class MyPageEval(BrowserView): def __call__(self, **kw): """Call a Page Template""" template = self.context request = self.request return template.render(template.__parent__, request, **kw) index = __call__ class MyFolderPage(BrowserView): def __call__(self, **kw): """My folder page""" self.request.response.redirect('index.html') return '' index = __call__ class TestVirtualHosting(unittest.TestCase): def setUp(self): f = os.path.join(os.path.split(__file__)[0], 'ftesting.zcml') xmlconfig.file(f) defineChecker(MyObj, NoProxy) defineChecker(RootFolder, NoProxy) defineChecker(Folder, NoProxy) self.app = RootFolder() def tearDown(self): undefineChecker(MyObj) undefineChecker(RootFolder) undefineChecker(Folder) cleanUp() def makeRequest(self, path=''): env = {"HTTP_HOST": 'localhost', "HTTP_REFERER": 'localhost'} p = path.split('?') if len(p) == 1: env['PATH_INFO'] = p[0] request = BrowserRequest(StringIO(u''), env) request.setPublication(DummyPublication(self.app)) setDefaultSkin(request) return request def publish(self, path): return publish(self.makeRequest(path)).response def test_request_url(self): self.addPage('/pt', u'request/URL') self.verify('/pt', 'http://localhost/pt/index.html') self.verify('/++vh++/++/pt', 'http://localhost/pt/index.html') self.verify('/++vh++https:localhost:443/++/pt', 'https://localhost/pt/index.html') self.verify('/++vh++https:localhost:443/fake/folders/++/pt', 'https://localhost/fake/folders/pt/index.html') self.addPage('/foo/bar/pt', u'request/URL') self.verify('/foo/bar/pt', 'http://localhost/foo/bar/pt/index.html') self.verify('/foo/bar/++vh++/++/pt', 'http://localhost/pt/index.html') self.verify('/foo/bar/++vh++https:localhost:443/++/pt', 'https://localhost/pt/index.html') self.verify('/foo/++vh++https:localhost:443/fake/folders/++/bar/pt', 'https://localhost/fake/folders/bar/pt/index.html') def test_request_redirect(self): self.addPage('/foo/index.html', u'Spam') self.verifyRedirect('/foo', 'http://localhost/foo/index.html') self.verifyRedirect('/++vh++https:localhost:443/++/foo', 'https://localhost/foo/index.html') self.verifyRedirect('/foo/++vh++https:localhost:443/bar/++', 'https://localhost/bar/index.html') def test_absolute_url(self): self.addPage('/pt', u'context/@@absolute_url') self.verify('/pt', 'http://localhost') self.verify('/++vh++/++/pt', 'http://localhost') self.verify('/++vh++https:localhost:443/++/pt', 'https://localhost') self.verify('/++vh++https:localhost:443/fake/folders/++/pt', 'https://localhost/fake/folders') self.addPage('/foo/bar/pt', u'context/@@absolute_url') self.verify('/foo/bar/pt', 'http://localhost/foo/bar') self.verify('/foo/bar/++vh++/++/pt', 'http://localhost') self.verify('/foo/bar/++vh++https:localhost:443/++/pt', 'https://localhost') self.verify('/foo/++vh++https:localhost:443/fake/folders/++/bar/pt', 'https://localhost/fake/folders/bar') def test_absolute_url_absolute_traverse(self): self.createObject('/foo/bar/obj', MyObj()) self.addPage('/foo/bar/pt', u'container/obj/pt/@@absolute_url') self.verify('/foo/bar/pt', 'http://localhost/foo/bar/pt') self.verify('/foo/++vh++https:localhost:443/++/bar/pt', 'https://localhost/bar/pt') def test_resources(self): browserResource('quux', Resource) # Only register the checker once, so that multiple test runs pass. if Resource not in _checkers: defineChecker(Resource, NamesChecker(['__call__'])) self.addPage(u'/foo/bar/pt', u'context/++resource++quux') self.verify(u'/foo/bar/pt', u'http://localhost/@@/quux') self.verify(u'/foo/++vh++https:localhost:443/fake/folders/++/bar/pt', u'https://localhost/fake/folders/@@/quux') def createFolders(self, path): """addFolders('/a/b/c/d') would traverse and/or create three nested folders (a, b, c) and return a tuple (c, 'd') where c is a Folder instance at /a/b/c.""" folder = self.app #self.connection.root()['Application'] if path[0] == '/': path = path[1:] path = path.split('/') for id in path[:-1]: try: folder = folder[id] except KeyError: folder[id] = Folder() folder = folder[id] return folder, path[-1] def createObject(self, path, obj): folder, id = self.createFolders(path) folder[id] = obj transaction.commit() def addPage(self, path, content): page = MyTalesPage(content) self.createObject(path, page) def verify(self, path, content): result = self.publish(path) self.assertEqual(result.getStatus(), 200) self.assertEqual(result.consumeBody().decode(), content) def verifyRedirect(self, path, location): result = self.publish(path) self.assertEqual(result.getStatus(), 302) self.assertEqual(result.getHeader('Location'), location) class DummyPublication(object): def __init__(self, app): self.app = app def beforeTraversal(self, request): """Pre-traversal hook. This is called *once* before any traversal has been done. """ def getApplication(self, request): """Returns the object where traversal should commence. """ return self.app def callTraversalHooks(self, request, ob): """Invokes any traversal hooks associated with the object. This is called before traversing each object. The ob argument is the object that is about to be traversed. """ def traverseName(self, request, ob, name): """Traverses to the next object. Name must be an ASCII string or Unicode object.""" if name == 'index.html': from zope.component import getMultiAdapter view = getMultiAdapter((ob, request), name=name) return view from zope.traversing.publicationtraverse import PublicationTraverserWithoutProxy t = PublicationTraverserWithoutProxy() return t.traverseName(request, ob, name) def afterTraversal(self, request, ob): """Post-traversal hook. This is called after all traversal. """ def callObject(self, request, ob): """Call the object, returning the result. For GET/POST this means calling it, but for other methods (including those of WebDAV and FTP) this might mean invoking a method of an adapter. """ from zope.publisher.publish import mapply return mapply(ob, request.getPositionalArguments(), request) def afterCall(self, request, ob): """Post-callObject hook (if it was successful). """ def handleException(self, ob, request, exc_info, retry_allowed=1): # pragma: no cover """Handle an exception Either: - sets the body of the response, request.response, or - raises a Retry exception, or - throws another exception, which is a Bad Thing. """ import traceback traceback.print_exception(*exc_info) def endRequest(self, request, ob): """Do any end-of-request cleanup """ def getDefaultTraversal(self, request, ob): if hasattr(ob, 'index'): return ob, () return ob, ('index.html',)