From d1209e077a1607440677a363651bda4393d72d82 Mon Sep 17 00:00:00 2001 From: Chris McDonough Date: Thu, 16 Apr 2009 20:31:40 +0000 Subject: - The interface for ``repoze.bfg.interfaces.ITraverser`` and the built-in implementations that implement the interface (``repoze.bfg.traversal.ModelGraphTraverser``, and ``repoze.bfg.urldispatch.RoutesModelTraverser``) now expect the ``__call__`` method of an ITraverser to return 3 additional arguments: ``traversed``, ``virtual_root``, and ``virtual_root_path`` (the old contract was that the ``__call__`` method of an ITraverser returned; three arguments, the contract new is that it returns six). ``traversed`` will be a sequence of Unicode names that were traversed (including the virtual root path, if any) or ``None`` if no traversal was performed, ``virtual_root`` will be a model object representing the virtual root (or the physical root if traversal was not performed), and ``virtual_root_path`` will be a sequence representing the virtual root path (a sequence of Unicode names) or ``None`` if traversal was not performed. Six arguments are now returned from BFG ITraversers. They are returned in this order: ``context``, ``view_name``, ``subpath``, ``traversed``, ``virtual_root``, and ``virtual_root_path``. Places in the BFG code which called an ITraverser continue to accept a 3-argument return value, although BFG will generate and log a warning when one is encountered. - The request object now has the following attributes: ``traversed`` (the sequence of names traversed or ``None`` if traversal was not performed), ``virtual_root`` (the model object representing the virtual root, including the virtual root path if any), and ``virtual_root_path`` (the seuquence of names representing the virtual root path or ``None`` if traversal was not performed). - A new decorator named ``wsgiapp2`` was added to the ``repoze.bfg.wsgi`` module. This decorator performs the same function as ``repoze.bfg.wsgi.wsgiapp`` except it fixes up the ``SCRIPT_NAME``, and ``PATH_INFO`` environment values before invoking the WSGI subapplication. - The ``repoze.bfg.testing.DummyRequest`` object now has default attributes for ``traversed``, ``virtual_root``, and ``virtual_root_path``. - The RoutesModelTraverser now behaves more like the Routes "RoutesMiddleware" object when an element in the match dict is named ``path_info`` (usually when there's a pattern like ``http://foo/*path_info``). When this is the case, the ``PATH_INFO`` environment variable is set to the value in the match dict, and the ``SCRIPT_NAME`` is appended to with the prefix of the original ``PATH_INFO`` not including the value of the new variable. - The notfound debug now shows the traversed path, the virtual root, and the virtual root path too. --- repoze/bfg/tests/test_integration.py | 1 + repoze/bfg/tests/test_router.py | 36 ++++++++++++- repoze/bfg/tests/test_traversal.py | 49 ++++++++++++++---- repoze/bfg/tests/test_urldispatch.py | 34 +++++++++++++ repoze/bfg/tests/test_wsgi.py | 97 ++++++++++++++++++++++++++++++++++++ 5 files changed, 207 insertions(+), 10 deletions(-) (limited to 'repoze/bfg/tests') diff --git a/repoze/bfg/tests/test_integration.py b/repoze/bfg/tests/test_integration.py index b6e5e1c0c..1159ca380 100644 --- a/repoze/bfg/tests/test_integration.py +++ b/repoze/bfg/tests/test_integration.py @@ -160,6 +160,7 @@ class DummyContext: class DummyRequest: subpath = ('__init__.py',) + traversed = None environ = {'REQUEST_METHOD':'GET', 'wsgi.version':(1,0)} def get_response(self, application): return application(None, None) diff --git a/repoze/bfg/tests/test_router.py b/repoze/bfg/tests/test_router.py index 29849e396..dd249a8fe 100644 --- a/repoze/bfg/tests/test_router.py +++ b/repoze/bfg/tests/test_router.py @@ -21,6 +21,7 @@ class RouterTests(unittest.TestCase): self.messages = [] def info(self, msg): self.messages.append(msg) + warn = info debug = info logger = Logger() self.registry.registerUtility(logger, ILogger, name='repoze.bfg.debug') @@ -93,6 +94,28 @@ class RouterTests(unittest.TestCase): router = self._makeOne() self.assertEqual(router.root_policy, rootfactory) + def test_3arg_policy(self): + rootfactory = make_rootfactory(None) + environ = self._makeEnviron() + context = DummyContext() + traversalfactory = make_3arg_traversal_factory(context, '', []) + self._registerTraverserFactory(traversalfactory, '', None) + logger = self._registerLogger() + self._registerRootFactory(rootfactory) + router = self._makeOne() + start_response = DummyStartResponse() + result = router(environ, start_response) + self.failUnless(traversalfactory in router.traverser_warned) + headers = start_response.headers + self.assertEqual(len(headers), 2) + status = start_response.status + self.assertEqual(status, '404 Not Found') + self.failUnless('http://localhost:8080' in result[0], result) + self.failIf('debug_notfound' in result[0]) + self.assertEqual(len(logger.messages), 1) + message = logger.messages[0] + self.failUnless('is an pre-0.7.1-style ITraverser ' in message) + def test_call_no_view_registered_no_isettings(self): rootfactory = make_rootfactory(None) environ = self._makeEnviron() @@ -717,7 +740,17 @@ def make_view(response): return response return view -def make_traversal_factory(context, name, subpath): +def make_traversal_factory(context, name, subpath, vroot=None, + vroot_path=(), traversed=()): + class DummyTraversalFactory: + def __init__(self, root): + self.root = root + + def __call__(self, path): + return context, name, subpath, traversed, vroot, vroot_path + return DummyTraversalFactory + +def make_3arg_traversal_factory(context, name, subpath): class DummyTraversalFactory: def __init__(self, root): self.root = root @@ -726,6 +759,7 @@ def make_traversal_factory(context, name, subpath): return context, name, subpath return DummyTraversalFactory + def make_permission_factory(result): class DummyPermissionFactory: def __init__(self, context, request): diff --git a/repoze/bfg/tests/test_traversal.py b/repoze/bfg/tests/test_traversal.py index 9cdf04910..18e9a9f18 100644 --- a/repoze/bfg/tests/test_traversal.py +++ b/repoze/bfg/tests/test_traversal.py @@ -83,70 +83,95 @@ class ModelGraphTraverserTests(unittest.TestCase): def test_call_with_no_pathinfo(self): policy = self._makeOne(None) environ = self._getEnviron() - ctx, name, subpath = policy(environ) + ctx, name, subpath, traversed, vroot, vroot_path = policy(environ) self.assertEqual(ctx, None) self.assertEqual(name, '') self.assertEqual(subpath, []) + self.assertEqual(traversed, []) + self.assertEqual(vroot, policy.root) + self.assertEqual(vroot_path, []) def test_call_pathel_with_no_getitem(self): policy = self._makeOne(None) environ = self._getEnviron(PATH_INFO='/foo/bar') - ctx, name, subpath = policy(environ) + ctx, name, subpath, traversed, vroot, vroot_path = policy(environ) self.assertEqual(ctx, None) self.assertEqual(name, 'foo') self.assertEqual(subpath, ['bar']) + self.assertEqual(traversed, []) + self.assertEqual(vroot, policy.root) + self.assertEqual(vroot_path, []) def test_call_withconn_getitem_emptypath_nosubpath(self): root = DummyContext() policy = self._makeOne(root) environ = self._getEnviron(PATH_INFO='') - ctx, name, subpath = policy(environ) + ctx, name, subpath, traversed, vroot, vroot_path = policy(environ) self.assertEqual(ctx, root) self.assertEqual(name, '') self.assertEqual(subpath, []) + self.assertEqual(traversed, []) + self.assertEqual(vroot, root) + self.assertEqual(vroot_path, []) def test_call_withconn_getitem_withpath_nosubpath(self): foo = DummyContext() root = DummyContext(foo) policy = self._makeOne(root) environ = self._getEnviron(PATH_INFO='/foo/bar') - ctx, name, subpath = policy(environ) + ctx, name, subpath, traversed, vroot, vroot_path = policy(environ) self.assertEqual(ctx, foo) self.assertEqual(name, 'bar') self.assertEqual(subpath, []) + self.assertEqual(traversed, [u'foo']) + self.assertEqual(vroot, root) + self.assertEqual(vroot_path, []) def test_call_withconn_getitem_withpath_withsubpath(self): foo = DummyContext() root = DummyContext(foo) policy = self._makeOne(root) environ = self._getEnviron(PATH_INFO='/foo/bar/baz/buz') - ctx, name, subpath = policy(environ) + ctx, name, subpath, traversed, vroot, vroot_path = policy(environ) self.assertEqual(ctx, foo) self.assertEqual(name, 'bar') self.assertEqual(subpath, ['baz', 'buz']) + self.assertEqual(traversed, [u'foo']) + self.assertEqual(vroot, root) + self.assertEqual(vroot_path, []) def test_call_with_explicit_viewname(self): foo = DummyContext() root = DummyContext(foo) policy = self._makeOne(root) environ = self._getEnviron(PATH_INFO='/@@foo') - ctx, name, subpath = policy(environ) + ctx, name, subpath, traversed, vroot, vroot_path = policy(environ) self.assertEqual(ctx, root) self.assertEqual(name, 'foo') self.assertEqual(subpath, []) + self.assertEqual(traversed, []) + self.assertEqual(vroot, root) + self.assertEqual(vroot_path, []) def test_call_with_vh_root(self): environ = self._getEnviron(PATH_INFO='/baz', HTTP_X_VHM_ROOT='/foo/bar') baz = DummyContext() + baz.name = 'baz' bar = DummyContext(baz) + bar.name = 'bar' foo = DummyContext(bar) + foo.name = 'foo' root = DummyContext(foo) + root.name = 'root' policy = self._makeOne(root) - ctx, name, subpath = policy(environ) + ctx, name, subpath, traversed, vroot, vroot_path = policy(environ) self.assertEqual(ctx, baz) self.assertEqual(name, '') self.assertEqual(subpath, []) + self.assertEqual(traversed, [u'foo', u'bar', u'baz']) + self.assertEqual(vroot, bar) + self.assertEqual(vroot_path, [u'foo', u'bar']) def test_call_with_ILocation_root_proxies(self): baz = DummyContext() @@ -161,7 +186,7 @@ class ModelGraphTraverserTests(unittest.TestCase): root.__parent__ = None policy = self._makeOne(root) environ = self._getEnviron(PATH_INFO='/foo/bar/baz') - ctx, name, subpath = policy(environ) + ctx, name, subpath, traversed, vroot, vroot_path = policy(environ) self.assertEqual(name, '') self.assertEqual(subpath, []) self.assertEqual(ctx, baz) @@ -177,6 +202,9 @@ class ModelGraphTraverserTests(unittest.TestCase): self.failIf(isProxy(ctx.__parent__.__parent__.__parent__)) self.assertEqual(ctx.__parent__.__parent__.__parent__.__name__, None) self.assertEqual(ctx.__parent__.__parent__.__parent__.__parent__, None) + self.assertEqual(traversed, [u'foo', u'bar', u'baz']) + self.assertEqual(vroot, root) + self.assertEqual(vroot_path, []) def test_call_with_ILocation_root_proxies_til_next_ILocation(self): # This is a test of an insane setup; it tests the case where @@ -200,7 +228,7 @@ class ModelGraphTraverserTests(unittest.TestCase): root.__parent__ = None policy = self._makeOne(root) environ = self._getEnviron(PATH_INFO='/foo/bar/baz') - ctx, name, subpath = policy(environ) + ctx, name, subpath, traversed, vroot, vroot_path = policy(environ) self.assertEqual(name, '') self.assertEqual(subpath, []) self.assertEqual(ctx, baz) @@ -208,6 +236,9 @@ class ModelGraphTraverserTests(unittest.TestCase): self.assertEqual(ctx.__name__, 'baz') self.assertEqual(ctx.__parent__, bar) self.failIf(isProxy(ctx.__parent__)) + self.assertEqual(traversed, [u'foo', u'bar', u'baz']) + self.assertEqual(vroot, root) + self.assertEqual(vroot_path, []) def test_non_utf8_path_segment_unicode_path_segments_fails(self): foo = DummyContext() diff --git a/repoze/bfg/tests/test_urldispatch.py b/repoze/bfg/tests/test_urldispatch.py index 0fc828161..fec394d56 100644 --- a/repoze/bfg/tests/test_urldispatch.py +++ b/repoze/bfg/tests/test_urldispatch.py @@ -248,6 +248,9 @@ class RoutesModelTraverserTests(unittest.TestCase): self.assertEqual(result[0], model) self.assertEqual(result[1], 'controller') self.assertEqual(result[2], []) + self.assertEqual(result[3], None) + self.assertEqual(result[4], model) + self.assertEqual(result[5], None) def test_call_with_only_view_name_bwcompat(self): model = DummyContext() @@ -257,6 +260,9 @@ class RoutesModelTraverserTests(unittest.TestCase): self.assertEqual(result[0], model) self.assertEqual(result[1], 'view_name') self.assertEqual(result[2], []) + self.assertEqual(result[3], None) + self.assertEqual(result[4], model) + self.assertEqual(result[5], None) def test_call_with_subpath_bwcompat(self): model = DummyContext() @@ -267,6 +273,9 @@ class RoutesModelTraverserTests(unittest.TestCase): self.assertEqual(result[0], model) self.assertEqual(result[1], 'view_name') self.assertEqual(result[2], ['a', 'b', 'c']) + self.assertEqual(result[3], None) + self.assertEqual(result[4], model) + self.assertEqual(result[5], None) def test_call_with_no_view_name_or_controller_bwcompat(self): model = DummyContext() @@ -275,6 +284,9 @@ class RoutesModelTraverserTests(unittest.TestCase): self.assertEqual(result[0], model) self.assertEqual(result[1], '') self.assertEqual(result[2], []) + self.assertEqual(result[3], None) + self.assertEqual(result[4], model) + self.assertEqual(result[5], None) def test_call_with_only_view_name(self): model = DummyContext() @@ -285,6 +297,9 @@ class RoutesModelTraverserTests(unittest.TestCase): self.assertEqual(result[0], model) self.assertEqual(result[1], 'view_name') self.assertEqual(result[2], []) + self.assertEqual(result[3], None) + self.assertEqual(result[4], model) + self.assertEqual(result[5], None) def test_call_with_view_name_and_subpath(self): model = DummyContext() @@ -295,6 +310,25 @@ class RoutesModelTraverserTests(unittest.TestCase): self.assertEqual(result[0], model) self.assertEqual(result[1], 'view_name') self.assertEqual(result[2], ['a', 'b','c']) + self.assertEqual(result[3], None) + self.assertEqual(result[4], model) + self.assertEqual(result[5], None) + + def test_with_path_info(self): + model = DummyContext() + traverser = self._makeOne(model) + routing_args = ((), {'view_name':'view_name', 'path_info':'foo/bar'}) + environ = {'wsgiorg.routing_args': routing_args, + 'PATH_INFO':'/a/b/foo/bar', 'SCRIPT_NAME':''} + result = traverser(environ) + self.assertEqual(result[0], model) + self.assertEqual(result[1], 'view_name') + self.assertEqual(result[2], []) + self.assertEqual(result[3], None) + self.assertEqual(result[4], model) + self.assertEqual(result[5], None) + self.assertEqual(environ['PATH_INFO'], '/foo/bar') + self.assertEqual(environ['SCRIPT_NAME'], '/a/b') class RoutesContextURLTests(unittest.TestCase): def _getTargetClass(self): diff --git a/repoze/bfg/tests/test_wsgi.py b/repoze/bfg/tests/test_wsgi.py index 1fd2393b8..b9568eb82 100644 --- a/repoze/bfg/tests/test_wsgi.py +++ b/repoze/bfg/tests/test_wsgi.py @@ -12,6 +12,103 @@ class WSGIAppTests(unittest.TestCase): response = decorator(context, request) self.assertEqual(response, dummyapp) +class WSGIApp2Tests(unittest.TestCase): + def _callFUT(self, app): + from repoze.bfg.wsgi import wsgiapp2 + return wsgiapp2(app) + + def test_decorator_traversed_is_None(self): + context = DummyContext() + request = DummyRequest() + request.traversed = None + decorator = self._callFUT(dummyapp) + response = decorator(context, request) + self.assertEqual(response, dummyapp) + + def test_decorator_traversed_not_None_with_subpath_and_view_name(self): + context = DummyContext() + request = DummyRequest() + request.traversed = ['a', 'b'] + request.virtual_root_path = ['a'] + request.subpath = ['subpath'] + request.view_name = 'view_name' + request.environ = {'SCRIPT_NAME':'/foo'} + decorator = self._callFUT(dummyapp) + response = decorator(context, request) + self.assertEqual(response, dummyapp) + self.assertEqual(request.environ['PATH_INFO'], '/subpath') + self.assertEqual(request.environ['SCRIPT_NAME'], '/foo/b/view_name') + + def test_decorator_traversed_not_None_with_subpath_no_view_name(self): + context = DummyContext() + request = DummyRequest() + request.traversed = ['a', 'b'] + request.virtual_root_path = ['a'] + request.subpath = ['subpath'] + request.view_name = '' + request.environ = {'SCRIPT_NAME':'/foo'} + decorator = self._callFUT(dummyapp) + response = decorator(context, request) + self.assertEqual(response, dummyapp) + self.assertEqual(request.environ['PATH_INFO'], '/subpath') + self.assertEqual(request.environ['SCRIPT_NAME'], '/foo/b') + + def test_decorator_traversed_not_None_no_subpath_with_view_name(self): + context = DummyContext() + request = DummyRequest() + request.traversed = ['a', 'b'] + request.virtual_root_path = ['a'] + request.subpath = [] + request.view_name = 'view_name' + request.environ = {'SCRIPT_NAME':'/foo'} + decorator = self._callFUT(dummyapp) + response = decorator(context, request) + self.assertEqual(response, dummyapp) + self.assertEqual(request.environ['PATH_INFO'], '/') + self.assertEqual(request.environ['SCRIPT_NAME'], '/foo/b/view_name') + + def test_decorator_traversed_empty_with_view_name(self): + context = DummyContext() + request = DummyRequest() + request.traversed = [] + request.virtual_root_path = [] + request.subpath = [] + request.view_name = 'view_name' + request.environ = {'SCRIPT_NAME':'/foo'} + decorator = self._callFUT(dummyapp) + response = decorator(context, request) + self.assertEqual(response, dummyapp) + self.assertEqual(request.environ['PATH_INFO'], '/') + self.assertEqual(request.environ['SCRIPT_NAME'], '/foo/view_name') + + def test_decorator_traversed_empty_no_view_name(self): + context = DummyContext() + request = DummyRequest() + request.traversed = [] + request.virtual_root_path = [] + request.subpath = [] + request.view_name = '' + request.environ = {'SCRIPT_NAME':'/foo'} + decorator = self._callFUT(dummyapp) + response = decorator(context, request) + self.assertEqual(response, dummyapp) + self.assertEqual(request.environ['PATH_INFO'], '/') + self.assertEqual(request.environ['SCRIPT_NAME'], '/foo') + + def test_decorator_traversed_empty_no_view_name_no_script_name(self): + context = DummyContext() + request = DummyRequest() + request.traversed = [] + request.virtual_root_path = [] + request.subpath = [] + request.view_name = '' + request.environ = {'SCRIPT_NAME':''} + decorator = self._callFUT(dummyapp) + response = decorator(context, request) + self.assertEqual(response, dummyapp) + self.assertEqual(request.environ['PATH_INFO'], '/') + self.assertEqual(request.environ['SCRIPT_NAME'], '') + class TestNotFound(unittest.TestCase): def _getTargetClass(self): from repoze.bfg.wsgi import NotFound -- cgit v1.2.3