Checkpoint: move most zcml route and view directive tests to test_configuration.

8 files changed, 1015 insertions, 2259 deletions

diff --git a/CHANGES.txt b/CHANGES.txt
index e4c4420e9..bb09e08b2 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -21,9 +21,30 @@ Internals
 Backwards Incompatibilites
 --------------------------
 
-The ``repoze.bfg.router.make_app`` callable no longer accepts the
-``authentication_policy`` nor the ``authorization_policy`` arguments.
-This feature was deprecated in version 1.0 and has been removed.
+- View registration no longer registers a
+  ``repoze.bfg.interfaces.IViewPermission`` adapter (it is no longer
+  checked by the framework; since 1.1, views have been responsible for
+  providing their own security).
+
+- The ``repoze.bfg.router.make_app`` callable no longer accepts the
+  ``authentication_policy`` nor the ``authorization_policy``
+  arguments.  This feature was deprecated in version 1.0 and has been
+  removed.
+
+- Obscure: the machinery which configured views with a
+  ``request_type`` *and* a ``route_name`` would ignore the request
+  interface implied by ``route_name`` registering a view only for the
+  interface implied by ``request_type``.  In the unlikely event that
+  you were trying to use these two features together, the symptom
+  would have been that views that named a ``request_type`` but which
+  were also associated with routes were not found when the route
+  matched.  Now if a view is configured with both a ``request_type``
+  and a ``route_name``, an error is raised.
+
+- The ``route`` ZCML directive now no longer accepts the
+  ``request_type`` or ``view_request_type`` attributes.  These
+  attributes didn't actually work in any useful way (see entry above
+  this one).
 
 1.1 (2009-11-15)
 ================
diff --git a/repoze/bfg/configuration.py b/repoze/bfg/configuration.py
index bd1df14fd..9c2765c7c 100644
--- a/repoze/bfg/configuration.py
+++ b/repoze/bfg/configuration.py
@@ -34,7 +34,6 @@ from repoze.bfg.interfaces import ISettings
 from repoze.bfg.interfaces import ISecuredView
 from repoze.bfg.interfaces import ITemplateRendererFactory
 from repoze.bfg.interfaces import IView
-from repoze.bfg.interfaces import IViewPermission
 
 from repoze.bfg import chameleon_zpt
 from repoze.bfg import chameleon_text
@@ -140,7 +139,7 @@ class Configurator(object):
             manager.pop()
             getSiteManager.reset()
 
-    def view(self, permission=None, for_=None, view=None, name="",
+    def view(self, view=None, name="", for_=None, permission=None, 
              request_type=None, route_name=None, request_method=None,
              request_param=None, containment=None, attr=None,
              renderer=None, wrapper=None, xhr=False, accept=None,
@@ -154,21 +153,22 @@ class Configurator(object):
                 raise ConfigurationError('"view" was not specified and '
                                          'no "renderer" specified')
 
-        if request_type in ('GET', 'HEAD', 'PUT', 'POST', 'DELETE'):
-            # b/w compat for 1.0
-            request_method = request_type
-            request_type = None
+        if request_type and route_name:
+            raise ConfigurationError(
+                'A view cannot be configured with both the request_type and '
+                'route_name parameters: these two features when used together '
+                'causes an internal conflict.')
 
         if request_type is None:
-            if route_name is None:
-                request_type = IRequest
-            else:
-                request_type = self.reg.queryUtility(IRouteRequest,
-                                                     name=route_name)
-                if request_type is None:
-                    request_type = route_request_iface(route_name)
-                    self.reg.registerUtility(request_type, IRouteRequest,
-                                             name=route_name)
+            request_type = IRequest
+
+        if route_name is not None:
+            request_type = self.reg.queryUtility(IRouteRequest,
+                                                 name=route_name)
+            if request_type is None:
+                request_type = route_request_iface(route_name)
+                self.reg.registerUtility(request_type, IRouteRequest,
+                                         name=route_name)
 
         score, predicates = _make_predicates(
             xhr=xhr, request_method=request_method, path_info=path_info,
@@ -186,20 +186,14 @@ class Configurator(object):
         if not IInterface.providedBy(r_request_type):
             r_request_type = implementedBy(r_request_type)
         old_view = self.reg.adapters.lookup((r_for_, r_request_type),
-                                            IView,name=name)
+                                            IView, name=name)
         if old_view is None:
             if hasattr(derived_view, '__call_permissive__'):
-                self.reg.registerAdapter(derived_view, (for_, request_type),
-                                         ISecuredView, name, info=_info)
-                if hasattr(derived_view, '__permitted__'):
-                    # bw compat
-                    self.reg.registerAdapter(
-                        derived_view.__permitted__,
-                        (for_, request_type), IViewPermission,
-                        name, info=_info)
+                view_iface = ISecuredView
             else:
-                self.reg.registerAdapter(derived_view, (for_, request_type),
-                                         IView, name, info=_info)
+                view_iface = IView
+            self.reg.registerAdapter(derived_view, (for_, request_type),
+                                     view_iface, name, info=_info)
         else:
             # XXX we could try to be more efficient here and register
             # a non-secured view for a multiview if none of the
@@ -218,12 +212,27 @@ class Configurator(object):
                                              name=name)
             self.reg.registerAdapter(multiview, (for_, request_type),
                                      IMultiView, name, info=_info)
-            # b/w compat
-            self.reg.registerAdapter(multiview.__permitted__,
-                                     (for_, request_type), IViewPermission,
-                                     name, info=_info)
 
-    def map_view(self, view, attr=None, renderer_name=None):
+    def renderer_from_name(self, path):
+        name = os.path.splitext(path)[1]
+        if not name:
+            name = path
+        factory = self.reg.queryUtility(IRendererFactory, name=name)
+        if factory is None:
+            raise ValueError('No renderer for renderer name %r' % name)
+        return factory(path)
+
+    def derive_view(self, original_view, permission=None, predicates=(),
+                    attr=None, renderer_name=None, wrapper_viewname=None,
+                    viewname=None):
+        mapped_view = self._map_view(original_view, attr, renderer_name)
+        owrapped_view = self._owrap_view(mapped_view, viewname,wrapper_viewname)
+        secured_view = self._secure_view(owrapped_view, permission)
+        debug_view = self._authdebug_view(secured_view, permission)
+        derived_view = self._predicate_wrap(debug_view, predicates)
+        return derived_view
+
+    def _map_view(self, view, attr=None, renderer_name=None):
         wrapped_view = view
 
         renderer = None
@@ -317,26 +326,7 @@ class Configurator(object):
         decorate_view(wrapped_view, view)
         return wrapped_view
 
-    def renderer_from_name(self, path):
-        name = os.path.splitext(path)[1]
-        if not name:
-            name = path
-        factory = self.reg.queryUtility(IRendererFactory, name=name)
-        if factory is None:
-            raise ValueError('No renderer for renderer name %r' % name)
-        return factory(path)
-
-    def derive_view(self, original_view, permission=None, predicates=(),
-                    attr=None, renderer_name=None, wrapper_viewname=None,
-                    viewname=None):
-        mapped_view = self.map_view(original_view, attr, renderer_name)
-        owrapped_view = self.owrap_view(mapped_view, viewname, wrapper_viewname)
-        secured_view = self.secure_view(owrapped_view, permission)
-        debug_view = self.authdebug_view(secured_view, permission)
-        derived_view = self.predicate_wrap(debug_view, predicates)
-        return derived_view
-
-    def owrap_view(self, view, viewname, wrapper_viewname):
+    def _owrap_view(self, view, viewname, wrapper_viewname):
         if not wrapper_viewname:
             return view
         def _owrapped_view(context, request):
@@ -354,7 +344,7 @@ class Configurator(object):
         decorate_view(_owrapped_view, view)
         return _owrapped_view
 
-    def predicate_wrap(self, view, predicates):
+    def _predicate_wrap(self, view, predicates):
         if not predicates:
             return view
         def _wrapped(context, request):
@@ -368,7 +358,7 @@ class Configurator(object):
         decorate_view(_wrapped, view)
         return _wrapped
 
-    def secure_view(self, view, permission):
+    def _secure_view(self, view, permission):
         wrapped_view = view
         authn_policy = self.reg.queryUtility(IAuthenticationPolicy)
         authz_policy = self.reg.queryUtility(IAuthorizationPolicy)
@@ -390,7 +380,7 @@ class Configurator(object):
 
         return wrapped_view
 
-    def authdebug_view(self, view, permission):
+    def _authdebug_view(self, view, permission):
         wrapped_view = view
         authn_policy = self.reg.queryUtility(IAuthenticationPolicy)
         authz_policy = self.reg.queryUtility(IAuthorizationPolicy)
@@ -428,11 +418,11 @@ class Configurator(object):
         return wrapped_view
 
     def route(self, name, path, view=None, view_for=None,
-              permission=None, factory=None, request_type=None, for_=None,
+              permission=None, factory=None, for_=None,
               header=None, xhr=False, accept=None, path_info=None,
               request_method=None, request_param=None, 
-              view_permission=None, view_request_type=None, 
-              view_request_method=None, view_request_param=None,
+              view_permission=None, view_request_method=None,
+              view_request_param=None,
               view_containment=None, view_attr=None,
               renderer=None, view_renderer=None, view_header=None, 
               view_accept=None, view_xhr=False,
@@ -448,11 +438,6 @@ class Configurator(object):
                                          header=header,
                                          accept=accept)
 
-        if request_type in ('GET', 'HEAD', 'PUT', 'POST', 'DELETE'):
-            # b/w compat for 1.0
-            view_request_method = request_type
-            request_type = None
-
         request_iface = self.reg.queryUtility(IRouteRequest, name=name)
         if request_iface is None:
             request_iface = route_request_iface(name)
@@ -460,7 +445,6 @@ class Configurator(object):
 
         if view:
             view_for = view_for or for_
-            view_request_type = view_request_type or request_type
             view_permission = view_permission or permission
             view_renderer = view_renderer or renderer
             self.view(
@@ -468,7 +452,6 @@ class Configurator(object):
                 for_=view_for,
                 view=view,
                 name='',
-                request_type=view_request_type,
                 route_name=name, 
                 request_method=view_request_method,
                 request_param=view_request_param,
@@ -479,7 +462,7 @@ class Configurator(object):
                 accept=view_accept,
                 xhr=view_xhr,
                 path_info=view_path_info,
-                info=_info,
+                _info=_info,
                 )
 
         mapper = self.reg.queryUtility(IRoutesMapper)
diff --git a/repoze/bfg/request.py b/repoze/bfg/request.py
index 080ececc9..07151b512 100644
--- a/repoze/bfg/request.py
+++ b/repoze/bfg/request.py
@@ -1,6 +1,7 @@
 from zope.deprecation import deprecated
 from zope.interface import implements
 from zope.interface.interface import InterfaceClass
+from zope.interface.interface import Interface
 
 from webob import Request as WebobRequest
 
diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py
index 5449e0933..1916fe11d 100644
--- a/repoze/bfg/tests/test_configuration.py
+++ b/repoze/bfg/tests/test_configuration.py
@@ -17,10 +17,779 @@ class ConfiguratorTests(unittest.TestCase):
         class Renderer:
             implements(ITemplateRenderer)
             def __init__(self, path):
-                pass
+                self.__class__.path = path
             def __call__(self, *arg):
                 return 'Hello!'
         config.reg.registerUtility(Renderer, IRendererFactory, name=name)
+        return Renderer
+
+    def _getViewCallable(self, config, ctx_iface=None, request_iface=None,
+                         name=''):
+        from zope.interface import Interface
+        from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.interfaces import IView
+        if ctx_iface is None:
+            ctx_iface = Interface
+        if request_iface is None:
+            request_iface = IRequest
+        return config.reg.adapters.lookup(
+            (ctx_iface, request_iface), IView, name=name,
+            default=None)
+
+    def _callDefaultConfiguration(self, *arg, **kw):
+        inst = self._makeOne()
+        inst.default_configuration(*arg, **kw)
+        return inst.reg
+
+    def _getRouteRequestIface(self, config, name):
+        from repoze.bfg.interfaces import IRouteRequest
+        iface = config.reg.getUtility(IRouteRequest, name)
+        return iface
+
+    def _assertNotFound(self, wrapper, *arg):
+        from repoze.bfg.exceptions import NotFound
+        self.assertRaises(NotFound, wrapper, *arg)
+
+    def test_view_view_callable_None_no_renderer(self):
+        from zope.configuration.exceptions import ConfigurationError
+        config = self._makeOne()
+        self.assertRaises(ConfigurationError, config.view)
+
+    def test_view_with_request_type_and_route_name(self):
+        from zope.configuration.exceptions import ConfigurationError
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        self.assertRaises(ConfigurationError, config.view, view, '', None,
+                          None, True, True)
+
+    def test_view_view_callable_None_with_renderer(self):
+        config = self._makeOne()
+        self._registerRenderer(config, name='dummy')
+        config.view(renderer='dummy')
+        view = self._getViewCallable(config)
+        self.failUnless('Hello!' in view(None, None).body)
+
+    def test_wrapped_view_is_decorated(self):
+        def view(request): # request-only wrapper
+            """ """
+        config = self._makeOne()
+        config.view(view=view)
+        wrapper = self._getViewCallable(config)
+        self.assertEqual(wrapper.__module__, view.__module__)
+        self.assertEqual(wrapper.__name__, view.__name__)
+        self.assertEqual(wrapper.__doc__, view.__doc__)
+
+    def test_view_with_function_callable(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view)
+        wrapper = self._getViewCallable(config)
+        result = wrapper(None, None)
+        self.assertEqual(result, 'OK')
+
+    def test_view_with_function_callable_requestonly(self):
+        def view(request):
+            return 'OK'
+        config = self._makeOne()
+        config.view(view=view)
+        wrapper = self._getViewCallable(config)
+        result = wrapper(None, None)
+        self.assertEqual(result, 'OK')
+
+    def test_view_as_instance(self):
+        class AView:
+            def __call__(self, context, request):
+                """ """
+                return 'OK'
+        view = AView()
+        config = self._makeOne()
+        config.view(view=view)
+        wrapper = self._getViewCallable(config)
+        result = wrapper(None, None)
+        self.assertEqual(result, 'OK')
+
+    def test_view_as_instance_requestonly(self):
+        class AView:
+            def __call__(self, request):
+                """ """
+                return 'OK'
+        view = AView()
+        config = self._makeOne()
+        config.view(view=view)
+        wrapper = self._getViewCallable(config)
+        result = wrapper(None, None)
+        self.assertEqual(result, 'OK')
+
+    def test_view_as_oldstyle_class(self):
+        class view:
+            def __init__(self, context, request):
+                self.context = context
+                self.request = request
+
+            def __call__(self):
+                return 'OK'
+        config = self._makeOne()
+        config.view(view=view)
+        wrapper = self._getViewCallable(config)
+        result = wrapper(None, None)
+        self.assertEqual(result, 'OK')
+
+    def test_view_as_oldstyle_class_requestonly(self):
+        class view:
+            def __init__(self, request):
+                self.request = request
+
+            def __call__(self):
+                return 'OK'
+        config = self._makeOne()
+        config.view(view=view)
+        wrapper = self._getViewCallable(config)
+        result = wrapper(None, None)
+        self.assertEqual(result, 'OK')
+
+    def test_view_for_as_class(self):
+        from zope.interface import implementedBy
+        view = lambda *arg: 'OK'
+        class Foo:
+            pass
+        config = self._makeOne()
+        config.view(for_=Foo, view=view)
+        foo = implementedBy(Foo)
+        wrapper = self._getViewCallable(config, foo)
+        self.assertEqual(wrapper, view)
+
+    def test_view_for_as_iface(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(for_=IDummy, view=view)
+        wrapper = self._getViewCallable(config, IDummy)
+        self.assertEqual(wrapper, view)
+
+    def test_view_register_secured_view(self):
+        from zope.component import Interface
+        from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.interfaces import ISecuredView
+        view = lambda *arg: 'OK'
+        view.__call_permissive__ = view
+        config = self._makeOne()
+        config.view(view=view)
+        wrapper = config.reg.adapters.lookup(
+            (Interface, IRequest), ISecuredView, name='', default=None)
+        self.assertEqual(wrapper, view)
+
+    def test_view_multiview_replaces_existing_view(self):
+        from zope.component import Interface
+        from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import IMultiView
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.reg.registerAdapter(view, (Interface, IRequest), IView, name='')
+        config.view(view=view)
+        wrapper = self._getViewCallable(config)
+        self.failUnless(IMultiView.providedBy(wrapper))
+        self.assertEqual(wrapper(None, None), 'OK')
+
+    def test_view_multiview_replaces_multiview(self):
+        from zope.component import Interface
+        from zope.interface import implements
+        from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.interfaces import IMultiView
+        class DummyMultiView:
+            implements(IMultiView)
+            def __init__(self):
+                self.views = []
+                self.name = 'name'
+            def add(self, view, score):
+                self.views.append(view)
+            def __call__(self, context, request):
+                return 'OK1'
+            def __permitted__(self, context, request):
+                """ """
+        view = DummyMultiView()
+        config = self._makeOne()
+        config.reg.registerAdapter(view, (Interface, IRequest),
+                                   IMultiView, name='')
+        view2 = lambda *arg: 'OK2'
+        config.view(view=view2)
+        wrapper = self._getViewCallable(config)
+        self.failUnless(IMultiView.providedBy(wrapper))
+        self.assertEqual(wrapper.views, [view2])
+        self.assertEqual(wrapper(None, None), 'OK1')
+
+    def test_view_multiview_call_ordering(self):
+        from zope.interface import directlyProvides
+        def view1(context, request): return 'view1'
+        def view2(context, request): return 'view2'
+        def view3(context, request): return 'view3'
+        def view4(context, request): return 'view4'
+        def view5(context, request): return 'view5'
+        def view6(context, request): return 'view6'
+        def view7(context, request): return 'view7'
+        def view8(context, request): return 'view8'
+        config = self._makeOne()
+        config.view(view=view1)
+        config.view(view=view2, request_method='POST')
+        config.view(view=view3,request_param='param')
+        config.view(view=view4, containment=IDummy)
+        config.view(view=view5, request_method='POST', request_param='param')
+        config.view(view=view6, request_method='POST', containment=IDummy)
+        config.view(view=view7, request_param='param', containment=IDummy)
+        config.view(view=view8, request_method='POST', request_param='param',
+                    containment=IDummy)
+
+        wrapper = self._getViewCallable(config)
+
+        ctx = DummyContext()
+        request = DummyRequest()
+        request.method = 'GET'
+        request.params = {}
+        self.assertEqual(wrapper(ctx, request), 'view1')
+
+        ctx = DummyContext()
+        request = DummyRequest()
+        request.params = {}
+        request.method = 'POST'
+        self.assertEqual(wrapper(ctx, request), 'view2')
+
+        ctx = DummyContext()
+        request = DummyRequest()
+        request.params = {'param':'1'}
+        request.method = 'GET'
+        self.assertEqual(wrapper(ctx, request), 'view3')
+
+        ctx = DummyContext()
+        directlyProvides(ctx, IDummy)
+        request = DummyRequest()
+        request.method = 'GET'
+        request.params = {}
+        self.assertEqual(wrapper(ctx, request), 'view4')
+
+        ctx = DummyContext()
+        request = DummyRequest()
+        request.method = 'POST'
+        request.params = {'param':'1'}
+        self.assertEqual(wrapper(ctx, request), 'view5')
+
+        ctx = DummyContext()
+        directlyProvides(ctx, IDummy)
+        request = DummyRequest()
+        request.params = {}
+        request.method = 'POST'
+        self.assertEqual(wrapper(ctx, request), 'view6')
+
+        ctx = DummyContext()
+        directlyProvides(ctx, IDummy)
+        request = DummyRequest()
+        request.method = 'GET'
+        request.params = {'param':'1'}
+        self.assertEqual(wrapper(ctx, request), 'view7')
+
+        ctx = DummyContext()
+        directlyProvides(ctx, IDummy)
+        request = DummyRequest()
+        request.method = 'POST'
+        request.params = {'param':'1'}
+        self.assertEqual(wrapper(ctx, request), 'view8')
+
+    def test_view_with_relative_template_renderer(self):
+        class view(object):
+            def __init__(self, context, request):
+                self.request = request
+                self.context = context
+
+            def __call__(self):
+                return {'a':'1'}
+        config = self._makeOne()
+        renderer = self._registerRenderer(config)
+        fixture = 'fixtures/minimal.txt'
+        config.view(view=view, renderer=fixture)
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        result = wrapper(None, request)
+        self.assertEqual(result.body, 'Hello!')
+        self.assertEqual(renderer.path, 'fixtures/minimal.txt')
+
+    def test_view_with_relative_template_renderer_no_callable(self):
+        config = self._makeOne()
+        renderer = self._registerRenderer(config)
+        fixture = 'fixtures/minimal.txt'
+        config.view(view=None, renderer=fixture)
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        result = wrapper(None, request)
+        self.assertEqual(result.body, 'Hello!')
+        self.assertEqual(renderer.path, 'fixtures/minimal.txt')
+
+    def test_view_with_request_type_as_iface(self):
+        def view(context, request):
+            return 'OK'
+        config = self._makeOne()
+        config.view(request_type=IDummy, view=view)
+        wrapper = self._getViewCallable(config, None, IDummy)
+        result = wrapper(None, None)
+        self.assertEqual(result, 'OK')
+
+    def test_view_with_request_type_as_noniface(self):
+        from zope.interface import providedBy
+        def view(context, request):
+            return 'OK'
+        config = self._makeOne()
+        config.view(request_type=object, view=view)
+        request_iface = providedBy(object)
+        wrapper = self._getViewCallable(config, None, request_iface)
+        result = wrapper(None, None)
+        self.assertEqual(result, 'OK')
+
+    def test_view_with_route_name(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, route_name='foo')
+        request_type = self._getRouteRequestIface(config, 'foo')
+        wrapper = self._getViewCallable(config, None, request_type)
+        self.assertEqual(wrapper(None, None), 'OK')
+
+    def test_view_with_request_method_true(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, request_method='POST')
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.method = 'POST'
+        self.assertEqual(wrapper(None, request), 'OK')
+
+    def test_view_with_request_method_false(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, request_method='POST')
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.method = 'GET'
+        self._assertNotFound(wrapper, None, request)
+
+    def test_view_with_request_param_noval_true(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, request_param='abc')
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.params = {'abc':''}
+        self.assertEqual(wrapper(None, request), 'OK')
+
+    def test_view_with_request_param_noval_false(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, request_param='abc')
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.params = {}
+        self._assertNotFound(wrapper, None, request)
+
+    def test_view_with_request_param_val_true(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, request_param='abc=123')
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.params = {'abc':'123'}
+        self.assertEqual(wrapper(None, request), 'OK')
+
+    def test_view_with_request_param_val_false(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, request_param='abc=123')
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.params = {'abc':''}
+        self._assertNotFound(wrapper, None, request)
+
+    def test_view_with_xhr_true(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, xhr=True)
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.is_xhr = True
+        self.assertEqual(wrapper(None, request), 'OK')
+
+    def test_view_with_xhr_false(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, xhr=True)
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.is_xhr = False
+        self._assertNotFound(wrapper, None, request)
+
+    def test_view_with_header_badregex(self):
+        from zope.configuration.exceptions import ConfigurationError
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        self.assertRaises(ConfigurationError,
+                          config.view, view=view, header='Host:a\\')
+
+    def test_view_with_header_noval_match(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, header='Host')
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.headers = {'Host':'whatever'}
+        self.assertEqual(wrapper(None, request), 'OK')
+
+    def test_view_with_header_noval_nomatch(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, header='Host')
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.headers = {'NotHost':'whatever'}
+        self._assertNotFound(wrapper, None, request)
+
+    def test_view_with_header_val_match(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, header=r'Host:\d')
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.headers = {'Host':'1'}
+        self.assertEqual(wrapper(None, request), 'OK')
+
+    def test_view_with_header_val_nomatch(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, header=r'Host:\d')
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.headers = {'Host':'abc'}
+        self._assertNotFound(wrapper, None, request)
+
+    def test_view_with_accept_match(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, accept='text/xml')
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.accept = ['text/xml']
+        self.assertEqual(wrapper(None, request), 'OK')
+
+    def test_view_with_accept_nomatch(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, accept='text/xml')
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.accept = ['text/html']
+        self._assertNotFound(wrapper, None, request)
+
+    def test_view_with_containment_true(self):
+        from zope.interface import directlyProvides
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, containment=IDummy)
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        context = DummyContext()
+        directlyProvides(context, IDummy)
+        self.assertEqual(wrapper(context, None), 'OK')
+
+    def test_view_with_containment_false(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, containment=IDummy)
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        context = DummyContext()
+        self._assertNotFound(wrapper, context, None)
+
+    def test_view_with_path_info_badregex(self):
+        from zope.configuration.exceptions import ConfigurationError
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        self.assertRaises(ConfigurationError,
+                          config.view, view=view, path_info='\\')
+
+    def test_with_path_info_match(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, path_info='/foo')
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.path_info = '/foo'
+        self.assertEqual(wrapper(None, request), 'OK')
+
+    def test_with_path_info_nomatch(self):
+        view = lambda *arg: 'OK'
+        config = self._makeOne()
+        config.view(view=view, path_info='/foo')
+        wrapper = self._getViewCallable(config)
+        request = DummyRequest()
+        request.path_info = '/'
+        self._assertNotFound(wrapper, None, request)
+
+    def _assertRoute(self, config, name, path, num_predicates=0):
+        from repoze.bfg.interfaces import IRoutesMapper
+        mapper = config.reg.getUtility(IRoutesMapper)
+        routes = mapper.get_routes()
+        route = routes[0]
+        self.assertEqual(len(routes), 1)
+        self.assertEqual(route.name, name)
+        self.assertEqual(route.path, path)
+        self.assertEqual(len(routes[0].predicates), num_predicates)
+        return route
+
+    def test_route_defaults(self):
+        config = self._makeOne()
+        config.route('name', 'path')
+        self._assertRoute(config, 'name', 'path')
+
+    def test_route_with_xhr(self):
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', xhr=True)
+        request_type = self._getRouteRequestIface(config, 'name')
+        route = self._assertRoute(config, 'name', 'path', 1)
+        predicate = route.predicates[0]
+        request = DummyRequest()
+        request.is_xhr = True
+        self.assertEqual(predicate(None, request), True)
+        request = DummyRequest()
+        request.is_xhr = False
+        self.assertEqual(predicate(None, request), False)
+
+    def test_route_with_request_method(self):
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', request_method='GET')
+        request_type = self._getRouteRequestIface(config, 'name')
+        route = self._assertRoute(config, 'name', 'path', 1)
+        predicate = route.predicates[0]
+        request = DummyRequest()
+        request.method = 'GET'
+        self.assertEqual(predicate(None, request), True)
+        request = DummyRequest()
+        request.method = 'POST'
+        self.assertEqual(predicate(None, request), False)
+
+    def test_route_with_path_info(self):
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', path_info='/foo')
+        request_type = self._getRouteRequestIface(config, 'name')
+        route = self._assertRoute(config, 'name', 'path', 1)
+        predicate = route.predicates[0]
+        request = DummyRequest()
+        request.path_info = '/foo'
+        self.assertEqual(predicate(None, request), True)
+        request = DummyRequest()
+        request.path_info = '/'
+        self.assertEqual(predicate(None, request), False)
+
+    def test_route_with_request_param(self):
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', request_param='abc')
+        request_type = self._getRouteRequestIface(config, 'name')
+        route = self._assertRoute(config, 'name', 'path', 1)
+        predicate = route.predicates[0]
+        request = DummyRequest()
+        request.params = {'abc':'123'}
+        self.assertEqual(predicate(None, request), True)
+        request = DummyRequest()
+        request.params = {}
+        self.assertEqual(predicate(None, request), False)
+
+    def test_route_with_header(self):
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', header='Host')
+        request_type = self._getRouteRequestIface(config, 'name')
+        route = self._assertRoute(config, 'name', 'path', 1)
+        predicate = route.predicates[0]
+        request = DummyRequest()
+        request.headers = {'Host':'example.com'}
+        self.assertEqual(predicate(None, request), True)
+        request = DummyRequest()
+        request.headers = {}
+        self.assertEqual(predicate(None, request), False)
+
+    def test_route_with_accept(self):
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', accept='text/xml')
+        request_type = self._getRouteRequestIface(config, 'name')
+        route = self._assertRoute(config, 'name', 'path', 1)
+        predicate = route.predicates[0]
+        request = DummyRequest()
+        request.accept = ['text/xml']
+        self.assertEqual(predicate(None, request), True)
+        request = DummyRequest()
+        request.accept = ['text/html']
+        self.assertEqual(predicate(None, request), False)
+
+    def test_route_with_view(self):
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', view=view)
+        request_type = self._getRouteRequestIface(config, 'name')
+        wrapper = self._getViewCallable(config, None, request_type)
+        self.assertEqual(wrapper(None, None), 'OK')
+        self._assertRoute(config, 'name', 'path')
+
+    def test_route_with_view_for(self):
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', view=view, view_for=IDummy)
+        request_type = self._getRouteRequestIface(config, 'name')
+        wrapper = self._getViewCallable(config, IDummy, request_type)
+        self.assertEqual(wrapper(None, None), 'OK')
+        self._assertRoute(config, 'name', 'path')
+        wrapper = self._getViewCallable(config, IOther, request_type)
+        self.assertEqual(wrapper, None)
+
+    def test_route_with_view_for_alias(self):
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', view=view, for_=IDummy)
+        request_type = self._getRouteRequestIface(config, 'name')
+        wrapper = self._getViewCallable(config, IDummy, request_type)
+        self.assertEqual(wrapper(None, None), 'OK')
+        self._assertRoute(config, 'name', 'path')
+        wrapper = self._getViewCallable(config, IOther, request_type)
+        self.assertEqual(wrapper, None)
+
+    def test_route_with_view_request_method(self):
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', view=view, view_request_method='GET')
+        request_type = self._getRouteRequestIface(config, 'name')
+        wrapper = self._getViewCallable(config, None, request_type)
+        route = self._assertRoute(config, 'name', 'path')
+        request = DummyRequest()
+        request.method = 'GET'
+        self.assertEqual(wrapper(None, request), 'OK')
+        request = DummyRequest()
+        request.method = 'POST'
+        self._assertNotFound(wrapper, None, request)
+
+    def test_route_with_view_header(self):
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', view=view, view_header='Host')
+        request_type = self._getRouteRequestIface(config, 'name')
+        wrapper = self._getViewCallable(config, None, request_type)
+        route = self._assertRoute(config, 'name', 'path')
+        request = DummyRequest()
+        request.headers = {'Host':'abc'}
+        self.assertEqual(wrapper(None, request), 'OK')
+        request = DummyRequest()
+        request.headers = {}
+        self._assertNotFound(wrapper, None, request)
+
+    def test_route_with_view_xhr(self):
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', view=view, view_xhr=True)
+        request_type = self._getRouteRequestIface(config, 'name')
+        wrapper = self._getViewCallable(config, None, request_type)
+        route = self._assertRoute(config, 'name', 'path')
+        request = DummyRequest()
+        request.is_xhr = True
+        self.assertEqual(wrapper(None, request), 'OK')
+        request = DummyRequest()
+        request.is_xhr = False
+        self._assertNotFound(wrapper, None, request)
+
+    def test_route_with_view_path_info(self):
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', view=view, view_path_info='/foo')
+        request_type = self._getRouteRequestIface(config, 'name')
+        wrapper = self._getViewCallable(config, None, request_type)
+        route = self._assertRoute(config, 'name', 'path')
+        request = DummyRequest()
+        request.path_info = '/foo'
+        self.assertEqual(wrapper(None, request), 'OK')
+        request = DummyRequest()
+        request.path_info = '/'
+        self._assertNotFound(wrapper, None, request)
+
+    def test_route_with_view_accept(self):
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', view=view, view_accept='text/xml')
+        request_type = self._getRouteRequestIface(config, 'name')
+        wrapper = self._getViewCallable(config, None, request_type)
+        route = self._assertRoute(config, 'name', 'path')
+        request = DummyRequest()
+        request.accept = ['text/xml']
+        self.assertEqual(wrapper(None, request), 'OK')
+        request = DummyRequest()
+        request.accept = ['text/html']
+        self._assertNotFound(wrapper, None, request)
+
+    def test_route_with_view_containment(self):
+        from zope.interface import directlyProvides
+        config = self._makeOne()
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', view=view, view_containment=IDummy)
+        request_type = self._getRouteRequestIface(config, 'name')
+        wrapper = self._getViewCallable(config, None, request_type)
+        route = self._assertRoute(config, 'name', 'path')
+        context = DummyContext()
+        directlyProvides(context, IDummy)
+        self.assertEqual(wrapper(context, None), 'OK')
+        self._assertNotFound(wrapper, None, None)
+
+    def test_route_with_view_renderer(self):
+        config = self._makeOne()
+        self._registerRenderer(config)
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', view=view,
+                     view_renderer='fixtures/minimal.txt')
+        request_type = self._getRouteRequestIface(config, 'name')
+        wrapper = self._getViewCallable(config, None, request_type)
+        route = self._assertRoute(config, 'name', 'path')
+        self.assertEqual(wrapper(None, None).body, 'Hello!')
+
+    def test_route_with_view_renderer_alias(self):
+        config = self._makeOne()
+        self._registerRenderer(config)
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', view=view,
+                     renderer='fixtures/minimal.txt')
+        request_type = self._getRouteRequestIface(config, 'name')
+        wrapper = self._getViewCallable(config, None, request_type)
+        route = self._assertRoute(config, 'name', 'path')
+        self.assertEqual(wrapper(None, None).body, 'Hello!')
+
+    def test_route_with_view_permission(self):
+        from repoze.bfg.interfaces import IAuthenticationPolicy
+        from repoze.bfg.interfaces import IAuthorizationPolicy
+        config = self._makeOne()
+        policy = lambda *arg: None
+        config.reg.registerUtility(policy, IAuthenticationPolicy)
+        config.reg.registerUtility(policy, IAuthorizationPolicy)
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', view=view, view_permission='edit')
+        request_type = self._getRouteRequestIface(config, 'name')
+        wrapper = self._getViewCallable(config, None, request_type)
+        route = self._assertRoute(config, 'name', 'path')
+        self.failUnless(hasattr(wrapper, '__call_permissive__'))
+
+    def test_route_with_view_permission_alias(self):
+        from repoze.bfg.interfaces import IAuthenticationPolicy
+        from repoze.bfg.interfaces import IAuthorizationPolicy
+        config = self._makeOne()
+        policy = lambda *arg: None
+        config.reg.registerUtility(policy, IAuthenticationPolicy)
+        config.reg.registerUtility(policy, IAuthorizationPolicy)
+        view = lambda *arg: 'OK'
+        config.route('name', 'path', view=view, permission='edit')
+        request_type = self._getRouteRequestIface(config, 'name')
+        wrapper = self._getViewCallable(config, None, request_type)
+        route = self._assertRoute(config, 'name', 'path')
+        self.failUnless(hasattr(wrapper, '__call_permissive__'))
 
     def test__override_not_yet_registered(self):
         from repoze.bfg.interfaces import IPackageOverrides
@@ -47,83 +816,82 @@ class ConfiguratorTests(unittest.TestCase):
         self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')])
         self.assertEqual(overrides.package, package)
 
-    def test_map_view_as_function_context_and_request(self):
+    def test__map_view_as_function_context_and_request(self):
         def view(context, request):
             return 'OK'
         config = self._makeOne()
-        result = config.map_view(view)
+        result = config._map_view(view)
         self.failUnless(result is view)
         self.assertEqual(result(None, None), 'OK')
 
-    def test_map_view_as_function_with_attr(self):
+    def test__map_view_as_function_with_attr(self):
         def view(context, request):
             """ """
         config = self._makeOne()
-        result = config.map_view(view, attr='__name__')
+        result = config._map_view(view, attr='__name__')
         self.failIf(result is view)
         self.assertRaises(TypeError, result, None, None)
 
-    def test_map_view_as_function_with_attr_and_renderer(self):
+    def test__map_view_as_function_with_attr_and_renderer(self):
         config = self._makeOne()
         self._registerRenderer(config)
-        def view(context, request):
-            """ """
-        result = config.map_view(view, attr='__name__',
+        view = lambda *arg: 'OK'
+        result = config._map_view(view, attr='__name__',
                                  renderer_name='fixtures/minimal.txt')
         self.failIf(result is view)
         self.assertRaises(TypeError, result, None, None)
         
-    def test_map_view_as_function_requestonly(self):
+    def test__map_view_as_function_requestonly(self):
         config = self._makeOne()
         def view(request):
             return 'OK'
-        result = config.map_view(view)
+        result = config._map_view(view)
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
-    def test_map_view_as_function_requestonly_with_attr(self):
+    def test__map_view_as_function_requestonly_with_attr(self):
         config = self._makeOne()
         def view(request):
             """ """
-        result = config.map_view(view, attr='__name__')
+        result = config._map_view(view, attr='__name__')
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
         self.assertRaises(TypeError, result, None, None)
 
-    def test_map_view_as_newstyle_class_context_and_request(self):
+    def test__map_view_as_newstyle_class_context_and_request(self):
         config = self._makeOne()
         class view(object):
             def __init__(self, context, request):
                 pass
             def __call__(self):
                 return 'OK'
-        result = config.map_view(view)
+        result = config._map_view(view)
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
-    def test_map_view_as_newstyle_class_context_and_request_with_attr(self):
+    def test__map_view_as_newstyle_class_context_and_request_with_attr(self):
         config = self._makeOne()
         class view(object):
             def __init__(self, context, request):
                 pass
             def index(self):
                 return 'OK'
-        result = config.map_view(view, attr='index')
+        result = config._map_view(view, attr='index')
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
-    def test_map_view_as_newstyle_class_context_and_request_attr_and_renderer(
+    def test__map_view_as_newstyle_class_context_and_request_attr_and_renderer(
         self):
         config = self._makeOne()
         self._registerRenderer(config)
@@ -132,7 +900,7 @@ class ConfiguratorTests(unittest.TestCase):
                 pass
             def index(self):
                 return {'a':'1'}
-        result = config.map_view(
+        result = config._map_view(
             view, attr='index',
             renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
         self.failIf(result is view)
@@ -142,35 +910,35 @@ class ConfiguratorTests(unittest.TestCase):
         request = DummyRequest()
         self.assertEqual(result(None, request).body, 'Hello!')
         
-    def test_map_view_as_newstyle_class_requestonly(self):
+    def test__map_view_as_newstyle_class_requestonly(self):
         config = self._makeOne()
         class view(object):
             def __init__(self, request):
                 pass
             def __call__(self):
                 return 'OK'
-        result = config.map_view(view)
+        result = config._map_view(view)
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
-    def test_map_view_as_newstyle_class_requestonly_with_attr(self):
+    def test__map_view_as_newstyle_class_requestonly_with_attr(self):
         config = self._makeOne()
         class view(object):
             def __init__(self, request):
                 pass
             def index(self):
                 return 'OK'
-        result = config.map_view(view, attr='index')
+        result = config._map_view(view, attr='index')
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
-    def test_map_view_as_newstyle_class_requestonly_with_attr_and_renderer(
+    def test__map_view_as_newstyle_class_requestonly_with_attr_and_renderer(
         self):
         config = self._makeOne()
         self._registerRenderer(config)
@@ -179,7 +947,7 @@ class ConfiguratorTests(unittest.TestCase):
                 pass
             def index(self):
                 return {'a':'1'}
-        result = config.map_view(
+        result = config._map_view(
             view, attr='index',
             renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
         self.failIf(result is view)
@@ -189,35 +957,35 @@ class ConfiguratorTests(unittest.TestCase):
         request = DummyRequest()
         self.assertEqual(result(None, request).body, 'Hello!')
 
-    def test_map_view_as_oldstyle_class_context_and_request(self):
+    def test__map_view_as_oldstyle_class_context_and_request(self):
         config = self._makeOne()
         class view:
             def __init__(self, context, request):
                 pass
             def __call__(self):
                 return 'OK'
-        result = config.map_view(view)
+        result = config._map_view(view)
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
-    def test_map_view_as_oldstyle_class_context_and_request_with_attr(self):
+    def test__map_view_as_oldstyle_class_context_and_request_with_attr(self):
         config = self._makeOne()
         class view:
             def __init__(self, context, request):
                 pass
             def index(self):
                 return 'OK'
-        result = config.map_view(view, attr='index')
+        result = config._map_view(view, attr='index')
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
-    def test_map_view_as_oldstyle_class_context_and_request_attr_and_renderer(
+    def test__map_view_as_oldstyle_class_context_and_request_attr_and_renderer(
         self):
         config = self._makeOne()
         self._registerRenderer(config)
@@ -226,7 +994,7 @@ class ConfiguratorTests(unittest.TestCase):
                 pass
             def index(self):
                 return {'a':'1'}
-        result = config.map_view(
+        result = config._map_view(
             view, attr='index',
             renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
         self.failIf(result is view)
@@ -236,35 +1004,35 @@ class ConfiguratorTests(unittest.TestCase):
         request = DummyRequest()
         self.assertEqual(result(None, request).body, 'Hello!')
 
-    def test_map_view_as_oldstyle_class_requestonly(self):
+    def test__map_view_as_oldstyle_class_requestonly(self):
         config = self._makeOne()
         class view:
             def __init__(self, request):
                 pass
             def __call__(self):
                 return 'OK'
-        result = config.map_view(view)
+        result = config._map_view(view)
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
-    def test_map_view_as_oldstyle_class_requestonly_with_attr(self):
+    def test__map_view_as_oldstyle_class_requestonly_with_attr(self):
         config = self._makeOne()
         class view:
             def __init__(self, request):
                 pass
             def index(self):
                 return 'OK'
-        result = config.map_view(view, attr='index')
+        result = config._map_view(view, attr='index')
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
-    def test_map_view_as_oldstyle_class_requestonly_attr_and_renderer(self):
+    def test__map_view_as_oldstyle_class_requestonly_attr_and_renderer(self):
         config = self._makeOne()
         self._registerRenderer(config)
         class view:
@@ -272,7 +1040,7 @@ class ConfiguratorTests(unittest.TestCase):
                 pass
             def index(self):
                 return {'a':'1'}
-        result = config.map_view(
+        result = config._map_view(
             view, attr='index',
             renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
         self.failIf(result is view)
@@ -282,74 +1050,74 @@ class ConfiguratorTests(unittest.TestCase):
         request = DummyRequest()
         self.assertEqual(result(None, request).body, 'Hello!')
 
-    def test_map_view_as_instance_context_and_request(self):
+    def test__map_view_as_instance_context_and_request(self):
         config = self._makeOne()
         class View:
             def __call__(self, context, request):
                 return 'OK'
         view = View()
-        result = config.map_view(view)
+        result = config._map_view(view)
         self.failUnless(result is view)
         self.assertEqual(result(None, None), 'OK')
         
-    def test_map_view_as_instance_context_and_request_and_attr(self):
+    def test__map_view_as_instance_context_and_request_and_attr(self):
         config = self._makeOne()
         class View:
             def index(self, context, request):
                 return 'OK'
         view = View()
-        result = config.map_view(view, attr='index')
+        result = config._map_view(view, attr='index')
         self.failIf(result is view)
         self.assertEqual(result(None, None), 'OK')
 
-    def test_map_view_as_instance_context_and_request_attr_and_renderer(self):
+    def test__map_view_as_instance_context_and_request_attr_and_renderer(self):
         config = self._makeOne()
         self._registerRenderer(config)
         class View:
             def index(self, context, request):
                 return {'a':'1'}
         view = View()
-        result = config.map_view(
+        result = config._map_view(
             view, attr='index',
             renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
         self.failIf(result is view)
         request = DummyRequest()
         self.assertEqual(result(None, request).body, 'Hello!')
 
-    def test_map_view_as_instance_requestonly(self):
+    def test__map_view_as_instance_requestonly(self):
         config = self._makeOne()
         class View:
             def __call__(self, request):
                 return 'OK'
         view = View()
-        result = config.map_view(view)
+        result = config._map_view(view)
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.failUnless('instance' in result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
-    def test_map_view_as_instance_requestonly_with_attr(self):
+    def test__map_view_as_instance_requestonly_with_attr(self):
         config = self._makeOne()
         class View:
             def index(self, request):
                 return 'OK'
         view = View()
-        result = config.map_view(view, attr='index')
+        result = config._map_view(view, attr='index')
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.failUnless('instance' in result.__name__)
         self.assertEqual(result(None, None), 'OK')
 
-    def test_map_view_as_instance_requestonly_with_attr_and_renderer(self):
+    def test__map_view_as_instance_requestonly_with_attr_and_renderer(self):
         config = self._makeOne()
         self._registerRenderer(config)
         class View:
             def index(self, request):
                 return {'a':'1'}
         view = View()
-        result = config.map_view(
+        result = config._map_view(
             view, attr='index',
             renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
         self.failIf(result is view)
@@ -359,12 +1127,12 @@ class ConfiguratorTests(unittest.TestCase):
         request = DummyRequest()
         self.assertEqual(result(None, request).body, 'Hello!')
 
-    def test_map_view_rendereronly(self):
+    def test__map_view_rendereronly(self):
         config = self._makeOne()
         self._registerRenderer(config)
         def view(context, request):
             return {'a':'1'}
-        result = config.map_view(
+        result = config._map_view(
             view,
             renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
         self.failIf(result is view)
@@ -373,23 +1141,18 @@ class ConfiguratorTests(unittest.TestCase):
         request = DummyRequest()
         self.assertEqual(result(None, request).body, 'Hello!')
 
-    def test_map_view_defaultrendereronly(self):
+    def test__map_view_defaultrendereronly(self):
         config = self._makeOne()
         self._registerRenderer(config, name='')
         def view(context, request):
             return {'a':'1'}
-        result = config.map_view(view)
+        result = config._map_view(view)
         self.failIf(result is view)
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         request = DummyRequest()
         self.assertEqual(result(None, request).body, 'Hello!')
 
-    def _callDefaultConfiguration(self, *arg, **kw):
-        inst = self._makeOne()
-        inst.default_configuration(*arg, **kw)
-        return inst.reg
-
     def test_default_config_fixtureapp_default_filename_withpackage(self):
         manager = DummyRegistryManager()
         from repoze.bfg.tests import fixtureapp
@@ -627,3 +1390,9 @@ class DummyOverrides:
     def insert(self, path, package, prefix):
         self.inserted.append((path, package, prefix))
 
+from zope.interface import Interface
+class IDummy(Interface):
+    pass
+
+class IOther(Interface):
+    pass
diff --git a/repoze/bfg/tests/test_request.py b/repoze/bfg/tests/test_request.py
index eb26b07cf..7d9e956ae 100644
--- a/repoze/bfg/tests/test_request.py
+++ b/repoze/bfg/tests/test_request.py
@@ -155,6 +155,7 @@ class Test_route_request_iface(unittest.TestCase):
         iface = self._callFUT('routename')
         self.failUnless(iface.extends(IRouteRequest))
         self.failUnless(iface.extends(IRequest))
+        self.assertEqual(iface.__name__, 'routename_IRequest')
 
 class Test_add_global_response_headers(unittest.TestCase):
     def _callFUT(self, request, headerlist):
diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index 7caf2a596..3dc55957e 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -17,445 +17,6 @@ class TestViewDirective(unittest.TestCase):
         from repoze.bfg.zcml import view
         return view(*arg, **kw)
 
-    def test_no_view(self):
-        from zope.configuration.exceptions import ConfigurationError
-        context = DummyContext()
-        self.assertRaises(ConfigurationError, self._callFUT, context,
-                          'repoze.view', None)
-
-    def test_view_as_function(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        view = lambda *arg: None
-        self._callFUT(context, 'repoze.view', IFoo, view=view)
-        actions = context.actions
-
-        self.assertEqual(len(actions), 1)
-
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        sm = getSiteManager()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        self.failUnless(wrapper)
-        self.failIf(hasattr(wrapper, '__call_permissive__'))
-
-        perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='')
-        self.assertEqual(perm, None)
-
-    def test_view_as_function_requestonly(self):
-        from zope.interface import Interface
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-
-        context = DummyContext()
-
-        def view(request):
-            return 'OK'
-        class IFoo(Interface):
-            pass
-        
-        self._callFUT(context, 'repoze.view', IFoo, view=view)
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        sm = getSiteManager()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        self.failIfEqual(wrapper, view)
-        self.assertEqual(wrapper.__module__, view.__module__)
-        self.assertEqual(wrapper.__name__, view.__name__)
-        self.assertEqual(wrapper.__doc__, view.__doc__)
-        result = wrapper(None, None)
-        self.assertEqual(result, 'OK')
-        self.failIf(hasattr(wrapper, '__call_permissive__'))
-
-        perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='')
-        self.assertEqual(perm, None)
-
-    def test_view_as_instance(self):
-        from zope.interface import Interface
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-
-        context = DummyContext()
-        class AView:
-            def __call__(self, context, request):
-                """ """
-        view = AView()
-        class IFoo(Interface):
-            pass
-        self._callFUT(context, 'repoze.view', IFoo, view=view)
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        sm = getSiteManager()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        self.failUnless(wrapper)
-        self.failIf(hasattr(wrapper, '__call_permissive__'))
-
-        perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='')
-        self.assertEqual(perm, None)
-
-    def test_view_as_instance_requestonly(self):
-        from zope.interface import Interface
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-
-        context = DummyContext()
-        class AView:
-            def __call__(self, request):
-                return 'OK'
-        view = AView()
-        class IFoo(Interface):
-            pass
-        self._callFUT(context, 'repoze.view', IFoo, view=view)
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        sm = getSiteManager()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        self.failIfEqual(wrapper, view)
-        self.assertEqual(wrapper.__module__, view.__module__)
-        self.failUnless('instance' in wrapper.__name__)
-        self.assertEqual(wrapper.__doc__, view.__doc__)
-        result = wrapper(None, None)
-        self.assertEqual(result, 'OK')
-        self.failIf(hasattr(wrapper, '__call_permissive__'))
-
-        perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='')
-        self.assertEqual(perm, None)
-
-    def test_view_as_oldstyle_class(self):
-        from zope.interface import Interface
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        class view:
-            def __init__(self, context, request):
-                self.context = context
-                self.request = request
-
-            def __call__(self):
-                return self
-        self._callFUT(context, 'repoze.view', IFoo, view=view)
-        actions = context.actions
-
-        self.assertEqual(len(actions), 1)
-
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        sm = getSiteManager()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        self.assertEqual(wrapper.__module__, view.__module__)
-        self.assertEqual(wrapper.__name__, view.__name__)
-        self.assertEqual(wrapper.__doc__, view.__doc__)
-        result = wrapper(None, None)
-        self.assertEqual(result.context, None)
-        self.assertEqual(result.request, None)
-        self.failIf(hasattr(wrapper, '__call_permissive__'))
-
-        perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='')
-        self.assertEqual(perm, None)
-
-    def test_view_as_oldstyle_class_requestonly(self):
-        from zope.interface import Interface
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        class view:
-            def __init__(self, request):
-                self.request = request
-
-            def __call__(self):
-                return self
-        self._callFUT(context, 'repoze.view', IFoo, view=view)
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        sm = getSiteManager()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        self.assertEqual(wrapper.__module__, view.__module__)
-        self.assertEqual(wrapper.__name__, view.__name__)
-        self.assertEqual(wrapper.__doc__, view.__doc__)
-        result = wrapper(None, None)
-        self.assertEqual(result.request, None)
-        self.failIf(hasattr(wrapper, '__call_permissive__'))
-
-        perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='')
-        self.assertEqual(perm, None)
-
-
-    def test_view_as_newstyle_class(self):
-        from zope.interface import Interface
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        class view(object):
-            def __init__(self, context, request):
-                self.context = context
-                self.request = request
-
-            def __call__(self):
-                return self
-        self._callFUT(context, 'repoze.view', IFoo, view=view)
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        sm = getSiteManager()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        self.assertEqual(wrapper.__module__, view.__module__)
-        self.assertEqual(wrapper.__name__, view.__name__)
-        self.assertEqual(wrapper.__doc__, view.__doc__)
-        result = wrapper(None, None)
-        self.assertEqual(result.context, None)
-        self.assertEqual(result.request, None)
-        self.failIf(hasattr(wrapper, '__call_permissive__'))
-
-        perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='')
-        self.assertEqual(perm, None)
-
-    def test_view_as_newstyle_class_requestonly(self):
-        from zope.interface import Interface
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        class view(object):
-            def __init__(self, request):
-                self.request = request
-
-            def __call__(self):
-                return self
-        self._callFUT(context, 'repoze.view', IFoo, view=view)
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        sm = getSiteManager()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        self.assertEqual(wrapper.__module__, view.__module__)
-        self.assertEqual(wrapper.__name__, view.__name__)
-        self.assertEqual(wrapper.__doc__, view.__doc__)
-        result = wrapper(None, None)
-        self.assertEqual(result.request, None)
-        self.failIf(hasattr(wrapper, '__call_permissive__'))
-
-        perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='')
-        self.assertEqual(perm, None)
-
-    def test_with_reltemplate(self):
-        from zope.interface import Interface
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRendererFactory
-        import repoze.bfg.tests
-
-        context = DummyContext(repoze.bfg.tests)
-        class IFoo(Interface):
-            pass
-        class view(object):
-            def __init__(self, context, request):
-                self.request = request
-                self.context = context
-
-            def __call__(self):
-                return {'a':'1'}
-
-        class Renderer:
-            def __call__(self, path):
-                self.path = path
-                return lambda *arg: 'Hello!'
-
-        renderer = Renderer()
-        sm = getSiteManager()
-        sm.registerUtility(renderer, IRendererFactory, name='.txt')
-
-        fixture = 'fixtures/minimal.txt'
-        self._callFUT(context, 'repoze.view', IFoo, view=view, renderer=fixture)
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        self.assertEqual(wrapper.__module__, view.__module__)
-        self.assertEqual(wrapper.__name__, view.__name__)
-        self.assertEqual(wrapper.__doc__, view.__doc__)
-        request = DummyRequest()
-        result = wrapper(None, request)
-        self.assertEqual(result.body, 'Hello!')
-        self.assertEqual(renderer.path, 'repoze.bfg.tests:fixtures/minimal.txt')
-
-    def test_with_template_no_view_callable(self):
-        from zope.interface import Interface
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRendererFactory
-
-        import repoze.bfg.tests
-
-        context = DummyContext(repoze.bfg.tests)
-        class IFoo(Interface):
-            pass
-        sm = getSiteManager()
-        def renderer_factory(path):
-            return lambda *arg: 'Hello!'
-        sm.registerUtility(renderer_factory, IRendererFactory, name='.txt')
-
-        self._callFUT(context, 'repoze.view', IFoo, renderer='foo.txt')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.environ = {}
-        result = wrapper(None, request)
-        self.assertEqual(result.body, 'Hello!')
-
-    def test_request_type_asinterface(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-        class IRequest(Interface):
-            pass
-        class IFoo(Interface):
-            pass
-        context = DummyContext(IRequest)
-        view = lambda *arg: None
-        self._callFUT(context, 'repoze.view', IFoo, view=view,
-                      request_type=IDummy)
-        actions = context.actions
-
-        self.assertEqual(len(actions), 1)
-
-        action = actions[0]
-        discrim = ('view', IFoo, '', IDummy, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        sm = getSiteManager()
-        wrapper = sm.adapters.lookup((IFoo, IDummy), IView, name='')
-        self.failUnless(wrapper)
-        self.failIf(hasattr(wrapper, '__call_permissive__'))
-
-        perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='')
-        self.assertEqual(perm, None)
-
-    def test_request_type_as_noninterface(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from zope.interface import implementedBy
-        from repoze.bfg.interfaces import IView
-        class IFoo(Interface):
-            pass
-        class Dummy:
-            pass
-        context = DummyContext(Dummy)
-        view = lambda *arg: None
-        self._callFUT(context, 'repoze.view', IFoo, view=view,
-                      request_type=Dummy)
-        actions = context.actions
-
-        self.assertEqual(len(actions), 1)
-
-        action = actions[0]
-        discrim = ('view', IFoo, '', Dummy, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        sm = getSiteManager()
-        iface = implementedBy(Dummy)
-        wrapper = sm.adapters.lookup((IFoo, iface), IView, name='')
-        self.failUnless(wrapper)
-        self.failIf(hasattr(wrapper, '__call_permissive__'))
-
     def test_request_type_ashttpmethod(self):
         from zope.interface import Interface
         from zope.component import getSiteManager
@@ -472,7 +33,7 @@ class TestViewDirective(unittest.TestCase):
         self.assertEqual(len(actions), 1)
 
         action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, 'GET', None,
+        discrim = ('view', IFoo, '', None, IView, None, None, 'GET', None,
                    None, False, None, None, None)
         self.assertEqual(action['discriminator'], discrim)
         register = action['callable']
@@ -485,7 +46,6 @@ class TestViewDirective(unittest.TestCase):
         request.method = 'POST'
         self.assertEqual(wrapper.__predicated__(None, request), False)
         
-
     def test_request_type_asinterfacestring(self):
         from zope.component import getSiteManager
         from zope.interface import Interface
@@ -515,726 +75,6 @@ class TestViewDirective(unittest.TestCase):
         perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='')
         self.assertEqual(perm, None)
 
-    def test_with_route_name(self):
-        from zope.interface import Interface
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        class IFoo(Interface):
-            pass
-        context = DummyContext()
-        view = lambda *arg: '123'
-        self._callFUT(context, 'repoze.view', IFoo, view=view, route_name='foo')
-        actions = context.actions
-
-        self.assertEqual(len(actions), 1)
-
-        action = actions[0]
-        register = action['callable']
-        register()
-        sm = getSiteManager() 
-        request_type = sm.getUtility(IRouteRequest, 'foo')
-        discrim = ('view', IFoo, '', request_type, IView, None, None, None,
-                   'foo', None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        the_view = sm.adapters.lookup((IFoo, request_type), IView, name='')
-        request = DummyRequest({})
-        self.assertEqual(the_view(None, request), '123')
-
-    def test_with_request_method_true(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            return '123'
-        self._callFUT(context, None, IFoo, view=view, request_method='POST')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, 'POST', None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.method = 'POST'
-        self.assertEqual(wrapper(None, request), '123')
-
-    def test_with_request_method_false(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.exceptions import NotFound
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            """ """
-        self._callFUT(context, None, IFoo, view=view, request_method='POST')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, 'POST', None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.method = 'GET'
-        self.assertRaises(NotFound, wrapper, None, request)
-
-    def test_with_request_param_noval_true(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            return '123'
-        self._callFUT(context, None, IFoo, view=view, request_param='abc')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, 'abc', None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.params = {'abc':''}
-        self.assertEqual(wrapper(None, request), '123')
-
-    def test_with_request_param_noval_false(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.exceptions import NotFound
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            """ """
-        self._callFUT(context, None, IFoo, view=view, request_param='abc')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, 'abc', None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.params = {}
-        self.assertRaises(NotFound, wrapper, None, request)
-
-    def test_with_request_param_val_true(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            return '123'
-        self._callFUT(context, None, IFoo, view=view, request_param='abc=123')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, 'abc=123', None,
-                   None, None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.params = {'abc':'123'}
-        self.assertEqual(wrapper(None, request), '123')
-
-    def test_with_request_param_val_false(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.exceptions import NotFound
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            """ """
-        self._callFUT(context, None, IFoo, view=view, request_param='abc=123')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, 'abc=123', None,
-                   None, None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.params = {'abc':'456'}
-        self.assertRaises(NotFound, wrapper, None, request)
-
-    def test_with_xhr_true(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        class IFoo(Interface):
-            pass
-        context = DummyContext()
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            return '123'
-        self._callFUT(context, None, IFoo, view=view, xhr=True)
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, True, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.is_xhr = True
-        self.assertEqual(wrapper(None, request), '123')
-
-    def test_with_xhr_false(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.exceptions import NotFound
-        class IFoo(Interface):
-            pass
-        context = DummyContext()
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            """ """
-        self._callFUT(context, None, IFoo, view=view, xhr=True)
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, True, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.is_xhr = False
-        self.assertRaises(NotFound, wrapper, None, request)
-
-    def test_with_header_badregex(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from zope.configuration.exceptions import ConfigurationError
-        class IFoo(Interface):
-            pass
-        context = DummyContext()
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            """ """
-        self._callFUT(context, None, IFoo, view=view, header='Host:a\\')
-        self.assertRaises(ConfigurationError, context.actions[-1]['callable'])
-
-    def test_with_header_noval_match(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        class IFoo(Interface):
-            pass
-        context = DummyContext()
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            return '123'
-        self._callFUT(context, None, IFoo, view=view, header='Host')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, 'Host', None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.headers  = {'Host':'whatever'}
-        self.assertEqual(wrapper(None, request), '123')
-
-    def test_with_header_noval_nomatch(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.exceptions import NotFound
-        class IFoo(Interface):
-            pass
-        context = DummyContext()
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            """ """
-        self._callFUT(context, None, IFoo, view=view, header='Host')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, 'Host', None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.headers  = {'NotHost':'whatever'}
-        self.assertRaises(NotFound, wrapper, None, request)
-
-    def test_with_header_val_match(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        class IFoo(Interface):
-            pass
-        context = DummyContext()
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            return '123'
-        self._callFUT(context, None, IFoo, view=view, header=r'Host:\d')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, r'Host:\d', None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.headers  = {'Host':'1'}
-        self.assertEqual(wrapper(None, request), '123')
-
-    def test_with_header_val_nomatch(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.exceptions import NotFound
-        class IFoo(Interface):
-            pass
-        context = DummyContext()
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            """ """
-        self._callFUT(context, None, IFoo, view=view, header=r'Host:\d')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, r'Host:\d', None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.headers  = {'Host':'abc'}
-        self.assertRaises(NotFound, wrapper, None, request)
-
-    def test_with_accept_match(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        class IFoo(Interface):
-            pass
-        context = DummyContext()
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            return '123'
-        self._callFUT(context, None, IFoo, view=view, accept='text/xml')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, 'text/xml', None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.accept = ['text/xml']
-        self.assertEqual(wrapper(None, request), '123')
-
-    def test_with_accept_nomatch(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.exceptions import NotFound
-        class IFoo(Interface):
-            pass
-        context = DummyContext()
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            """ """
-        self._callFUT(context, None, IFoo, view=view, accept='text/xml')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, 'text/xml', None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        request.accept = ['text/html']
-        self.assertRaises(NotFound, wrapper, None, request)
-
-    def test_with_containment_true(self):
-        from zope.component import getSiteManager
-        from zope.interface import directlyProvides
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            return '123'
-        sm.registerAdapter(view, (IFoo, IRequest), IView, name='')
-        self._callFUT(context, None, IFoo, view=view, containment=IFoo)
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, IFoo, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        context = Dummy()
-        directlyProvides(context, IFoo)
-        self.assertEqual(wrapper(context, request), '123')
-
-    def test_with_containment_false(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.exceptions import NotFound
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            """ """
-        self._callFUT(context, None, IFoo, view=view, containment=IFoo)
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, IFoo, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest()
-        context = Dummy()
-        self.assertRaises(NotFound, wrapper, context, request)
-
-    def test_with_path_info_badregex(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from zope.configuration.exceptions import ConfigurationError
-        class IFoo(Interface):
-            pass
-        context = DummyContext()
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            """ """
-        self._callFUT(context, None, IFoo, view=view, path_info='\\')
-        self.assertRaises(ConfigurationError, context.actions[-1]['callable'])
-
-    def test_with_path_info_match(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        class IFoo(Interface):
-            pass
-        context = DummyContext()
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request):
-            return '123'
-        self._callFUT(context, None, IFoo, view=view, path_info='/foo')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, '/foo')
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest({'PATH_INFO': '/foo'})
-        self.assertEqual(wrapper(None, request), '123')
-
-    def test_with_path_info_nomatch(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.exceptions import NotFound
-        class IFoo(Interface):
-            pass
-        context = DummyContext()
-        view = lambda *arg: None
-        sm = getSiteManager()
-        def view(context, request): pass
-        self._callFUT(context, None, IFoo, view=view, path_info='/boo')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, '/boo')
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        request = DummyRequest({'PATH_INFO': '/foo'})
-        self.assertRaises(NotFound, wrapper, None, request)
-
-    def test_multiview_replaces_traditional_view(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IMultiView
-        from repoze.bfg.interfaces import IViewPermission
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        sm = getSiteManager()
-        def view(context, request):
-            return '123'
-        sm.registerAdapter(view, (IFoo, IRequest), IView, name='')
-        self._callFUT(context, 'repoze.view', IFoo, view=view)
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        self.failUnless(IMultiView.providedBy(wrapper))
-        perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='')
-        self.assertEqual(perm, wrapper.__permitted__)
-        self.assertEqual(wrapper(None, None), '123')
-
-    def test_multiview_call_ordering(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        def view1(context, request): return 'view1'
-        def view2(context, request): return 'view2'
-        def view3(context, request): return 'view3'
-        def view4(context, request): return 'view4'
-        def view5(context, request): return 'view5'
-        def view6(context, request): return 'view6'
-        def view7(context, request): return 'view7'
-        def view8(context, request): return 'view8'
-        self._callFUT(context, 'repoze.view', IFoo, view=view1)
-        self._callFUT(context, 'repoze.view', IFoo, view=view2,
-                      request_method='POST')
-        self._callFUT(context, 'repoze.view', IFoo, view=view3,
-                      request_param='param')
-        self._callFUT(context, 'repoze.view', IFoo, view=view4,
-                      containment=IFoo)
-        self._callFUT(context, 'repoze.view', IFoo, view=view5,
-                      request_method='POST', request_param='param')
-        self._callFUT(context, 'repoze.view', IFoo, view=view6,
-                      request_method='POST', containment=IFoo)
-        self._callFUT(context, 'repoze.view', IFoo, view=view7,
-                      request_param='param', containment=IFoo)
-        self._callFUT(context, 'repoze.view', IFoo, view=view8,
-                      request_type='POST', request_param='param',
-                      containment=IFoo)
-        for action in context.actions:
-            register = action['callable']
-            register()
-
-        sm = getSiteManager()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-
-        ctx = Dummy()
-        request = DummyRequest()
-        request.method = 'GET'
-        request.params = {}
-        self.assertEqual(wrapper(ctx, request), 'view1')
-
-        ctx = Dummy()
-        request = DummyRequest()
-        request.params = {}
-        request.method = 'POST'
-        self.assertEqual(wrapper(ctx, request), 'view2')
-
-        ctx = Dummy()
-        request = DummyRequest()
-        request.params = {'param':'1'}
-        request.method = 'GET'
-        self.assertEqual(wrapper(ctx, request), 'view3')
-
-        ctx = Dummy()
-        directlyProvides(ctx, IFoo)
-        request = DummyRequest()
-        request.method = 'GET'
-        request.params = {}
-        self.assertEqual(wrapper(ctx, request), 'view4')
-
-        ctx = Dummy()
-        request = DummyRequest()
-        request.method = 'POST'
-        request.params = {'param':'1'}
-        self.assertEqual(wrapper(ctx, request), 'view5')
-
-        ctx = Dummy()
-        directlyProvides(ctx, IFoo)
-        request = DummyRequest()
-        request.params = {}
-        request.method = 'POST'
-        self.assertEqual(wrapper(ctx, request), 'view6')
-
-        ctx = Dummy()
-        directlyProvides(ctx, IFoo)
-        request = DummyRequest()
-        request.method = 'GET'
-        request.params = {'param':'1'}
-        self.assertEqual(wrapper(ctx, request), 'view7')
-
-        ctx = Dummy()
-        directlyProvides(ctx, IFoo)
-        request = DummyRequest()
-        request.method = 'POST'
-        request.params = {'param':'1'}
-        self.assertEqual(wrapper(ctx, request), 'view8')
-
-    def test_multiview_replaces_multiview(self):
-        from zope.component import getSiteManager
-        from zope.interface import Interface
-        from zope.interface import implements
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IMultiView
-        from repoze.bfg.interfaces import IViewPermission
-        context = DummyContext()
-        class IFoo(Interface):
-            pass
-        view = lambda *arg: None
-        sm = getSiteManager()
-        class DummyMultiView:
-            implements(IMultiView)
-            def __init__(self):
-                self.views = []
-                self.name = 'name'
-            def add(self, view, score):
-                self.views.append(view)
-            def __call__(self, context, request):
-                return '123'
-            def __permitted__(self, context, request):
-                """ """
-        view = DummyMultiView()
-        sm.registerAdapter(view, (IFoo, IRequest), IMultiView, name='')
-        def view2(context, request):
-            """ """
-        self._callFUT(context, None, IFoo, view=view2)
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
-        perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='')
-        self.assertEqual(perm, wrapper.__permitted__)
-        self.failUnless(IMultiView.providedBy(wrapper))
-        self.assertEqual(wrapper(None, None), '123')
-        self.assertEqual(wrapper.views, [view2])
-
-    def test_for_as_class(self):
-        from zope.component import getSiteManager
-        from zope.interface import implementedBy
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        context = DummyContext()
-        class Foo:
-            pass
-        sm = getSiteManager()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'repoze.view', Foo, view=view)
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        action = actions[0]
-        discrim = ('view', Foo, '', IRequest, IView, None, None, None, None,
-                   None, False, None, None, None)
-        self.assertEqual(action['discriminator'], discrim)
-        register = action['callable']
-        register()
-        foo = implementedBy(Foo)
-        wrapper = sm.adapters.lookup((foo, IRequest), IView, name='')
-        self.assertEqual(wrapper, view)
-
 class TestNotFoundDirective(unittest.TestCase):
     def setUp(self):
         testing.setUp()
@@ -1557,871 +397,36 @@ class TestRouteDirective(unittest.TestCase):
         self.assertEqual(len(routes[0].predicates), num_predicates)
         return route
 
-    def test_defaults(self):
-        context = DummyContext()
-        self._callFUT(context, 'name', 'path')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-        route_action = actions[0]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(
-            route_discriminator,
-            ('route', 'name', False, None, None, None, None, None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
     def test_with_view(self):
+        from zope.component import getSiteManager
         from zope.interface import Interface
         from repoze.bfg.interfaces import IView
         from repoze.bfg.interfaces import IRouteRequest
-        from zope.component import getSiteManager
-
         context = DummyContext()
-        def view(context, request):
-            return '123'
+        view = lambda *arg: 'OK'
         self._callFUT(context, 'name', 'path', view=view)
         actions = context.actions
         self.assertEqual(len(actions), 2)
 
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        register = view_action['callable']
-        register()
-        wrapped = sm.adapters.lookup((Interface, request_type), IView, name='')
-        request = DummyRequest()
-        self.assertEqual(wrapped(None, request), '123')
-        
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(
-            route_discriminator,
-            ('route', 'name', False, None, None, None, None, None))
-
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_with_view_and_view_for(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            return '123'
-        self._callFUT(context, 'name', 'path', view=view, view_for=IDummy)
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', IDummy, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        request = DummyRequest()
-        self.assertEqual(wrapped(None, request), '123')
-        
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(
-            route_discriminator,
-            ('route', 'name', False, None, None, None, None, None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_with_view_and_view_for_alias(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            return '123'
-        self._callFUT(context, 'name', 'path', view=view, for_=IDummy)
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', IDummy, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        request = DummyRequest()
-        self.assertEqual(wrapped(None, request), '123')
-        
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None, None, None,None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_without_view(self):
-        from repoze.bfg.interfaces import IRoutesMapper
-        from zope.component import getSiteManager
-        context = DummyContext()
-        self._callFUT(context, 'name', 'path')
-        actions = context.actions
-        self.assertEqual(len(actions), 1)
-
         route_action = actions[0]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None, None, None, None))
-        route_callable()
-        sm = getSiteManager()
-        mapper = sm.getUtility(IRoutesMapper)
-        routes = mapper.get_routes()
-        self.assertEqual(len(routes), 1)
-        self.assertEqual(routes[0].name, 'name')
-        self.assertEqual(routes[0].path, 'path')
-        self.failIf(routes[0].predicates)
-
-    def test_with_view_request_type(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view,
-                      view_request_type="GET")
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, 'GET',
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None, None, None,None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_with_view_request_type_alias(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view,
-                      request_type="GET")
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, 'GET',
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
+        route_action['callable']()
         route_discriminator = route_action['discriminator']
-        route_args = route_action['args']
         self.assertEqual(route_discriminator,
                          ('route', 'name', False, None, None, None, None,None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_with_view_request_method(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view,
-                      view_request_method="GET")
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, 'GET',
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None, None, None, None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_with_view_containment(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view, view_containment=True)
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, True, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None,None, None, None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_with_view_header(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view, view_header='Host')
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, None,
-                   'name', None, False, None, 'Host', None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None,None, None, None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_with_view_path_info(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view, view_path_info='/foo')
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, '/foo')
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None, None, None, None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_with_view_xhr(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view, view_xhr=True)
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, None,
-                   'name', None, True, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None, None, None, None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_with_view_accept(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view,
-                      view_accept='text/xml')
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, None,
-                   'name', None, False, 'text/xml', None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(
-            route_discriminator,
-            ('route', 'name', False, None, None, None, None, None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_with_view_renderer(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        from repoze.bfg.interfaces import IRendererFactory
-        
-        sm = getSiteManager()
-        def renderer(name):
-            return lambda *x: 'foo'
-        sm.registerUtility(renderer, IRendererFactory, name='dummy')
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view,
-                      view_renderer="dummy")
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None, None, None, None))
-        route_callable()
         self._assertRoute('name', 'path')
 
-    def test_with_view_renderer_alias(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        from repoze.bfg.interfaces import IRendererFactory
-
+        view_action = actions[1]
         sm = getSiteManager()
-        def renderer(name):
-            return lambda *x: 'foo'
-        sm.registerUtility(renderer, IRendererFactory, name='dummy')
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view,
-                      renderer="dummy")
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
         request_type = sm.getUtility(IRouteRequest, 'name')
         view_discriminator = view_action['discriminator']
         discrim = ('view', None, '', request_type, IView, None, None, None,
                    'name', None, False, None, None, None)
         self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None, None, None, None))
-        route_callable()
-        self._assertRoute('name', 'path')
-        
-
-    def test_with_view_permission(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        sm = getSiteManager()
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view,
-                      view_permission="edit")
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None, None, None, None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_with_view_permission_alias(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-
-        sm = getSiteManager()
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view,
-                      permission="edit")
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None, None, None, None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_with_view_for(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        sm = getSiteManager()
-
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view,
-                      view_for=IDummy)
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', IDummy, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None, None, None, None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_with_view_for_alias(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-
-        sm = getSiteManager()
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view,
-                      for_=IDummy)
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', IDummy, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None, None, None, None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
-    def test_with_request_type_GET(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view, request_type="GET")
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, 'GET',
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
+        wrapped = sm.adapters.lookup((Interface, request_type), IView, name='')
         self.failUnless(wrapped)
 
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None, None, None,None))
-        route_callable()
-        self._assertRoute('name', 'path')
-
     # route predicates
 
-    def test_with_xhr(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view, xhr=True)
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', True, None, None, None, None, None))
-        route_callable()
-        route = self._assertRoute('name', 'path', 1)
-        request = DummyRequest()
-        request.is_xhr = True
-        self.assertEqual(route.predicates[0](None, request), True)
-
-    def test_with_request_method(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view, request_method="GET")
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, 'GET',None, None, None, None))
-        route_callable()
-        route = self._assertRoute('name', 'path', 1)
-        request = DummyRequest()
-        request.method = 'GET'
-        self.assertEqual(route.predicates[0](None, request), True)
-
-    def test_with_path_info(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view, path_info='/foo')
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, '/foo',None,None, None))
-        route_callable()
-        route = self._assertRoute('name', 'path', 1)
-        request = DummyRequest()
-        request.path_info = '/foo'
-        self.assertEqual(route.predicates[0](None, request), True)
-
-    def test_with_request_param(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view, request_param='abc')
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        route_args = route_action['args']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None,'abc', None, None))
-        route_callable()
-        route = self._assertRoute('name', 'path', 1)
-        request = DummyRequest()
-        request.params = {'abc':'123'}
-        self.assertEqual(route.predicates[0](None, request), True)
-
-    def test_with_header(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view, header='Host')
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(route_discriminator,
-                         ('route', 'name', False, None, None,None,'Host', None))
-        route_callable()
-        route = self._assertRoute('name', 'path', 1)
-        request = DummyRequest()
-        request.headers = {'Host':'example.com'}
-        self.assertEqual(route.predicates[0](None, request), True)
-
-    def test_with_accept(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IRouteRequest
-        
-        context = DummyContext()
-        def view(context, request):
-            """ """
-        self._callFUT(context, 'name', 'path', view=view, accept='text/xml')
-        actions = context.actions
-        self.assertEqual(len(actions), 2)
-
-        view_action = actions[0]
-        register = view_action['callable']
-        register()
-        sm = getSiteManager()
-        request_type = sm.getUtility(IRouteRequest, 'name')
-
-        view_discriminator = view_action['discriminator']
-        discrim = ('view', None, '', request_type, IView, None, None, None,
-                   'name', None, False, None, None, None)
-        self.assertEqual(view_discriminator, discrim)
-        wrapped = sm.adapters.lookup((IDummy, request_type), IView, name='')
-        self.failUnless(wrapped)
-
-        route_action = actions[1]
-        route_callable = route_action['callable']
-        route_discriminator = route_action['discriminator']
-        self.assertEqual(
-            route_discriminator,
-            ('route', 'name', False, None, None, None, None, 'text/xml'))
-        route_callable()
-        route = self._assertRoute('name', 'path', 1)
-        request = DummyRequest()
-        request.accept = ['text/xml']
-        self.assertEqual(route.predicates[0](None, request), True)
-
 class TestStaticDirective(unittest.TestCase):
     def setUp(self):
         testing.setUp()
@@ -2449,32 +454,30 @@ class TestStaticDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 2)
 
-        action = actions[0]
-        discriminator = action['discriminator']
-        self.assertEqual(discriminator[:3], ('view', StaticRootFactory, ''))
-        self.assertEqual(discriminator[4], IView)
         sm = getSiteManager()
-        register = action['callable']
-        register()
-        sm = getSiteManager()
-        iface = implementedBy(StaticRootFactory)
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        wrapped = sm.adapters.lookup((iface, request_type), IView, name='')
-        request = DummyRequest()
-        self.assertEqual(wrapped(None, request).__class__, StaticURLParser)
 
-        action = actions[1]
-        callable = action['callable']
-        discriminator = action['discriminator']
+        route_action = actions[0]
+        route_action['callable']()
+        discriminator = route_action['discriminator']
         self.assertEqual(discriminator,
                          ('route', 'name', False, None, None, None, None, None))
-        action['callable']()
         mapper = sm.getUtility(IRoutesMapper)
         routes = mapper.get_routes()
         self.assertEqual(len(routes), 1)
         self.assertEqual(routes[0].path, 'name*subpath')
         self.assertEqual(routes[0].name, 'name')
 
+
+        view_action = actions[1]
+        discriminator = view_action['discriminator']
+        self.assertEqual(discriminator[:3], ('view', StaticRootFactory, ''))
+        self.assertEqual(discriminator[4], IView)
+        iface = implementedBy(StaticRootFactory)
+        request_type = sm.getUtility(IRouteRequest, 'name')
+        wrapped = sm.adapters.lookup((iface, request_type), IView, name='')
+        request = DummyRequest()
+        self.assertEqual(wrapped(None, request).__class__, StaticURLParser)
+
     def test_package_relative(self):
         from repoze.bfg.static import PackageURLParser
         from zope.component import getSiteManager
@@ -2488,30 +491,29 @@ class TestStaticDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 2)
 
-        action = actions[0]
-        discriminator = action['discriminator']
-        self.assertEqual(discriminator[:3], ('view', StaticRootFactory, ''))
-        self.assertEqual(discriminator[4], IView)
-        register = action['callable']
-        register()
         sm = getSiteManager()
-        iface = implementedBy(StaticRootFactory)
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        view = sm.adapters.lookup((iface, request_type), IView, name='')
-        request = DummyRequest()
-        self.assertEqual(view(None, request).__class__, PackageURLParser)
 
-        action = actions[1]
-        discriminator = action['discriminator']
+        route_action = actions[0]
+        discriminator = route_action['discriminator']
         self.assertEqual(discriminator,
                          ('route', 'name', False, None, None, None, None, None))
-        action['callable']()
+        route_action['callable']()
         mapper = sm.getUtility(IRoutesMapper)
         routes = mapper.get_routes()
         self.assertEqual(len(routes), 1)
         self.assertEqual(routes[0].path, 'name*subpath')
         self.assertEqual(routes[0].name, 'name')
 
+        view_action = actions[1]
+        discriminator = view_action['discriminator']
+        self.assertEqual(discriminator[:3], ('view', StaticRootFactory, ''))
+        self.assertEqual(discriminator[4], IView)
+        iface = implementedBy(StaticRootFactory)
+        request_type = sm.getUtility(IRouteRequest, 'name')
+        view = sm.adapters.lookup((iface, request_type), IView, name='')
+        request = DummyRequest()
+        self.assertEqual(view(None, request).__class__, PackageURLParser)
+
     def test_here_relative(self):
         from repoze.bfg.static import PackageURLParser
         from zope.component import getSiteManager
@@ -2526,31 +528,28 @@ class TestStaticDirective(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 2)
 
-        action = actions[0]
-        discriminator = action['discriminator']
-        self.assertEqual(discriminator[:3], ('view', StaticRootFactory, ''))
-        self.assertEqual(discriminator[4], IView)
-        register = action['callable']
-        register()
         sm = getSiteManager()
-        iface = implementedBy(StaticRootFactory)
-        request_type = sm.getUtility(IRouteRequest, 'name')
-        wrapped = sm.adapters.lookup((iface, request_type), IView, name='')
-        request = DummyRequest()
-        self.assertEqual(wrapped(None, request).__class__, PackageURLParser)
-
-        action = actions[1]
-        callable = action['callable']
-        discriminator = action['discriminator']
+        route_action = actions[0]
+        route_action['callable']()
+        discriminator = route_action['discriminator']
         self.assertEqual(discriminator,
                          ('route', 'name', False, None, None, None, None, None))
-        action['callable']()
         mapper = sm.getUtility(IRoutesMapper)
         routes = mapper.get_routes()
         self.assertEqual(len(routes), 1)
         self.assertEqual(routes[0].path, 'name*subpath')
         self.assertEqual(routes[0].name, 'name')
 
+        view_action = actions[1]
+        discriminator = view_action['discriminator']
+        self.assertEqual(discriminator[:3], ('view', StaticRootFactory, ''))
+        self.assertEqual(discriminator[4], IView)
+        iface = implementedBy(StaticRootFactory)
+        request_type = sm.getUtility(IRouteRequest, 'name')
+        wrapped = sm.adapters.lookup((iface, request_type), IView, name='')
+        request = DummyRequest()
+        self.assertEqual(wrapped(None, request).__class__, PackageURLParser)
+
 class TestResourceDirective(unittest.TestCase):
     def setUp(self):
         testing.setUp()
diff --git a/repoze/bfg/view.py b/repoze/bfg/view.py
index 9406d5852..43ad809c1 100644
--- a/repoze/bfg/view.py
+++ b/repoze/bfg/view.py
@@ -626,21 +626,22 @@ def rendered_response(renderer, response, view, context,request,
                                  'context':context, 'request':request})
     response_factory = queryUtility(IResponseFactory, default=Response)
     response = response_factory(result)
-    attrs = request.__dict__
-    content_type = attrs.get('response_content_type', None)
-    if content_type is not None:
-        response.content_type = content_type
-    headerlist = attrs.get('response_headerlist', None)
-    if headerlist is not None:
-        for k, v in headerlist:
-            response.headers.add(k, v)
-    status = attrs.get('response_status', None)
-    if status is not None:
-        response.status = status
-    charset = attrs.get('response_charset', None)
-    if charset is not None:
-        response.charset = charset
-    cache_for = attrs.get('response_cache_for', None)
-    if cache_for is not None:
-        response.cache_expires = cache_for
+    if request is not None: # in tests, it may be None
+        attrs = request.__dict__
+        content_type = attrs.get('response_content_type', None)
+        if content_type is not None:
+            response.content_type = content_type
+        headerlist = attrs.get('response_headerlist', None)
+        if headerlist is not None:
+            for k, v in headerlist:
+                response.headers.add(k, v)
+        status = attrs.get('response_status', None)
+        if status is not None:
+            response.status = status
+        charset = attrs.get('response_charset', None)
+        if charset is not None:
+            response.charset = charset
+        cache_for = attrs.get('response_cache_for', None)
+        if cache_for is not None:
+            response.cache_expires = cache_for
     return response
diff --git a/repoze/bfg/zcml.py b/repoze/bfg/zcml.py
index cfe64aa3f..a7c5f2660 100644
--- a/repoze/bfg/zcml.py
+++ b/repoze/bfg/zcml.py
@@ -1,5 +1,3 @@
-from zope.component import queryUtility
-
 from zope.configuration.exceptions import ConfigurationError
 from zope.configuration.fields import GlobalObject
 
@@ -17,9 +15,8 @@ from repoze.bfg.interfaces import IAuthorizationPolicy
 from repoze.bfg.interfaces import IForbiddenView
 from repoze.bfg.interfaces import INotFoundView
 from repoze.bfg.interfaces import IRendererFactory
-from repoze.bfg.interfaces import IRequest
-from repoze.bfg.interfaces import IRouteRequest
 from repoze.bfg.interfaces import IView
+from repoze.bfg.interfaces import IRouteRequest
 
 from repoze.bfg.authentication import RepozeWho1AuthenticationPolicy
 from repoze.bfg.authentication import RemoteUserAuthenticationPolicy
@@ -155,14 +152,6 @@ def view(
     cacheable=True, # not used, here for b/w compat < 0.8
     ):
 
-    if not view:
-        if renderer:
-            def view(context, request):
-                return {}
-        else:
-            raise ConfigurationError('"view" attribute was not specified and '
-                                     'no renderer specified')
-
     reg = get_current_registry()
 
     if request_type in ('GET', 'HEAD', 'PUT', 'POST', 'DELETE'):
@@ -170,21 +159,12 @@ def view(
         request_method = request_type
         request_type = None
 
-    if request_type is None:
-        if route_name is None:
-            request_type = IRequest
-        else:
-            request_type = reg.queryUtility(IRouteRequest, name=route_name)
-            if request_type is None:
-                request_type = route_request_iface(route_name)
-                reg.registerUtility(request_type, IRouteRequest,
-                                    name=route_name)
-
-    if isinstance(request_type, basestring):
+    if request_type is not None:
         request_type = _context.resolve(request_type)
 
     if renderer and '.' in renderer:
-        renderer = resource_spec(renderer, package_name(_context.resolve('.')))
+        zcml_package = package_name(_context.resolve('.'))
+        renderer = resource_spec(renderer, zcml_package)
 
     def register():
         config = Configurator(reg)
@@ -221,10 +201,6 @@ class IRouteDirective(Interface):
     # alias for view_permission
     permission = TextLine(title=u'permission', required=False)
 
-    view_request_type = TextLine(title=u'view_request_type', required=False)
-    # alias for view_request_type
-    request_type = TextLine(title=u'request_type', required=False)
-
     view_renderer = TextLine(title=u'view_renderer', required=False)
     # alias for view_renderer
     renderer = TextLine(title=u'renderer', required=False)
@@ -247,12 +223,11 @@ class IRouteDirective(Interface):
     path_info = TextLine(title=u'path_info', required=False)
 
 def route(_context, name, path, view=None, view_for=None,
-          permission=None, factory=None, request_type=None, for_=None,
+          permission=None, factory=None, for_=None,
           header=None, xhr=False, accept=None, path_info=None,
           request_method=None, request_param=None, 
-          view_permission=None, view_request_type=None, 
-          view_request_method=None, view_request_param=None,
-          view_containment=None, view_attr=None,
+          view_permission=None, view_request_method=None,
+          view_request_param=None, view_containment=None, view_attr=None,
           renderer=None, view_renderer=None, view_header=None, 
           view_accept=None, view_xhr=False,
           view_path_info=None):
@@ -264,47 +239,39 @@ def route(_context, name, path, view=None, view_for=None,
     # in the routelist will be tried
     reg = get_current_registry()
 
-    if request_type in ('GET', 'HEAD', 'PUT', 'POST', 'DELETE'):
-        # b/w compat for 1.0
-        view_request_method = request_type
-        request_type = None
-
-    request_iface = queryUtility(IRouteRequest, name=name)
-    if request_iface is None:
-        request_iface = route_request_iface(name)
-        reg.registerUtility(request_iface, IRouteRequest, name=name)
-
-    if view:
-        view_for = view_for or for_
-        view_request_type = view_request_type or request_type
-        view_permission = view_permission or permission
-        view_renderer = view_renderer or renderer
-        _view(
-            _context,
-            permission=view_permission,
-            for_=view_for,
-            view=view,
-            name='',
-            request_type=view_request_type,
-            route_name=name, 
-            request_method=view_request_method,
-            request_param=view_request_param,
-            containment=view_containment,
-            attr=view_attr,
-            renderer=view_renderer,
-            header=view_header,
-            accept=view_accept,
-            xhr=view_xhr,
-            path_info=view_path_info,
-            )
+    view_for = view_for or for_
+    view_permission = view_permission or permission
+    view_renderer = view_renderer or renderer
+    if view_renderer and '.' in view_renderer:
+        zcml_package = package_name(_context.resolve('.'))
+        view_renderer = resource_spec(view_renderer, zcml_package)
 
     def register():
         config = Configurator(reg)
         config.route(
-            name, path, factory=factory, header=header,
-            xhr=xhr, accept=accept, path_info=path_info,
-            request_method=request_method, request_param=request_param,
-            _info=_context.info)
+            name,
+            path,
+            factory=factory,
+            header=header,
+            xhr=xhr,
+            accept=accept,
+            path_info=path_info,
+            request_method=request_method,
+            request_param=request_param,
+            view=view,
+            view_for=view_for,
+            view_permission=view_permission,
+            view_request_method=view_request_method,
+            view_request_param=view_request_param,
+            view_containment=view_containment,
+            view_attr=view_attr,
+            view_renderer=view_renderer,
+            view_header=view_header,
+            view_accept=view_accept,
+            view_xhr=view_xhr,
+            view_path_info=view_path_info,
+            _info=_context.info
+            )
         
     _context.action(
         discriminator = ('route', name, xhr, request_method, path_info,
@@ -312,6 +279,20 @@ def route(_context, name, path, view=None, view_for=None,
         callable = register,
         )
 
+    if view:
+        request_iface = reg.queryUtility(IRouteRequest, name=name)
+        if request_iface is None:
+            request_iface = route_request_iface(name)
+            reg.registerUtility(request_iface, IRouteRequest, name=name)
+        _context.action(
+            discriminator = (
+                'view', view_for, '', request_iface, IView,
+                view_containment, view_request_param, view_request_method,
+                name, view_attr, view_xhr, view_accept, view_header,
+                view_path_info),
+            )
+
+
 class ISystemViewDirective(Interface):
     view = GlobalObject(
         title=u"",