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

3 files changed, 874 insertions, 2105 deletions

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()