Merge unifyroutesandtraversal branch into trunk

7 files changed, 414 insertions, 479 deletions

diff --git a/repoze/bfg/tests/test_authentication.py b/repoze/bfg/tests/test_authentication.py
index 09782cd3c..258fadfd2 100644
--- a/repoze/bfg/tests/test_authentication.py
+++ b/repoze/bfg/tests/test_authentication.py
@@ -361,20 +361,23 @@ class TestAuthTktCookieHelper(unittest.TestCase):
         plugin = self._makeOne('secret')
         old_val = self._makeTicket(userid='userid')
         request = self._makeRequest({'HTTP_COOKIE':'auth_tkt=%s' % old_val})
-        new_val = self._makeTicket(userid='other', userdata='userdata')
         result = plugin.remember(request, 'other', userdata='userdata')
         self.assertEqual(len(result), 3)
-        self.assertEqual(result[0],
-                         ('Set-Cookie',
-                          'auth_tkt="%s"; Path=/' % new_val))
-        self.assertEqual(result[1],
-                         ('Set-Cookie',
-                           'auth_tkt="%s"; Path=/; Domain=localhost'
-                            % new_val))
-        self.assertEqual(result[2],
-                         ('Set-Cookie',
-                           'auth_tkt="%s"; Path=/; Domain=.localhost'
-                            % new_val))
+
+        self.assertEqual(result[0][0], 'Set-Cookie')
+        self.failUnless(result[0][1].endswith('; Path=/'))
+        self.failUnless(result[0][1].startswith('auth_tkt='))
+        self.failIf(result[0][1].startswith('auth_tkt="%s"' % old_val))
+
+        self.assertEqual(result[1][0], 'Set-Cookie')
+        self.failUnless(result[1][1].endswith('; Path=/; Domain=localhost'))
+        self.failUnless(result[1][1].startswith('auth_tkt='))
+        self.failIf(result[1][1].startswith('auth_tkt="%s"' % old_val))
+
+        self.assertEqual(result[2][0], 'Set-Cookie')
+        self.failUnless(result[2][1].endswith('; Path=/; Domain=.localhost'))
+        self.failUnless(result[2][1].startswith('auth_tkt='))
+        self.failIf(result[2][1].startswith('auth_tkt="%s"' % old_val))
 
     def test_remember_creds_different_include_ip(self):
         plugin = self._makeOne('secret', include_ip=True)
diff --git a/repoze/bfg/tests/test_integration.py b/repoze/bfg/tests/test_integration.py
index 9c2d87135..107c8ae89 100644
--- a/repoze/bfg/tests/test_integration.py
+++ b/repoze/bfg/tests/test_integration.py
@@ -19,6 +19,10 @@ def wsgiapptest(environ, start_response):
     """ """
     return '123'
 
+def _getRequestInterface(name_or_iface=None):
+    from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
+    return DEFAULT_REQUEST_FACTORIES[name_or_iface]['interface']
+
 class WGSIAppPlusBFGViewTests(unittest.TestCase):
     def setUp(self):
         cleanUp()
@@ -36,7 +40,7 @@ class WGSIAppPlusBFGViewTests(unittest.TestCase):
         self.assertEqual(result, '123')
 
     def test_scanned(self):
-        from repoze.bfg.interfaces import IRequest
+        IRequest = _getRequestInterface()
         from repoze.bfg.interfaces import IView
         from repoze.bfg.zcml import scan
         context = DummyContext()
@@ -76,7 +80,6 @@ class PushPagePlusBFGViewTests(unittest.TestCase):
         self.assertEqual(result.status, '200 OK')
 
     def test_scanned(self):
-        from repoze.bfg.interfaces import IRequest
         from repoze.bfg.interfaces import IView
         from repoze.bfg.zcml import scan
         context = DummyContext()
@@ -85,6 +88,7 @@ class PushPagePlusBFGViewTests(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 2)
         action = actions[0]
+        IRequest = _getRequestInterface()
         self.assertEqual(action['args'],
                          ('registerAdapter',
                           pushtest, (INothing, IRequest), IView, '', None))
@@ -139,7 +143,6 @@ class TestGrokkedApp(unittest.TestCase):
     def test_it(self):
         import inspect
         from repoze.bfg.interfaces import IPOSTRequest
-        from repoze.bfg.interfaces import IRequest
         from repoze.bfg.interfaces import IView
         import repoze.bfg.tests.grokkedapp as package
         from zope.configuration import config
@@ -150,22 +153,25 @@ class TestGrokkedApp(unittest.TestCase):
         xmlconfig.include(context, 'configure.zcml', package)
         actions = context.actions
 
+        post_iface = _getRequestInterface(IPOSTRequest)
+        request_iface = _getRequestInterface()
+
         postview = actions[-1]
         self.assertEqual(postview[0][1], None)
         self.assertEqual(postview[0][2], '')
-        self.assertEqual(postview[0][3], IPOSTRequest)
+        self.assertEqual(postview[0][3], post_iface)
         self.assertEqual(postview[0][4], IView)
         self.assertEqual(postview[2][1], package.grokked_post)
-        self.assertEqual(postview[2][2], (None, IPOSTRequest))
+        self.assertEqual(postview[2][2], (None, post_iface))
         self.assertEqual(postview[2][3], IView)
         
         klassview = actions[-2]
         self.assertEqual(klassview[0][1], None)
         self.assertEqual(klassview[0][2], 'grokked_klass')
-        self.assertEqual(klassview[0][3], IRequest)
+        self.assertEqual(klassview[0][3], request_iface)
         self.assertEqual(klassview[0][4], IView)
         self.assertEqual(klassview[2][1], package.grokked_klass)
-        self.assertEqual(klassview[2][2], (None, IRequest))
+        self.assertEqual(klassview[2][2], (None, request_iface))
         self.assertEqual(klassview[2][3], IView)
         self.failUnless(inspect.isfunction(package.grokked_klass))
         self.assertEqual(package.grokked_klass(None, None), None)
@@ -173,10 +179,10 @@ class TestGrokkedApp(unittest.TestCase):
         funcview = actions[-3]
         self.assertEqual(funcview[0][1], None)
         self.assertEqual(funcview[0][2], '')
-        self.assertEqual(funcview[0][3], IRequest)
+        self.assertEqual(funcview[0][3], request_iface)
         self.assertEqual(funcview[0][4], IView)
         self.assertEqual(funcview[2][1], package.grokked)
-        self.assertEqual(funcview[2][2], (None, IRequest))
+        self.assertEqual(funcview[2][2], (None, request_iface))
         self.assertEqual(funcview[2][3], IView)
 
 class DummyContext:
diff --git a/repoze/bfg/tests/test_request.py b/repoze/bfg/tests/test_request.py
index 4771c3e1c..9cae6643a 100644
--- a/repoze/bfg/tests/test_request.py
+++ b/repoze/bfg/tests/test_request.py
@@ -13,8 +13,8 @@ class TestMakeRequestASCII(unittest.TestCase):
 
 class TestSubclassedRequest(unittest.TestCase):
     def _getTargetClass(self):
-        from repoze.bfg.request import Request
-        return Request
+        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
+        return DEFAULT_REQUEST_FACTORIES[None]['factory']
     
     def _makeOne(self, environ):
         request = self._getTargetClass()(environ)
@@ -56,6 +56,172 @@ class TestCurrentRequest(unittest.TestCase):
             manager.pop()
         self.assertEqual(self._callFUT(), None)
 
+class TestRequestFactory(unittest.TestCase):
+    def _callFUT(self, environ):
+        from repoze.bfg.request import request_factory
+        return request_factory(environ)
+
+    def _getRequestFactory(self, name_or_iface=None):
+        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
+        return DEFAULT_REQUEST_FACTORIES[name_or_iface]['factory']
+
+    def _makeRoute(self):
+        route = DummyRoute()
+        factories = {}
+        def factory(environ):
+            return environ
+        for name in (None, 'GET', 'POST', 'PUT', 'DELETE', 'HEAD'):
+            factories[name] = {'factory':factory}
+        route.request_factories = factories
+        return route
+
+    def test_no_route_no_request_method(self):
+        from repoze.bfg.interfaces import IRequest
+        result = self._callFUT({})
+        self.assertEqual(result.__class__, self._getRequestFactory())
+        self.failUnless(IRequest.providedBy(result))
+
+    def test_no_route_unknown(self):
+        from repoze.bfg.interfaces import IRequest
+        result = self._callFUT({'REQUEST_METHOD':'UNKNOWN'})
+        self.assertEqual(result.__class__, self._getRequestFactory())
+        self.failUnless(IRequest.providedBy(result))
+
+    def test_no_route_get(self):
+        from repoze.bfg.interfaces import IGETRequest
+        result = self._callFUT({'REQUEST_METHOD':'GET'})
+        self.assertEqual(result.__class__, self._getRequestFactory('GET'))
+        self.failUnless(IGETRequest.providedBy(result))
+
+    def test_no_route_post(self):
+        from repoze.bfg.interfaces import IPOSTRequest
+        result = self._callFUT({'REQUEST_METHOD':'POST'})
+        self.assertEqual(result.__class__, self._getRequestFactory('POST'))
+        self.failUnless(IPOSTRequest.providedBy(result))
+
+    def test_no_route_put(self):
+        from repoze.bfg.interfaces import IPUTRequest
+        result = self._callFUT({'REQUEST_METHOD':'PUT'})
+        self.assertEqual(result.__class__, self._getRequestFactory('PUT'))
+        self.failUnless(IPUTRequest.providedBy(result))
+
+    def test_no_route_delete(self):
+        from repoze.bfg.interfaces import IDELETERequest
+        result = self._callFUT({'REQUEST_METHOD':'DELETE'})
+        self.assertEqual(result.__class__, self._getRequestFactory('DELETE'))
+        self.failUnless(IDELETERequest.providedBy(result))
+
+    def test_no_route_head(self):
+        from repoze.bfg.interfaces import IHEADRequest
+        result = self._callFUT({'REQUEST_METHOD':'HEAD'})
+        self.assertEqual(result.__class__, self._getRequestFactory('HEAD'))
+        self.failUnless(IHEADRequest.providedBy(result))
+
+    def test_route_no_request_method(self):
+        route = self._makeRoute()
+        environ = {'bfg.routes.route':route}
+        result = self._callFUT(environ)
+        self.assertEqual(result, environ)
+
+    def test_route_unknown(self):
+        route = self._makeRoute()
+        environ = {'bfg.routes.route':route, 'REQUEST_METHOD':'UNKNOWN'}
+        result = self._callFUT(environ)
+        self.assertEqual(result, environ)
+
+    def test_route_known(self):
+        route = self._makeRoute()
+        environ = {'bfg.routes.route':route, 'REQUEST_METHOD':'GET'}
+        result = self._callFUT(environ)
+        self.assertEqual(result, environ)
+
+class TestNamedRequestFactories(unittest.TestCase):
+    def _callFUT(self, name):
+        from repoze.bfg.request import named_request_factories
+        return named_request_factories(name)
+
+    def test_it_unnamed(self):
+        factories = self._callFUT(None)
+        from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.interfaces import IGETRequest
+        from repoze.bfg.interfaces import IPOSTRequest
+        from repoze.bfg.interfaces import IPUTRequest
+        from repoze.bfg.interfaces import IDELETERequest
+        from repoze.bfg.interfaces import IHEADRequest
+        for alias, iface in (
+            (None, IRequest),
+            ('GET', IGETRequest),
+            ('POST', IPOSTRequest),
+            ('PUT', IPUTRequest),
+            ('DELETE', IDELETERequest),
+            ('HEAD', IHEADRequest),
+            ):
+            self.failUnless(alias in factories)
+            self.failUnless(iface in factories)
+            self.assertEqual(factories[alias], factories[iface])
+            named_iface = factories[alias]['interface']
+            named_factory = factories[alias]['factory']
+            self.failUnless(named_iface.implementedBy(named_factory))
+            self.assertEqual(factories[alias]['interface'], iface)
+            self.assertEqual(factories[iface]['interface'], iface)
+            self.assertEqual(factories[alias]['factory'].charset, 'utf-8')
+
+    def test_it_named(self):
+        factories = self._callFUT('name')
+        from zope.interface.interface import InterfaceClass
+        from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.interfaces import IGETRequest
+        from repoze.bfg.interfaces import IPOSTRequest
+        from repoze.bfg.interfaces import IPUTRequest
+        from repoze.bfg.interfaces import IDELETERequest
+        from repoze.bfg.interfaces import IHEADRequest
+        for alias, iface in (
+            (None, IRequest),
+            ('GET', IGETRequest),
+            ('POST', IPOSTRequest),
+            ('PUT', IPUTRequest),
+            ('DELETE', IDELETERequest),
+            ('HEAD', IHEADRequest),
+            ):
+            self.failUnless(alias in factories)
+            self.failUnless(iface in factories)
+            self.assertEqual(factories[alias], factories[iface])
+            self.assertEqual(factories[alias]['factory'].charset, 'utf-8')
+            named_iface = factories[alias]['interface']
+            named_factory = factories[alias]['factory']
+            self.failUnless(named_iface.implementedBy(named_factory))
+
+class TestDefaultRequestFactories(unittest.TestCase):
+    def test_it(self):
+        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES as factories
+        from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.interfaces import IGETRequest
+        from repoze.bfg.interfaces import IPOSTRequest
+        from repoze.bfg.interfaces import IPUTRequest
+        from repoze.bfg.interfaces import IDELETERequest
+        from repoze.bfg.interfaces import IHEADRequest
+        for alias, iface in (
+            (None, IRequest),
+            ('GET', IGETRequest),
+            ('POST', IPOSTRequest),
+            ('PUT', IPUTRequest),
+            ('DELETE', IDELETERequest),
+            ('HEAD', IHEADRequest),
+            ):
+            self.failUnless(alias in factories)
+            self.failUnless(iface in factories)
+            self.assertEqual(factories[alias], factories[iface])
+            named_iface = factories[alias]['interface']
+            named_factory = factories[alias]['factory']
+            self.failUnless(named_iface.implementedBy(named_factory))
+            self.assertEqual(factories[alias]['interface'], iface)
+            self.assertEqual(factories[iface]['interface'], iface)
+            self.assertEqual(factories[alias]['factory'].charset, 'utf-8')
+
+
+class DummyRoute:
+    pass
+
 class DummyRequest:
     pass
 
diff --git a/repoze/bfg/tests/test_router.py b/repoze/bfg/tests/test_router.py
index 6e18f6089..589843b0f 100644
--- a/repoze/bfg/tests/test_router.py
+++ b/repoze/bfg/tests/test_router.py
@@ -123,7 +123,7 @@ class RouterTests(unittest.TestCase):
         environ = self._makeEnviron()
         context = DummyContext()
         self._registerTraverserFactory(context)
-        rootfactory = self._registerRootFactory(None)
+        rootfactory = self._registerRootFactory('abc')
         router = self._makeOne()
         self.assertEqual(router.root_policy, rootfactory)
 
@@ -132,13 +132,11 @@ class RouterTests(unittest.TestCase):
         def app():
             """ """
         self.registry.registerUtility(app, IForbiddenView)
-        self._registerRootFactory(None)
         router = self._makeOne()
         self.assertEqual(router.forbidden_view, app)
 
     def test_iforbiddenview_nooverride(self):
         context = DummyContext()
-        self._registerRootFactory(None)
         router = self._makeOne()
         from repoze.bfg.router import default_forbidden_view
         self.assertEqual(router.forbidden_view, default_forbidden_view)
@@ -148,13 +146,11 @@ class RouterTests(unittest.TestCase):
         def app():
             """ """
         self.registry.registerUtility(app, INotFoundView)
-        self._registerRootFactory(None)
         router = self._makeOne()
         self.assertEqual(router.notfound_view, app)
 
     def test_inotfoundview_nooverride(self):
         context = DummyContext()
-        self._registerRootFactory(None)
         router = self._makeOne()
         from repoze.bfg.router import default_notfound_view
         self.assertEqual(router.notfound_view, default_notfound_view)
@@ -164,7 +160,6 @@ class RouterTests(unittest.TestCase):
         environ = self._makeEnviron()
         context = DummyContext()
         self._registerTraverserFactory(context)
-        rootfactory = self._registerRootFactory(None)
         logger = self._registerLogger()
         def factory():
             return 'yo'
@@ -183,7 +178,6 @@ class RouterTests(unittest.TestCase):
         environ = self._makeEnviron()
         context = DummyContext()
         self._registerTraverserFactory(context)
-        rootfactory = self._registerRootFactory(None)
         logger = self._registerLogger()
         def factory():
             return 'yo'
@@ -202,7 +196,6 @@ class RouterTests(unittest.TestCase):
         context = DummyContext()
         self._registerTraverserFactory(context)
         logger = self._registerLogger()
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -214,29 +207,12 @@ class RouterTests(unittest.TestCase):
         self.failIf('debug_notfound' in result[0])
         self.assertEqual(len(logger.messages), 0)
 
-    def test_call_root_is_icontextnotfound(self):
-        from zope.interface import implements
-        from repoze.bfg.interfaces import IContextNotFound
-        class NotFound(object):
-            implements(IContextNotFound)
-        context = NotFound()
-        self._registerTraverserFactory(context)
-        environ = self._makeEnviron()
-        start_response = DummyStartResponse()
-        self._registerRootFactory(NotFound())
-        router = self._makeOne()
-        result = router(environ, start_response)
-        status = start_response.status
-        self.assertEqual(status, '404 Not Found')
-        self.failUnless('http://localhost:8080' in result[0], result)
-
     def test_call_no_view_registered_debug_notfound_false(self):
         environ = self._makeEnviron()
         context = DummyContext()
         self._registerTraverserFactory(context)
         logger = self._registerLogger()
         self._registerSettings(debug_notfound=False)
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -254,7 +230,6 @@ class RouterTests(unittest.TestCase):
         self._registerTraverserFactory(context)
         self._registerSettings(debug_notfound=True)
         logger = self._registerLogger()
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -282,7 +257,6 @@ class RouterTests(unittest.TestCase):
         environ = self._makeEnviron()
         view = make_view('abc')
         self._registerView(view, '', None, None)
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         self.assertRaises(ValueError, router, environ, start_response)
@@ -292,7 +266,6 @@ class RouterTests(unittest.TestCase):
         context = DummyContext()
         environ = self._makeEnviron()
         self._registerTraverserFactory(context)
-        self._registerRootFactory(None)
         def app(context, request):
             """ """
         self.registry.registerUtility(app, INotFoundView)
@@ -318,7 +291,6 @@ class RouterTests(unittest.TestCase):
         environ = self._makeEnviron()
         self._registerView(view, '', IContext, IRequest)
         checker = self._registerViewPermission('', denied)
-        self._registerRootFactory(None)
         def app(context, request):
             """ """
         self.registry.registerUtility(app, IForbiddenView)
@@ -334,7 +306,7 @@ class RouterTests(unittest.TestCase):
         view = make_view(response)
         environ = self._makeEnviron()
         self._registerView(view, '', None, None)
-        self._registerRootFactory(None)
+        rootfactory = self._registerRootFactory(context)
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -344,7 +316,7 @@ class RouterTests(unittest.TestCase):
         self.assertEqual(environ['webob.adhoc_attrs']['view_name'], '')
         self.assertEqual(environ['webob.adhoc_attrs']['subpath'], [])
         self.assertEqual(environ['webob.adhoc_attrs']['context'], context)
-        self.assertEqual(environ['webob.adhoc_attrs']['root'], None)
+        self.assertEqual(environ['webob.adhoc_attrs']['root'], context)
 
     def test_call_deprecation_warning(self):
         context = DummyContext()
@@ -354,7 +326,6 @@ class RouterTests(unittest.TestCase):
         view = make_view(response)
         environ = self._makeEnviron()
         self._registerView(view, '', None, None)
-        self._registerRootFactory(None)
         router = self._makeOne()
         logger = self._registerLogger()
         router.logger = logger
@@ -368,12 +339,12 @@ class RouterTests(unittest.TestCase):
         self._registerTraverserFactory(context, view_name='foo',
                                        subpath=['bar'],
                                        traversed=['context'])
+        rootfactory = self._registerRootFactory(context)
         response = DummyResponse()
         response.app_iter = ['Hello world']
         view = make_view(response)
         environ = self._makeEnviron()
         self._registerView(view, 'foo', None, None)
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -383,7 +354,7 @@ class RouterTests(unittest.TestCase):
         self.assertEqual(environ['webob.adhoc_attrs']['view_name'], 'foo')
         self.assertEqual(environ['webob.adhoc_attrs']['subpath'], ['bar'])
         self.assertEqual(environ['webob.adhoc_attrs']['context'], context)
-        self.assertEqual(environ['webob.adhoc_attrs']['root'], None)
+        self.assertEqual(environ['webob.adhoc_attrs']['root'], context)
 
     def test_call_view_registered_specific_success(self):
         from zope.interface import Interface
@@ -394,12 +365,12 @@ class RouterTests(unittest.TestCase):
         context = DummyContext()
         directlyProvides(context, IContext)
         self._registerTraverserFactory(context)
+        rootfactory = self._registerRootFactory(context)
         response = DummyResponse()
         response.app_iter = ['Hello world']
         view = make_view(response)
         environ = self._makeEnviron()
         self._registerView(view, '', IContext, IRequest)
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -409,7 +380,7 @@ class RouterTests(unittest.TestCase):
         self.assertEqual(environ['webob.adhoc_attrs']['view_name'], '')
         self.assertEqual(environ['webob.adhoc_attrs']['subpath'], [])
         self.assertEqual(environ['webob.adhoc_attrs']['context'], context)
-        self.assertEqual(environ['webob.adhoc_attrs']['root'], None)
+        self.assertEqual(environ['webob.adhoc_attrs']['root'], context)
 
     def test_call_view_registered_specific_fail(self):
         from zope.interface import Interface
@@ -426,7 +397,6 @@ class RouterTests(unittest.TestCase):
         view = make_view(response)
         environ = self._makeEnviron()
         self._registerView(view, '', IContext, IRequest)
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -446,7 +416,6 @@ class RouterTests(unittest.TestCase):
         view = make_view(response)
         environ = self._makeEnviron()
         self._registerView(view, '', IContext, IRequest)
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -466,7 +435,6 @@ class RouterTests(unittest.TestCase):
         view = make_view(response)
         environ = self._makeEnviron()
         self._registerView(view, '', IContext, IRequest)
-        self._registerRootFactory(None)
         router = self._makeOne()
         router.debug_authorization = True
         start_response = DummyStartResponse()
@@ -490,7 +458,6 @@ class RouterTests(unittest.TestCase):
         view = make_view(response)
         environ = self._makeEnviron()
         self._registerView(view, '', IContext, IRequest)
-        self._registerRootFactory(None)
         router = self._makeOne()
         router.debug_authorization = True
         start_response = DummyStartResponse()
@@ -514,7 +481,6 @@ class RouterTests(unittest.TestCase):
         view = make_view(response)
         environ = self._makeEnviron()
         self._registerView(view, '', IContext, IRequest)
-        self._registerRootFactory(None)
         router = self._makeOne()
         router.debug_authorization = False
         start_response = DummyStartResponse()
@@ -537,7 +503,6 @@ class RouterTests(unittest.TestCase):
         environ = self._makeEnviron()
         self._registerView(view, '', IContext, IRequest)
         checker = self._registerViewPermission('', True)
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -561,7 +526,6 @@ class RouterTests(unittest.TestCase):
         environ = self._makeEnviron()
         self._registerView(view, '', IContext, IRequest)
         checker = self._registerViewPermission('', denied)
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -588,7 +552,6 @@ class RouterTests(unittest.TestCase):
         self._registerView(view, '', IContext, IRequest)
         checker = self._registerViewPermission('', denied)
         self._registerSettings(debug_authorization=False)
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -616,7 +579,6 @@ class RouterTests(unittest.TestCase):
         checker = self._registerViewPermission('', allowed)
         self._registerSettings(debug_authorization=True)
         logger = self._registerLogger()
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -650,7 +612,6 @@ class RouterTests(unittest.TestCase):
         from repoze.bfg.interfaces import INewResponse
         request_events = self._registerEventListener(INewRequest)
         response_events = self._registerEventListener(INewResponse)
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -667,7 +628,6 @@ class RouterTests(unittest.TestCase):
         view = make_view(response)
         environ = self._makeEnviron()
         self._registerView(view, '', None, None)
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         router.threadlocal_manager = DummyThreadLocalManager()
@@ -687,7 +647,6 @@ class RouterTests(unittest.TestCase):
         view = make_view(response)
         environ = self._makeEnviron(REQUEST_METHOD='POST')
         self._registerView(view, '', None, None)
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         request_events = self._registerEventListener(INewRequest)
@@ -709,7 +668,6 @@ class RouterTests(unittest.TestCase):
         view = make_view(response)
         environ = self._makeEnviron(REQUEST_METHOD='PUT')
         self._registerView(view, '', None, None)
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         request_events = self._registerEventListener(INewRequest)
@@ -729,7 +687,6 @@ class RouterTests(unittest.TestCase):
         view = make_view(response)
         environ = self._makeEnviron(REQUEST_METHOD='UNKNOWN')
         self._registerView(view, '', None, None)
-        self._registerRootFactory(None)
         router = self._makeOne()
         start_response = DummyStartResponse()
         request_events = self._registerEventListener(INewRequest)
@@ -737,30 +694,6 @@ class RouterTests(unittest.TestCase):
         request = request_events[0].request
         self.failUnless(IRequest.providedBy(request))
 
-    def test_call_irequestfactory_override(self):
-        from repoze.bfg.interfaces import INewRequest
-        from repoze.bfg.interfaces import IRequestFactory
-        from repoze.bfg.testing import DummyRequest
-        self.registry.registerUtility(DummyRequest, IRequestFactory)
-        context = DummyContext()
-        self._registerTraverserFactory(context)
-        response = DummyResponse()
-        response.app_iter = ['Hello world']
-        view = make_view(response)
-        environ = self._makeEnviron()
-        self._registerView(view, '', None, None)
-        self._registerRootFactory(None)
-        router = self._makeOne()
-        start_response = DummyStartResponse()
-        request_events = self._registerEventListener(INewRequest)
-        result = router(environ, start_response)
-        request = request_events[0].request
-        self.failUnless(isinstance(request, DummyRequest))
-        self.assertEqual(request.root, None)
-        self.assertEqual(request.context, context)
-        self.assertEqual(request.view_name, '')
-        self.assertEqual(request.subpath, [])
-
 class MakeAppTests(unittest.TestCase):
     def setUp(self):
         cleanUp()
@@ -844,13 +777,14 @@ class MakeAppTests(unittest.TestCase):
         self.assertEqual(settings.reload_templates, True)
         self.assertEqual(settings.debug_authorization, True)
         self.failUnless(isinstance(rootfactory, RoutesRootFactory))
-        self.assertEqual(rootfactory.get_root, rootpolicy)
+        self.assertEqual(rootfactory.default_root_factory, rootpolicy)
         self.failUnless(self.regmgr.pushed and self.regmgr.popped)
 
     def test_routes_in_config_no_rootpolicy(self):
         options= {'reload_templates':True,
                   'debug_authorization':True}
         from repoze.bfg.urldispatch import RoutesRootFactory
+        from repoze.bfg.router import DefaultRootFactory
         from repoze.bfg.tests import routesapp
         app = self._callFUT(None, routesapp, options=options)
         from repoze.bfg.interfaces import ISettings
@@ -863,15 +797,18 @@ class MakeAppTests(unittest.TestCase):
         self.assertEqual(settings.reload_templates, True)
         self.assertEqual(settings.debug_authorization, True)
         self.failUnless(isinstance(rootfactory, RoutesRootFactory))
-        self.assertEqual(rootfactory.get_root, None)
+        self.assertEqual(rootfactory.default_root_factory, DefaultRootFactory)
         self.failUnless(self.regmgr.pushed and self.regmgr.popped)
         
     def test_no_routes_in_config_no_rootpolicy(self):
+        from repoze.bfg.router import DefaultRootFactory
+        from repoze.bfg.interfaces import IRootFactory
         options= {'reload_templates':True,
                   'debug_authorization':True}
         from repoze.bfg.tests import fixtureapp
-        self.assertRaises(ValueError, self._callFUT, None, fixtureapp,
-                          options=options)
+        app = self._callFUT(None, fixtureapp, options=options)
+        rootfactory = app.registry.getUtility(IRootFactory)
+        self.assertEqual(rootfactory, DefaultRootFactory)
 
     def test_authorization_policy_no_authentication_policy(self):
         from repoze.bfg.interfaces import IAuthorizationPolicy
@@ -922,38 +859,6 @@ class MakeAppTests(unittest.TestCase):
         self.assertEqual(len(logger.messages), 1)
         self.failUnless('ISecurityPolicy' in logger.messages[0])
 
-    def test_custom_default_context_factory_nodecorate(self):
-        from repoze.bfg.tests import routesapp
-        from zope.component import getGlobalSiteManager
-        from repoze.bfg.interfaces import IRoutesContextFactory
-        from repoze.bfg.interfaces import IRoutesMapper
-        class Dummy(object):
-            pass
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(Dummy, IRoutesContextFactory)
-        app = self._callFUT(None, routesapp, registry=gsm)
-        mapper = gsm.getUtility(IRoutesMapper)
-        self.assertEqual(mapper.default_context_factory,
-                         Dummy)
-        self.assertEqual(mapper.decorate_context, True)
-
-    def test_custom_default_context_factory_decorate(self):
-        from repoze.bfg.tests import routesapp
-        from zope.component import getGlobalSiteManager
-        from repoze.bfg.interfaces import IRoutesContextFactory
-        from repoze.bfg.interfaces import IRoutesMapper
-        from repoze.bfg.interfaces import IRoutesContext
-        from zope.interface import implements
-        class Dummy(object):
-            implements(IRoutesContext)
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(Dummy, IRoutesContextFactory)
-        app = self._callFUT(None, routesapp, registry=gsm)
-        mapper = gsm.getUtility(IRoutesMapper)
-        self.assertEqual(mapper.default_context_factory,
-                         Dummy)
-        self.assertEqual(mapper.decorate_context, False)
-
 class TestDefaultForbiddenView(unittest.TestCase):
     def _callFUT(self, context, request):
         from repoze.bfg.router import default_forbidden_view
diff --git a/repoze/bfg/tests/test_traversal.py b/repoze/bfg/tests/test_traversal.py
index 41cf667b9..506a69d17 100644
--- a/repoze/bfg/tests/test_traversal.py
+++ b/repoze/bfg/tests/test_traversal.py
@@ -189,6 +189,67 @@ class ModelGraphTraverserTests(unittest.TestCase):
         environ = self._getEnviron(PATH_INFO='/%s' % segment)
         self.assertRaises(TypeError, policy, environ)
 
+    def test_withroute_nothingfancy(self):
+        model = DummyContext()
+        traverser = self._makeOne(model)
+        routing_args = ((), {})
+        environ = {'bfg.routes.matchdict': {}}
+        result = traverser(environ)
+        self.assertEqual(result['context'], model)
+        self.assertEqual(result['view_name'], '')
+        self.assertEqual(result['subpath'], [])
+        self.assertEqual(result['traversed'], [])
+        self.assertEqual(result['virtual_root'], model)
+        self.assertEqual(result['virtual_root_path'], [])
+
+    def test_withroute_with_subpath(self):
+        model = DummyContext()
+        traverser = self._makeOne(model)
+        environ = {'bfg.routes.matchdict': {'subpath':'/a/b/c'}}
+        result = traverser(environ)
+        self.assertEqual(result['context'], model)
+        self.assertEqual(result['view_name'], '')
+        self.assertEqual(result['subpath'], ['a', 'b','c'])
+        self.assertEqual(result['traversed'], [])
+        self.assertEqual(result['virtual_root'], model)
+        self.assertEqual(result['virtual_root_path'], [])
+
+    def test_withroute_with_path_info(self):
+        model = DummyContext()
+        traverser = self._makeOne(model)
+        environ = {'bfg.routes.matchdict': {'path_info':'foo/bar'},
+                   'PATH_INFO':'/a/b/foo/bar', 'SCRIPT_NAME':''}
+        result = traverser(environ)
+        self.assertEqual(result['context'], model)
+        self.assertEqual(result['view_name'], '')
+        self.assertEqual(result['subpath'], [])
+        self.assertEqual(result['traversed'], [])
+        self.assertEqual(result['virtual_root'], model)
+        self.assertEqual(result['virtual_root_path'], [])
+        self.assertEqual(environ['PATH_INFO'], '/foo/bar')
+        self.assertEqual(environ['SCRIPT_NAME'], '/a/b')
+
+    def test_withroute_with_path_info_PATH_INFO_w_extra_slash(self):
+        model = DummyContext()
+        traverser = self._makeOne(model)
+        environ = {'bfg.routes.matchdict':{'path_info':'foo/bar'},
+                   'PATH_INFO':'/a/b//foo/bar', 'SCRIPT_NAME':''}
+        traverser(environ)
+        self.assertEqual(environ['PATH_INFO'], '/foo/bar')
+        self.assertEqual(environ['SCRIPT_NAME'], '/a/b')
+
+    def test_withroute_and_traverse(self):
+        model = DummyContext()
+        traverser = self._makeOne(model)
+        environ = {'bfg.routes.matchdict': {'traverse':'foo/bar'}}
+        result = traverser(environ)
+        self.assertEqual(result['context'], model)
+        self.assertEqual(result['view_name'], 'foo')
+        self.assertEqual(result['subpath'], ['bar'])
+        self.assertEqual(result['traversed'], [])
+        self.assertEqual(result['virtual_root'], model)
+        self.assertEqual(result['virtual_root_path'], [])
+
 class FindInterfaceTests(unittest.TestCase):
     def _callFUT(self, context, iface):
         from repoze.bfg.traversal import find_interface
@@ -637,7 +698,21 @@ class TraversalContextURLTests(unittest.TestCase):
         context_url = self._makeOne(bar, request)
         result = context_url()
         self.assertEqual(result, 'http://example.com:5432//bar/')
-        
+
+    def test_with_route(self):
+        root = DummyContext()
+        root.__name__ = None
+        root.__parent__ = None
+        one = DummyContext()
+        one.__name__ = 'one'
+        one.__parent__ = root
+        route = DummyRoute()
+        request = DummyRequest({'bfg.routes.route':route,
+                                'bfg.routes.matchdict':{'a':1}})
+        context_url = self._makeOne(one, request)
+        result = context_url()
+        self.assertEqual(result, 'http://example.com/one/')
+        self.assertEqual(route.generate_kw, {'a':1, 'traverse':'/one/'})
 
 class TestVirtualRoot(unittest.TestCase):
     def setUp(self):
@@ -839,3 +914,8 @@ class DummyContextURL:
 
     def virtual_root(self):
         return '123'
+
+class DummyRoute:
+    def generate(self, **kw):
+        self.generate_kw = kw
+        return 'http://example.com'
diff --git a/repoze/bfg/tests/test_urldispatch.py b/repoze/bfg/tests/test_urldispatch.py
index 2b4578f94..68fda032d 100644
--- a/repoze/bfg/tests/test_urldispatch.py
+++ b/repoze/bfg/tests/test_urldispatch.py
@@ -22,139 +22,78 @@ class RoutesRootFactoryTests(unittest.TestCase):
         klass = self._getTargetClass()
         return klass(get_root)
 
-    def test_init_default_context_factory(self):
-        from zope.component import getGlobalSiteManager
-        from repoze.bfg.interfaces import IRoutesContextFactory
-        from repoze.bfg.urldispatch import DefaultRoutesContext
-        class Dummy(object):
-            pass
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(Dummy, IRoutesContextFactory)
+    def test_init_default_root_factory(self):
         mapper = self._makeOne(None)
-        self.assertEqual(mapper.default_context_factory, DefaultRoutesContext)
-        self.assertEqual(mapper.decorate_context, True)
+        self.assertEqual(mapper.default_root_factory, None)
 
     def test_no_route_matches(self):
-        marker = ()
-        get_root = make_get_root(marker)
+        get_root = make_get_root(123)
         mapper = self._makeOne(get_root)
         environ = self._getEnviron(PATH_INFO='/')
         result = mapper(environ)
-        self.assertEqual(result, marker)
+        self.assertEqual(result, 123)
         self.assertEqual(mapper.environ, environ)
 
     def test_route_matches(self):
-        marker = ()
-        get_root = make_get_root(marker)
+        get_root = make_get_root(123)
         mapper = self._makeOne(get_root)
         mapper.connect('foo', 'archives/:action/:article', foo='foo')
         environ = self._getEnviron(PATH_INFO='/archives/action1/article1')
         result = mapper(environ)
-        from repoze.bfg.interfaces import IRoutesContext
-        self.failUnless(IRoutesContext.providedBy(result))
-        self.assertEqual(result.foo, 'foo')
-        self.assertEqual(result.action, 'action1')
-        self.assertEqual(result.article, 'article1')
+        self.assertEqual(result, 123)
         routing_args = environ['wsgiorg.routing_args'][1]
         self.assertEqual(routing_args['foo'], 'foo')
         self.assertEqual(routing_args['action'], 'action1')
         self.assertEqual(routing_args['article'], 'article1')
-        self.assertEqual(environ['bfg.route'].name, 'foo')
+        self.assertEqual(environ['bfg.routes.matchdict'], routing_args)
+        self.assertEqual(environ['bfg.routes.route'].name, 'foo')
 
     def test_unnamed_root_route_matches(self):
-        mapper = self._makeOne(None)
+        root_factory = make_get_root(123)
+        mapper = self._makeOne(root_factory)
         mapper.connect('')
         environ = self._getEnviron(PATH_INFO='/')
         result = mapper(environ)
-        from repoze.bfg.interfaces import IRoutesContext
-        self.failUnless(IRoutesContext.providedBy(result))
-        self.assertEqual(environ['bfg.route'].name, None)
+        self.assertEqual(result, 123)
+        self.assertEqual(environ['bfg.routes.route'].name, None)
+        self.assertEqual(environ['bfg.routes.matchdict'], {})
+        self.assertEqual(environ['wsgiorg.routing_args'], ((), {}))
 
     def test_named_root_route_matches(self):
-        mapper = self._makeOne(None)
+        root_factory = make_get_root(123)
+        mapper = self._makeOne(root_factory)
         mapper.connect('root', '')
         environ = self._getEnviron(PATH_INFO='/')
         result = mapper(environ)
-        from repoze.bfg.interfaces import IRoutesContext
-        self.failUnless(IRoutesContext.providedBy(result))
-        self.assertEqual(environ['bfg.route'].name, 'root')
+        self.assertEqual(result, 123)
+        self.assertEqual(environ['bfg.routes.route'].name, 'root')
+        self.assertEqual(environ['bfg.routes.matchdict'], {})
+        self.assertEqual(environ['wsgiorg.routing_args'], ((), {}))
 
     def test_unicode_in_route_default(self):
-        marker = ()
-        get_root = make_get_root(marker)
-        mapper = self._makeOne(get_root)
-        class DummyRoute2:
+        root_factory = make_get_root(123)
+        mapper = self._makeOne(root_factory)
+        class DummyRoute:
             routepath = ':id'
             _factory = None
-            _provides = ()
         la = unicode('\xc3\xb1a', 'utf-8')
-        mapper.routematch = lambda *arg: ({la:'id'}, DummyRoute2)
+        mapper.routematch = lambda *arg: ({la:'id'}, DummyRoute)
         mapper.connect('whatever', ':la')
         environ = self._getEnviron(PATH_INFO='/foo')
         result = mapper(environ)
-        from repoze.bfg.interfaces import IRoutesContext
-        self.failUnless(IRoutesContext.providedBy(result))
-        self.assertEqual(getattr(result, la.encode('utf-8')), 'id')
+        self.assertEqual(result, 123)
+        self.assertEqual(environ['bfg.routes.route'], DummyRoute)
+        self.assertEqual(environ['bfg.routes.matchdict'], {u'\xf1a': 'id'})
         routing_args = environ['wsgiorg.routing_args'][1]
-        self.assertEqual(routing_args[la.encode('utf-8')], 'id')
+        self.assertEqual(routing_args[la], 'id')
 
-    def test_no_fallback_get_root(self):
-        from repoze.bfg.urldispatch import RoutesContextNotFound
-        marker = ()
-        mapper = self._makeOne(None)
+    def test_fallback_to_default_root_factory(self):
+        root_factory = make_get_root(123)
+        mapper = self._makeOne(root_factory)
         mapper.connect('wont', 'wont/:be/:found')
         environ = self._getEnviron(PATH_INFO='/archives/action1/article1')
         result = mapper(environ)
-        self.failUnless(isinstance(result, RoutesContextNotFound))
-
-    def test_custom_factory(self):
-        marker = ()
-        get_root = make_get_root(marker)
-        mapper = self._makeOne(get_root)
-        from zope.interface import implements, Interface
-        class IDummy(Interface):
-            pass
-        class Dummy(object):
-            implements(IDummy)
-            def __init__(self, **kw):
-                self.__dict__.update(kw)
-        mapper.connect('article', 'archives/:action/:article',
-                       _factory=Dummy)
-        environ = self._getEnviron(PATH_INFO='/archives/action1/article1')
-        result = mapper(environ)
-        self.assertEqual(result.action, 'action1')
-        self.assertEqual(result.article, 'article1')
-        from repoze.bfg.interfaces import IRoutesContext
-        self.failUnless(IRoutesContext.providedBy(result))
-        self.failUnless(isinstance(result, Dummy))
-        self.failUnless(IDummy.providedBy(result))
-        self.failIf(hasattr(result, '_factory'))
-
-    def test_decorate_context_false(self):
-        from repoze.bfg.interfaces import IRoutesContext
-        class Dummy:
-            def __init__(self, **kw):
-                pass
-        mapper = self._makeOne(None)
-        mapper.connect('root', '')
-        environ = self._getEnviron(PATH_INFO='/')
-        mapper.decorate_context = False
-        mapper.default_context_factory = Dummy
-        result = mapper(environ)
-        self.failIf(IRoutesContext.providedBy(result))
-
-    def test_decorate_context_true(self):
-        from repoze.bfg.interfaces import IRoutesContext
-        class Dummy:
-            def __init__(self, **kw):
-                pass
-        mapper = self._makeOne(None)
-        mapper.connect('root', '')
-        environ = self._getEnviron(PATH_INFO='/')
-        mapper.decorate_context = True
-        mapper.default_context_factory = Dummy
-        result = mapper(environ)
-        self.failUnless(IRoutesContext.providedBy(result))
+        self.assertEqual(result, 123)
 
     def test_has_routes(self):
         mapper = self._makeOne(None)
@@ -163,163 +102,23 @@ class RoutesRootFactoryTests(unittest.TestCase):
         self.assertEqual(mapper.has_routes(), True)
 
     def test_url_for(self):
-        marker = ()
-        get_root = make_get_root(marker)
-        mapper = self._makeOne(get_root)
+        root_factory = make_get_root(None)
+        mapper = self._makeOne(root_factory)
         mapper.connect('whatever', 'archives/:action/:article')
         environ = self._getEnviron(PATH_INFO='/archives/action1/article1')
-        route = DummyRoute('yo')
-        environ['bfg.route'] = route
         result = mapper(environ)
         from routes import url_for
         result = url_for(action='action2', article='article2')
         self.assertEqual(result, '/archives/action2/article2')
 
-class TestRoutesContextNotFound(unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.urldispatch import RoutesContextNotFound
-        return RoutesContextNotFound
-
-    def _makeOne(self, msg):
-        return self._getTargetClass()(msg)
-
-    def test_it(self):
-        inst = self._makeOne('hi')
-        self.assertEqual(inst.msg, 'hi')
-
 def make_get_root(result):
     def dummy_get_root(environ):
         return result
     return dummy_get_root
 
-class RoutesModelTraverserTests(unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.urldispatch import RoutesModelTraverser
-        return RoutesModelTraverser
-
-    def _makeOne(self, model):
-        klass = self._getTargetClass()
-        return klass(model)
-
-    def test_class_conforms_to_ITraverser(self):
-        from zope.interface.verify import verifyClass
-        from repoze.bfg.interfaces import ITraverser
-        verifyClass(ITraverser, self._getTargetClass())
-
-    def test_instance_conforms_to_ITraverser(self):
-        from zope.interface.verify import verifyObject
-        from repoze.bfg.interfaces import ITraverser
-        verifyObject(ITraverser, self._makeOne(None))
-
-    def test_it_nothingfancy(self):
-        model = DummyContext()
-        traverser = self._makeOne(model)
-        routing_args = ((), {})
-        route = DummyRoute('yo')
-        environ = {'wsgiorg.routing_args': routing_args, 'bfg.route': route}
-        result = traverser(environ)
-        self.assertEqual(result['context'], model)
-        self.assertEqual(result['view_name'], 'yo')
-        self.assertEqual(result['subpath'], [])
-        self.assertEqual(result['traversed'], None)
-        self.assertEqual(result['virtual_root'], model)
-        self.assertEqual(result['virtual_root_path'], None)
-
-    def test_call_with_subpath(self):
-        model = DummyContext()
-        traverser = self._makeOne(model)
-        routing_args = ((), {'subpath':'/a/b/c'})
-        route = DummyRoute('yo')
-        environ = {'wsgiorg.routing_args':routing_args, 'bfg.route': route}
-        result = traverser(environ)
-        self.assertEqual(result['context'], model)
-        self.assertEqual(result['view_name'], 'yo')
-        self.assertEqual(result['subpath'], ['a', 'b','c'])
-        self.assertEqual(result['traversed'], None)
-        self.assertEqual(result['virtual_root'], model)
-        self.assertEqual(result['virtual_root_path'], None)
-
-    def test_with_path_info(self):
-        model = DummyContext()
-        traverser = self._makeOne(model)
-        routing_args = ((), {'path_info':'foo/bar'})
-        route = DummyRoute('yo')
-        environ = {'wsgiorg.routing_args': routing_args, 'bfg.route': route,
-                   'PATH_INFO':'/a/b/foo/bar', 'SCRIPT_NAME':''}
-        result = traverser(environ)
-        self.assertEqual(result['context'], model)
-        self.assertEqual(result['view_name'], 'yo')
-        self.assertEqual(result['subpath'], [])
-        self.assertEqual(result['traversed'], None)
-        self.assertEqual(result['virtual_root'], model)
-        self.assertEqual(result['virtual_root_path'], None)
-        self.assertEqual(environ['PATH_INFO'], '/foo/bar')
-        self.assertEqual(environ['SCRIPT_NAME'], '/a/b')
-
-    def test_with_path_info_PATH_INFO_w_extra_slash(self):
-        model = DummyContext()
-        traverser = self._makeOne(model)
-        routing_args = ((), {'path_info':'foo/bar'})
-        route = DummyRoute('yo')
-        environ = {'wsgiorg.routing_args': routing_args, 'bfg.route':route,
-                   'PATH_INFO':'/a/b//foo/bar', 'SCRIPT_NAME':''}
-        traverser(environ)
-        self.assertEqual(environ['PATH_INFO'], '/foo/bar')
-        self.assertEqual(environ['SCRIPT_NAME'], '/a/b')
-
-class RoutesContextURLTests(unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.urldispatch import RoutesContextURL
-        return RoutesContextURL
-
-    def _makeOne(self, context, request):
-        return self._getTargetClass()(context, request)
-
-    def test_class_conforms_to_IContextURL(self):
-        from zope.interface.verify import verifyClass
-        from repoze.bfg.interfaces import IContextURL
-        verifyClass(IContextURL, self._getTargetClass())
-
-    def test_instance_conforms_to_IContextURL(self):
-        from zope.interface.verify import verifyObject
-        from repoze.bfg.interfaces import IContextURL
-        verifyObject(IContextURL, self._makeOne(None, None))
-
-    def test_get_virtual_root(self):
-        context_url = self._makeOne(1,2)
-        self.assertEqual(context_url.virtual_root(), 1)
-
-    def test_call(self):
-        from routes import Mapper
-        mapper = Mapper(controller_scan=None, directory=None,
-                        explicit=True, always_scan=False)
-        args = {'a':'1', 'b':'2', 'c':'3'}
-        mapper.connect(':a/:b/:c')
-        mapper.create_regs([])
-        environ = {'SERVER_NAME':'example.com', 'wsgi.url_scheme':'http',
-                   'SERVER_PORT':'80', 'wsgiorg.routing_args':((), args)}
-        mapper.environ = environ
-        from routes import request_config
-        config = request_config()
-        config.environ = environ
-        config.mapper = mapper
-        config.mapper_dict = args
-        config.host = 'www.example.com'
-        config.protocol = 'https'
-        config.redirect = None
-        request = DummyRequest()
-        request.environ = environ
-        context_url = self._makeOne(None, request)
-        result = context_url()
-        self.assertEqual(result, '/1/2/3')
-
 class DummyContext(object):
     """ """
         
 class DummyRequest(object):
     """ """
     
-class DummyRoute(object):
-    def __init__(self, name):
-        self.name = name
-        
diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index e35944add..2fad91150 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -184,111 +184,54 @@ class TestViewDirective(unittest.TestCase):
         regadapt_discriminator = ('view', IFoo, '', IDummy, IView)
         self.assertEqual(regadapt['args'][2], (IFoo, IDummy))
 
-    def test_adapted_class(self):
-        from zope.interface import Interface
-        import zope.component
-
-        class IFoo(Interface):
+    def test_with_route_name(self):
+        class IFoo:
             pass
-        class IBar(Interface):
+        class IDummyRequest:
             pass
-
-        class AView(object):
-            zope.component.adapts(IFoo, IBar)
-
-        aview = AView()
-
         context = DummyContext()
-        self._callFUT(context, view=aview)
-
+        context.request_factories = {'foo':{None:{'interface':IDummyRequest}}}
+        view = lambda *arg: None
+        self._callFUT(context, 'repoze.view', IFoo, view=view, route_name='foo')
         actions = context.actions
         from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import IViewPermission
+        from repoze.bfg.security import ViewPermissionFactory
         from repoze.bfg.zcml import handler
 
-        self.assertEqual(len(actions), 1)
-
-        regadapt = actions[0]
-        regadapt_discriminator = ('view', IFoo, '', IBar, IView)
+        self.assertEqual(len(actions), 2)
 
+        permission = actions[0]
+        permission_discriminator = ('permission', IFoo, '', IDummyRequest,
+                                    IViewPermission)
+        self.assertEqual(permission['discriminator'], permission_discriminator)
+        self.assertEqual(permission['callable'], handler)
+        self.assertEqual(permission['args'][0], 'registerAdapter')
+        self.failUnless(isinstance(permission['args'][1],ViewPermissionFactory))
+        self.assertEqual(permission['args'][1].permission_name, 'repoze.view')
+        self.assertEqual(permission['args'][2], (IFoo, IDummyRequest))
+        self.assertEqual(permission['args'][3], IViewPermission)
+        self.assertEqual(permission['args'][4], '')
+        self.assertEqual(permission['args'][5], None)
+        
+        regadapt = actions[1]
+        regadapt_discriminator = ('view', IFoo, '', IDummyRequest, IView)
         self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
         self.assertEqual(regadapt['callable'], handler)
         self.assertEqual(regadapt['args'][0], 'registerAdapter')
-        self.assertEqual(regadapt['args'][1], aview)
-        self.assertEqual(regadapt['args'][2], (IFoo, IBar))
+        self.assertEqual(regadapt['args'][1], view)
+        self.assertEqual(regadapt['args'][2], (IFoo, IDummyRequest))
         self.assertEqual(regadapt['args'][3], IView)
         self.assertEqual(regadapt['args'][4], '')
         self.assertEqual(regadapt['args'][5], None)
 
-    def test_adapted_function(self):
-        from zope.interface import Interface
-        import zope.component
-
-        class IFoo(Interface):
-            pass
-        class IBar(Interface):
-            pass
-
-        @zope.component.adapter(IFoo, IBar)
-        def aview(context, request):
-            pass
-        aview(None, None) # dead chicken for test coverage
-
+    def test_with_route_name_bad_order(self):
         context = DummyContext()
-        self._callFUT(context, view=aview)
-
-        actions = context.actions
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.zcml import handler
-
-        self.assertEqual(len(actions), 1)
-
-        regadapt = actions[0]
-        regadapt_discriminator = ('view', IFoo, '', IBar, IView)
-
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerAdapter')
-        self.assertEqual(regadapt['args'][1], aview)
-        self.assertEqual(regadapt['args'][2], (IFoo, IBar))
-        self.assertEqual(regadapt['args'][3], IView)
-        self.assertEqual(regadapt['args'][4], '')
-        self.assertEqual(regadapt['args'][5], None)
-
-    def test_adapted_nonsense(self):
-        from repoze.bfg.interfaces import IRequest
-        from zope.interface import Interface
-        import zope.component
-
-        class IFoo(Interface):
-            pass
-        class IBar(Interface):
-            pass
-
-        @zope.component.adapter(IFoo) # too few arguments
-        def aview(context, request):
-            pass
-        aview(None, None) # dead chicken for test coverage
-
-        context = DummyContext()
-        self._callFUT(context, view=aview)
-
-        actions = context.actions
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.zcml import handler
-
-        self.assertEqual(len(actions), 1)
-
-        regadapt = actions[0]
-        regadapt_discriminator = ('view', None, '', IRequest, IView)
-
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerAdapter')
-        self.assertEqual(regadapt['args'][1], aview)
-        self.assertEqual(regadapt['args'][2], (None, IRequest))
-        self.assertEqual(regadapt['args'][3], IView)
-        self.assertEqual(regadapt['args'][4], '')
-        self.assertEqual(regadapt['args'][5], None)
+        context.request_factories = {}
+        view = lambda *arg: None
+        from zope.configuration.exceptions import ConfigurationError
+        self.assertRaises(ConfigurationError, self._callFUT, context,
+                          'repoze.view', None, view, '', None, 'foo')
 
 class TestRouteRequirementFunction(unittest.TestCase):
     def _callFUT(self, context, attr, expr):
@@ -372,7 +315,11 @@ class TestConnectRouteFunction(unittest.TestCase):
         self.assertEqual(D['_collection_name'], 'c')
         self.assertEqual(D['_parent_resource'], pr)
         self.assertEqual(D['conditions'], c)
-        self.assertEqual(D['_factory'], foo)
+        route = mapper.matchlist[-1]
+        self.assertEqual(route._factory, foo)
+        self.assertEqual(route.request_factories,
+                         directive.context.request_factories['thename'])
+        
 
     def test_condition_subdomain_true(self):
         mapper = self._registerRoutesMapper()
@@ -469,49 +416,45 @@ class TestRoute(unittest.TestCase):
         from repoze.bfg.zcml import Route
         return Route
 
-    def _makeOne(self, context, path, name, view, **kw):
-        return self._getTargetClass()(context, path, name, view, **kw)
+    def _makeOne(self, context, path, name, **kw):
+        return self._getTargetClass()(context, path, name, **kw)
 
     def test_defaults(self):
         context = DummyContext()
-        view = Dummy()
-        route = self._makeOne(context, 'path', 'name', view)
+        route = self._makeOne(context, 'path', 'name')
         self.assertEqual(route.path, 'path')
         self.assertEqual(route.name, 'name')
-        self.assertEqual(route.view, view)
         self.assertEqual(route.requirements, {})
 
     def test_parent_collection_name_missing(self):
         context = DummyContext()
-        view = Dummy()
         from zope.configuration.exceptions import ConfigurationError
         self.assertRaises(ConfigurationError, self._makeOne, context,
-                          'path', 'name', view,
-                          parent_member_name='a')
+                          'path', 'name', parent_member_name='a')
         
     def test_parent_collection_name_present(self):
         context = DummyContext()
-        view = Dummy()
-        route = self._makeOne(context, 'path', 'name', view,
+        route = self._makeOne(context, 'path', 'name',
                               parent_member_name='a',
                               parent_collection_name='p')
         self.assertEqual(route.parent_member_name, 'a')
         self.assertEqual(route.parent_collection_name, 'p')
 
-    def test_after(self):
+    def test_after_with_view(self):
         from repoze.bfg.zcml import handler
         from repoze.bfg.zcml import connect_route
-        from repoze.bfg.interfaces import IRoutesContext
-        from repoze.bfg.interfaces import IRequest
         from repoze.bfg.interfaces import IView
         
         context = DummyContext()
         view = Dummy()
-        route = self._makeOne(context, 'path', 'name', view)
+        route = self._makeOne(context, 'path', 'name', view=view)
         route.after()
         actions = context.actions
         self.assertEqual(len(actions), 2)
 
+        factories = context.request_factories
+        request_iface = factories['name'][None]['interface']
+
         view_action = actions[0]
         view_callable = view_action['callable']
         view_discriminator = view_action['discriminator']
@@ -519,13 +462,13 @@ class TestRoute(unittest.TestCase):
         self.assertEqual(view_callable, handler)
         self.assertEqual(len(view_discriminator), 5)
         self.assertEqual(view_discriminator[0], 'view')
-        self.assertEqual(view_discriminator[1], IRoutesContext)
-        self.assertEqual(view_discriminator[2],'name')
-        self.assertEqual(view_discriminator[3], IRequest)
+        self.assertEqual(view_discriminator[1], None)
+        self.assertEqual(view_discriminator[2],'')
+        self.assertEqual(view_discriminator[3], request_iface)
         self.assertEqual(view_discriminator[4], IView)
         self.assertEqual(view_args, ('registerAdapter', view,
-                                     (IRoutesContext, IRequest), IView,
-                                     'name', None))
+                                     (None, request_iface), IView,
+                                     '', None))
         
         route_action = actions[1]
         route_callable = route_action['callable']
@@ -534,7 +477,32 @@ class TestRoute(unittest.TestCase):
         self.assertEqual(route_callable, connect_route)
         self.assertEqual(len(route_discriminator), 7)
         self.assertEqual(route_discriminator[0], 'route')
-        self.assertEqual(route_discriminator[1], 'path')
+        self.assertEqual(route_discriminator[1], 'name')
+        self.assertEqual(route_discriminator[2],'{}')
+        self.assertEqual(route_discriminator[3], None)
+        self.assertEqual(route_discriminator[4], None)
+        self.assertEqual(route_discriminator[5], None)
+        self.assertEqual(route_discriminator[6], None)
+        self.assertEqual(route_args, (route,))
+
+    def test_after_without_view(self):
+        from repoze.bfg.zcml import connect_route
+        
+        context = DummyContext()
+        view = Dummy()
+        route = self._makeOne(context, 'path', 'name')
+        route.after()
+        actions = context.actions
+        self.assertEqual(len(actions), 1)
+
+        route_action = actions[0]
+        route_callable = route_action['callable']
+        route_discriminator = route_action['discriminator']
+        route_args = route_action['args']
+        self.assertEqual(route_callable, connect_route)
+        self.assertEqual(len(route_discriminator), 7)
+        self.assertEqual(route_discriminator[0], 'route')
+        self.assertEqual(route_discriminator[1], 'name')
         self.assertEqual(route_discriminator[2],'{}')
         self.assertEqual(route_discriminator[3], None)
         self.assertEqual(route_discriminator[4], None)
@@ -611,6 +579,7 @@ class TestBFGViewFunctionGrokker(unittest.TestCase):
         obj.__for__ = Interface
         obj.__view_name__ = 'foo.html'
         obj.__request_type__ = IRequest
+        obj.__route_name__ = None
         context = DummyContext()
         result = grokker.grok('name', obj, context=context)
         self.assertEqual(result, True)
@@ -729,13 +698,20 @@ class DummyRouteDirective:
         if not 'requirements' in kw:
             kw['requirements'] = {}
         self.__dict__.update(kw)
+        self.context = DummyContext()
+        self.context.request_factories = {self.name:{}}
 
 class DummyMapper:
     def __init__(self):
         self.connections = []
+        self.matchlist = []
 
     def connect(self, *arg, **kw):
         self.connections.append((arg, kw))
+        self.matchlist.append(DummyRoute())
+
+class DummyRoute:
+    pass
 
 from zope.interface import Interface
 class IDummy(Interface):