Merge multiview2 branch to HEAD.

7 files changed, 1872 insertions, 1312 deletions

diff --git a/repoze/bfg/tests/test_integration.py b/repoze/bfg/tests/test_integration.py
index 14dd6a8ad..681dcf043 100644
--- a/repoze/bfg/tests/test_integration.py
+++ b/repoze/bfg/tests/test_integration.py
@@ -18,10 +18,6 @@ def wsgiapptest(environ, start_response):
     """ """
     return '123'
 
-def _getRequestInterface(name_or_iface=None):
-    from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-    return DEFAULT_REQUEST_FACTORIES[name_or_iface]['interface']
-
 class WGSIAppPlusBFGViewTests(unittest.TestCase):
     def setUp(self):
         cleanUp()
@@ -39,7 +35,8 @@ class WGSIAppPlusBFGViewTests(unittest.TestCase):
         self.assertEqual(result, '123')
 
     def test_scanned(self):
-        IRequest = _getRequestInterface()
+        from zope.component import getSiteManager
+        from repoze.bfg.interfaces import IRequest
         from repoze.bfg.interfaces import IView
         from repoze.bfg.zcml import scan
         context = DummyContext()
@@ -48,9 +45,11 @@ class WGSIAppPlusBFGViewTests(unittest.TestCase):
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
-        self.assertEqual(action['args'],
-                         ('registerAdapter',
-                          wsgiapptest, (INothing, IRequest), IView, '', None))
+        register = action['callable']
+        register()
+        sm = getSiteManager()
+        view = sm.adapters.lookup((INothing, IRequest), IView, name='')
+        self.assertEqual(view, wsgiapptest)
 
 here = os.path.dirname(__file__)
 staticapp = static(os.path.join(here, 'fixtures'))
@@ -101,8 +100,8 @@ class TestGrokkedApp(unittest.TestCase):
 
     def test_it(self):
         import inspect
-        from repoze.bfg.interfaces import IPOSTRequest
         from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import IRequest
         import repoze.bfg.tests.grokkedapp as package
         from zope.configuration import config
         from zope.configuration import xmlconfig
@@ -112,37 +111,25 @@ class TestGrokkedApp(unittest.TestCase):
         xmlconfig.include(context, 'configure.zcml', package)
         actions = context.actions
 
-        post_iface = _getRequestInterface(IPOSTRequest)
-        request_iface = _getRequestInterface()
-
         postview = actions[-1]
         self.assertEqual(postview[0][1], None)
         self.assertEqual(postview[0][2], '')
-        self.assertEqual(postview[0][3], post_iface)
+        self.assertEqual(postview[0][3], IRequest)
         self.assertEqual(postview[0][4], IView)
-        self.assertEqual(postview[2][1], package.grokked_post)
-        self.assertEqual(postview[2][2], (None, post_iface))
-        self.assertEqual(postview[2][3], IView)
         
         klassview = actions[-2]
         self.assertEqual(klassview[0][1], None)
         self.assertEqual(klassview[0][2], 'grokked_klass')
-        self.assertEqual(klassview[0][3], request_iface)
+        self.assertEqual(klassview[0][3], IRequest)
         self.assertEqual(klassview[0][4], IView)
-        self.assertEqual(klassview[2][1], package.grokked_klass)
-        self.assertEqual(klassview[2][2], (None, request_iface))
-        self.assertEqual(klassview[2][3], IView)
         self.failUnless(inspect.isfunction(package.grokked_klass))
         self.assertEqual(package.grokked_klass(None, None), None)
 
         funcview = actions[-3]
         self.assertEqual(funcview[0][1], None)
         self.assertEqual(funcview[0][2], '')
-        self.assertEqual(funcview[0][3], request_iface)
+        self.assertEqual(funcview[0][3], IRequest)
         self.assertEqual(funcview[0][4], IView)
-        self.assertEqual(funcview[2][1], package.grokked)
-        self.assertEqual(funcview[2][2], (None, request_iface))
-        self.assertEqual(funcview[2][3], IView)
 
 class DummyContext:
     pass
diff --git a/repoze/bfg/tests/test_request.py b/repoze/bfg/tests/test_request.py
index 5f61f4efc..8aeeff42d 100644
--- a/repoze/bfg/tests/test_request.py
+++ b/repoze/bfg/tests/test_request.py
@@ -12,7 +12,7 @@ class TestMakeRequestASCII(unittest.TestCase):
         self._callFUT(event)
         self.assertEqual(request.charset, None)
 
-class TestRequestSubclass(object):
+class RequestTestBase(object):
     def _makeOne(self, environ):
         request = self._getTargetClass()(environ)
         return request
@@ -37,71 +37,22 @@ class TestRequestSubclass(object):
     def test_class_implements(self):
         from repoze.bfg.interfaces import IRequest
         klass = self._getTargetClass()
-        iface = self._getInterface()
-        self.assertTrue(iface.implementedBy(klass))
         self.assertTrue(IRequest.implementedBy(klass))
 
     def test_instance_provides(self):
         from repoze.bfg.interfaces import IRequest
         inst = self._makeOne({})
-        iface = self._getInterface()
-        self.assertTrue(iface.providedBy(inst))
         self.assertTrue(IRequest.providedBy(inst))
 
-
-class Test_Request(TestRequestSubclass, unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-        return DEFAULT_REQUEST_FACTORIES[None]['factory']
-
-    def _getInterface(self):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-        return DEFAULT_REQUEST_FACTORIES[None]['interface']
-
-class Test_GETRequest(TestRequestSubclass, unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-        return DEFAULT_REQUEST_FACTORIES['GET']['factory']
-
-    def _getInterface(self):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-        return DEFAULT_REQUEST_FACTORIES['GET']['interface']
-
-class Test_POSTRequest(TestRequestSubclass, unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-        return DEFAULT_REQUEST_FACTORIES['POST']['factory']
-
-    def _getInterface(self):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-        return DEFAULT_REQUEST_FACTORIES['POST']['interface']
-
-class Test_PUTRequest(TestRequestSubclass, unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-        return DEFAULT_REQUEST_FACTORIES['PUT']['factory']
-
-    def _getInterface(self):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-        return DEFAULT_REQUEST_FACTORIES['PUT']['interface']
-
-class Test_DELETERequest(TestRequestSubclass, unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-        return DEFAULT_REQUEST_FACTORIES['DELETE']['factory']
-
-    def _getInterface(self):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-        return DEFAULT_REQUEST_FACTORIES['DELETE']['interface']
-
-class Test_HEADRequest(TestRequestSubclass, unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-        return DEFAULT_REQUEST_FACTORIES['HEAD']['factory']
-
-    def _getInterface(self):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-        return DEFAULT_REQUEST_FACTORIES['HEAD']['interface']
+class TestRequest(unittest.TestCase, RequestTestBase):
+        def _getTargetClass(self):
+            from repoze.bfg.request import Request
+            return Request
+    
+class TestRouteRequest(unittest.TestCase, RequestTestBase):
+        def _getTargetClass(self):
+            from repoze.bfg.request import create_route_request_factory
+            return create_route_request_factory('abc')
 
 class TestRequestFactory(unittest.TestCase):
     def setUp(self):
@@ -114,187 +65,48 @@ class TestRequestFactory(unittest.TestCase):
         from repoze.bfg.request import request_factory
         return request_factory(environ)
 
-    def _registerRequestFactories(self, name=''):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IRequestFactories
-        factories = {}
-        def factory(environ):
-            return environ
-        for name in (None, 'GET', 'POST', 'PUT', 'DELETE', 'HEAD'):
-            factories[name] = {'factory':factory}
-        sm = getSiteManager()
-        sm.registerUtility(factories, IRequestFactories, name=name)
-        if name:
-            sm.registerUtility(factories, IRequestFactories, name='')
-
-    def _getRequestFactory(self, name_or_iface=None):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES
-        return DEFAULT_REQUEST_FACTORIES[name_or_iface]['factory']
-
-    def _makeRoute(self, name=None):
-        route = DummyRoute(name)
-        return route
-
-    def test_no_route_no_request_method(self):
+    def test_it_no_route(self):
         from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.request import Request
         result = self._callFUT({})
-        self.assertEqual(result.__class__, self._getRequestFactory())
-        self.failUnless(IRequest.providedBy(result))
-
-    def test_no_route_unknown(self):
-        from repoze.bfg.interfaces import IRequest
-        result = self._callFUT({'REQUEST_METHOD':'UNKNOWN'})
-        self.assertEqual(result.__class__, self._getRequestFactory())
+        self.assertEqual(result.__class__, Request)
         self.failUnless(IRequest.providedBy(result))
 
-    def test_no_route_get(self):
-        from repoze.bfg.interfaces import IGETRequest
-        result = self._callFUT({'REQUEST_METHOD':'GET'})
-        self.assertEqual(result.__class__, self._getRequestFactory('GET'))
-        self.failUnless(IGETRequest.providedBy(result))
-
-    def test_no_route_post(self):
-        from repoze.bfg.interfaces import IPOSTRequest
-        result = self._callFUT({'REQUEST_METHOD':'POST'})
-        self.assertEqual(result.__class__, self._getRequestFactory('POST'))
-        self.failUnless(IPOSTRequest.providedBy(result))
-
-    def test_no_route_put(self):
-        from repoze.bfg.interfaces import IPUTRequest
-        result = self._callFUT({'REQUEST_METHOD':'PUT'})
-        self.assertEqual(result.__class__, self._getRequestFactory('PUT'))
-        self.failUnless(IPUTRequest.providedBy(result))
-
-    def test_no_route_delete(self):
-        from repoze.bfg.interfaces import IDELETERequest
-        result = self._callFUT({'REQUEST_METHOD':'DELETE'})
-        self.assertEqual(result.__class__, self._getRequestFactory('DELETE'))
-        self.failUnless(IDELETERequest.providedBy(result))
-
-    def test_no_route_head(self):
-        from repoze.bfg.interfaces import IHEADRequest
-        result = self._callFUT({'REQUEST_METHOD':'HEAD'})
-        self.assertEqual(result.__class__, self._getRequestFactory('HEAD'))
-        self.failUnless(IHEADRequest.providedBy(result))
-
-    def test_route_no_request_method(self):
-        self._registerRequestFactories()
-        route = self._makeRoute()
-        environ = {'bfg.routes.route':route}
-        result = self._callFUT(environ)
-        self.assertEqual(result, environ)
-
-    def test_route_unknown(self):
-        self._registerRequestFactories()
-        route = self._makeRoute()
-        environ = {'bfg.routes.route':route, 'REQUEST_METHOD':'UNKNOWN'}
-        result = self._callFUT(environ)
-        self.assertEqual(result, environ)
-
-    def test_route_known(self):
-        self._registerRequestFactories()
-        route = self._makeRoute()
-        environ = {'bfg.routes.route':route, 'REQUEST_METHOD':'GET'}
-        result = self._callFUT(environ)
-        self.assertEqual(result, environ)
-
-class TestNamedRequestFactories(unittest.TestCase):
+    def test_it_with_route_found(self):
+        from zope.component import getSiteManager
+        from repoze.bfg.interfaces import IRouteRequest
+        sm = getSiteManager()
+        sm.registerUtility(DummyRequest, IRouteRequest, 'routename')
+        route = DummyRoute('routename')
+        result = self._callFUT({'bfg.routes.route':route})
+        self.assertEqual(result.__class__, DummyRequest)
+
+    def test_it_with_route_notfound(self):
+        from repoze.bfg.request import Request
+        route = DummyRoute('routename')
+        result = self._callFUT({'bfg.routes.route':route})
+        self.assertEqual(result.__class__, Request)
+
+class Test_create_route_request_factory(unittest.TestCase):
     def _callFUT(self, name):
-        from repoze.bfg.request import named_request_factories
-        return named_request_factories(name)
-
-    def test_it_unnamed(self):
-        factories = self._callFUT(None)
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IGETRequest
-        from repoze.bfg.interfaces import IPOSTRequest
-        from repoze.bfg.interfaces import IPUTRequest
-        from repoze.bfg.interfaces import IDELETERequest
-        from repoze.bfg.interfaces import IHEADRequest
-        for alias, iface in (
-            (None, IRequest),
-            ('GET', IGETRequest),
-            ('POST', IPOSTRequest),
-            ('PUT', IPUTRequest),
-            ('DELETE', IDELETERequest),
-            ('HEAD', IHEADRequest),
-            ):
-            self.failUnless(alias in factories)
-            self.failUnless(iface in factories)
-            self.assertEqual(factories[alias], factories[iface])
-            named_iface = factories[alias]['interface']
-            named_factory = factories[alias]['factory']
-            default_iface = factories[None]['interface']
-            self.assertEqual(factories[alias]['interface'], iface)
-            self.assertEqual(factories[iface]['interface'], iface)
-            self.assertEqual(factories[alias]['factory'].charset, 'utf-8')
-            self.failUnless(named_iface.implementedBy(named_factory))
-            self.failUnless(iface.implementedBy(named_factory))
-            self.failUnless(IRequest.implementedBy(named_factory))
-            self.failUnless(default_iface.implementedBy(named_factory))
+        from repoze.bfg.request import create_route_request_factory
+        return create_route_request_factory(name)
 
-    def test_it_named(self):
-        factories = self._callFUT('name')
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IGETRequest
-        from repoze.bfg.interfaces import IPOSTRequest
-        from repoze.bfg.interfaces import IPUTRequest
-        from repoze.bfg.interfaces import IDELETERequest
-        from repoze.bfg.interfaces import IHEADRequest
-        for alias, iface in (
-            (None, IRequest),
-            ('GET', IGETRequest),
-            ('POST', IPOSTRequest),
-            ('PUT', IPUTRequest),
-            ('DELETE', IDELETERequest),
-            ('HEAD', IHEADRequest),
-            ):
-            self.failUnless(alias in factories)
-            self.failUnless(iface in factories)
-            self.assertEqual(factories[alias], factories[iface])
-            self.assertEqual(factories[alias]['factory'].charset, 'utf-8')
-            named_iface = factories[alias]['interface']
-            named_factory = factories[alias]['factory']
-            default_iface = factories[None]['interface']
-            self.failUnless(named_iface.implementedBy(named_factory))
-            self.failUnless(iface.implementedBy(named_factory))
-            self.failUnless(IRequest.implementedBy(named_factory))
-            self.failUnless(default_iface.implementedBy(named_factory))
-
-class TestDefaultRequestFactories(unittest.TestCase):
     def test_it(self):
-        from repoze.bfg.request import DEFAULT_REQUEST_FACTORIES as factories
+        from repoze.bfg.interfaces import IRouteRequest
         from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IGETRequest
-        from repoze.bfg.interfaces import IPOSTRequest
-        from repoze.bfg.interfaces import IPUTRequest
-        from repoze.bfg.interfaces import IDELETERequest
-        from repoze.bfg.interfaces import IHEADRequest
-        for alias, iface in (
-            (None, IRequest),
-            ('GET', IGETRequest),
-            ('POST', IPOSTRequest),
-            ('PUT', IPUTRequest),
-            ('DELETE', IDELETERequest),
-            ('HEAD', IHEADRequest),
-            ):
-            self.failUnless(alias in factories)
-            self.failUnless(iface in factories)
-            self.assertEqual(factories[alias], factories[iface])
-            named_iface = factories[alias]['interface']
-            named_factory = factories[alias]['factory']
-            self.failUnless(named_iface.implementedBy(named_factory))
-            self.assertEqual(factories[alias]['interface'], iface)
-            self.assertEqual(factories[iface]['interface'], iface)
-            self.assertEqual(factories[alias]['factory'].charset, 'utf-8')
-
+        factory = self._callFUT('routename')
+        self.failUnless(IRouteRequest.implementedBy(factory))
+        self.failUnless(IRequest.implementedBy(factory))
 
 class DummyRoute:
     def __init__(self, name):
-        self.name=name
-
+        self.name = name
 class DummyRequest:
-    pass
+    def __init__(self, environ=None):
+        if environ is None:
+            environ = {}
+        self.environ = environ
 
 class DummyNewRequestEvent:
     def __init__(self, request):
diff --git a/repoze/bfg/tests/test_router.py b/repoze/bfg/tests/test_router.py
index 566ffe4f1..a96765a01 100644
--- a/repoze/bfg/tests/test_router.py
+++ b/repoze/bfg/tests/test_router.py
@@ -33,12 +33,6 @@ class RouterTests(unittest.TestCase):
         settings = Settings(**defaultkw)
         self.registry.registerUtility(settings, ISettings)
 
-    def _registerAuthenticationPolicy(self):
-        from repoze.bfg.interfaces import IAuthenticationPolicy
-        policy = DummyAuthenticationPolicy()
-        self.registry.registerUtility(policy, IAuthenticationPolicy)
-        return policy
-
     def _registerTraverserFactory(self, context, view_name='', subpath=None,
                                   traversed=None, virtual_root=None,
                                   virtual_root_path=None, **kw):
@@ -75,20 +69,6 @@ class RouterTests(unittest.TestCase):
         from repoze.bfg.interfaces import IView
         self.registry.registerAdapter(app, for_, IView, name)
 
-    def _registerViewPermission(self, view_name, allow=True):
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IViewPermission
-        class Checker(object):
-            def __call__(self, context, request):
-                self.context = context
-                self.request = request
-                return allow
-        checker = Checker()
-        self.registry.registerAdapter(checker, (Interface, Interface),
-                                      IViewPermission,
-                                      view_name)
-        return checker
-
     def _registerEventListener(self, iface):
         L = []
         def listener(event):
@@ -239,31 +219,6 @@ class RouterTests(unittest.TestCase):
         start_response = DummyStartResponse()
         self.assertRaises(ValueError, router, environ, start_response)
 
-    def test_iforbiddenview_returns_nonresponse(self):
-        from repoze.bfg.interfaces import IForbiddenView
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        class IContext(Interface):
-            pass
-        from repoze.bfg.interfaces import IRequest
-        context = DummyContext()
-        directlyProvides(context, IContext)
-        self._registerTraverserFactory(context)
-        self._registerAuthenticationPolicy()
-        response = DummyResponse()
-        view = DummyView(response)
-        from repoze.bfg.security import ACLDenied
-        denied = ACLDenied('ace', 'acl', 'permission', ['principals'], context)
-        environ = self._makeEnviron()
-        self._registerView(view, '', IContext, IRequest)
-        checker = self._registerViewPermission('', denied)
-        def app(context, request):
-            """ """
-        self.registry.registerUtility(app, IForbiddenView)
-        router = self._makeOne()
-        start_response = DummyStartResponse()
-        self.assertRaises(ValueError, router, environ, start_response)
-
     def test_call_view_registered_nonspecific_default_path(self):
         context = DummyContext()
         self._registerTraverserFactory(context)
@@ -369,72 +324,7 @@ class RouterTests(unittest.TestCase):
         self.assertEqual(start_response.status, '404 Not Found')
         self.failUnless('404' in result[0])
 
-    def test_call_view_permission_none(self):
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        class IContext(Interface):
-            pass
-        from repoze.bfg.interfaces import IRequest
-        context = DummyContext()
-        directlyProvides(context, IContext)
-        self._registerTraverserFactory(context, subpath=[''])
-        response = DummyResponse()
-        view = DummyView(response)
-        environ = self._makeEnviron()
-        self._registerView(view, '', IContext, IRequest)
-        router = self._makeOne()
-        start_response = DummyStartResponse()
-        result = router(environ, start_response)
-        self.assertEqual(start_response.status, '200 OK')
-
-    def test_call_view_no_authentication_policy_debug_authorization(self):
-        logger = self._registerLogger()
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        class IContext(Interface):
-            pass
-        from repoze.bfg.interfaces import IRequest
-        context = DummyContext()
-        directlyProvides(context, IContext)
-        self._registerTraverserFactory(context, subpath=[''])
-        response = DummyResponse()
-        view = DummyView(response)
-        environ = self._makeEnviron()
-        self._registerView(view, '', IContext, IRequest)
-        router = self._makeOne()
-        router.debug_authorization = True
-        start_response = DummyStartResponse()
-        result = router(environ, start_response)
-        self.assertEqual(start_response.status, '200 OK')
-        self.assertEqual(len(logger.messages), 1)
-        self.failUnless('no authentication policy' in logger.messages[0])
-
-    def test_call_view_no_permission_registered_debug_authorization(self):
-        self._registerAuthenticationPolicy()
-        logger = self._registerLogger()
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        class IContext(Interface):
-            pass
-        from repoze.bfg.interfaces import IRequest
-        context = DummyContext()
-        directlyProvides(context, IContext)
-        self._registerTraverserFactory(context, subpath=[''])
-        response = DummyResponse()
-        view = DummyView(response)
-        environ = self._makeEnviron()
-        self._registerView(view, '', IContext, IRequest)
-        router = self._makeOne()
-        router.debug_authorization = True
-        start_response = DummyStartResponse()
-        result = router(environ, start_response)
-        self.assertEqual(start_response.status, '200 OK')
-        self.assertEqual(len(logger.messages), 1)
-        self.failUnless('no permission registered' in logger.messages[0])
-
-    def test_call_view_no_permission_registered_no_debug(self):
-        self._registerAuthenticationPolicy()
-        logger = self._registerLogger()
+    def test_call_view_raises_unauthorized(self):
         from zope.interface import Interface
         from zope.interface import directlyProvides
         class IContext(Interface):
@@ -444,63 +334,16 @@ class RouterTests(unittest.TestCase):
         directlyProvides(context, IContext)
         self._registerTraverserFactory(context, subpath=[''])
         response = DummyResponse()
-        view = DummyView(response)
+        view = DummyView(response, raise_unauthorized=True)
         environ = self._makeEnviron()
         self._registerView(view, '', IContext, IRequest)
         router = self._makeOne()
-        router.debug_authorization = False
         start_response = DummyStartResponse()
-        result = router(environ, start_response)
-        self.assertEqual(start_response.status, '200 OK')
-        self.assertEqual(len(logger.messages), 0)
-
-    def test_call_view_permission_succeeds(self):
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        class IContext(Interface):
-            pass
-        from repoze.bfg.interfaces import IRequest
-        context = DummyContext()
-        directlyProvides(context, IContext)
-        self._registerTraverserFactory(context, subpath=[''])
-        self._registerAuthenticationPolicy()
-        response = DummyResponse()
-        view = DummyView(response)
-        environ = self._makeEnviron()
-        self._registerView(view, '', IContext, IRequest)
-        checker = self._registerViewPermission('', True)
-        router = self._makeOne()
-        start_response = DummyStartResponse()
-        result = router(environ, start_response)
-        self.assertEqual(start_response.status, '200 OK')
-        self.assertEqual(checker.context, context)
-
-    def test_call_view_permission_fails_nosettings(self):
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        class IContext(Interface):
-            pass
-        from repoze.bfg.interfaces import IRequest
-        context = DummyContext()
-        directlyProvides(context, IContext)
-        self._registerTraverserFactory(context, subpath=[''])
-        self._registerAuthenticationPolicy()
-        response = DummyResponse()
-        view = DummyView(response)
-        from repoze.bfg.security import ACLDenied
-        denied = ACLDenied('ace', 'acl', 'permission', ['principals'], context)
-        environ = self._makeEnviron()
-        self._registerView(view, '', IContext, IRequest)
-        checker = self._registerViewPermission('', denied)
-        router = self._makeOne()
-        start_response = DummyStartResponse()
-        result = router(environ, start_response)
+        response = router(environ, start_response)
         self.assertEqual(start_response.status, '401 Unauthorized')
-        message = environ['repoze.bfg.message']
-        self.assertEqual(message, 'Unauthorized: failed security policy check')
-        self.assertEqual(checker.context, context)
+        self.assertEqual(environ['repoze.bfg.message'], 'unauthorized')
 
-    def test_call_view_permission_fails_no_debug_auth(self):
+    def test_call_view_raises_notfound(self):
         from zope.interface import Interface
         from zope.interface import directlyProvides
         class IContext(Interface):
@@ -509,62 +352,15 @@ class RouterTests(unittest.TestCase):
         context = DummyContext()
         directlyProvides(context, IContext)
         self._registerTraverserFactory(context, subpath=[''])
-        self._registerAuthenticationPolicy()
         response = DummyResponse()
-        view = DummyView(response)
-        from repoze.bfg.security import ACLDenied
-        denied = ACLDenied('ace', 'acl', 'permission', ['principals'], context)
+        view = DummyView(response, raise_notfound=True)
         environ = self._makeEnviron()
         self._registerView(view, '', IContext, IRequest)
-        checker = self._registerViewPermission('', denied)
-        self._registerSettings(debug_authorization=False)
         router = self._makeOne()
         start_response = DummyStartResponse()
-        result = router(environ, start_response)
-        self.assertEqual(start_response.status, '401 Unauthorized')
-        message = environ['repoze.bfg.message']
-        self.failUnless('failed security policy check' in message)
-        self.assertEqual(checker.context, context)
-
-    def test_call_view_permission_fails_with_debug_auth(self):
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        class IContext(Interface):
-            pass
-        from repoze.bfg.interfaces import IRequest
-        context = DummyContext()
-        directlyProvides(context, IContext)
-        self._registerAuthenticationPolicy()
-        self._registerTraverserFactory(context, subpath=[''])
-        response = DummyResponse()
-        view = DummyView(response)
-        from repoze.bfg.security import ACLDenied
-        environ = self._makeEnviron()
-        self._registerView(view, '', IContext, IRequest)
-        allowed = ACLDenied('ace', 'acl', 'permission', ['principals'], context)
-        checker = self._registerViewPermission('', allowed)
-        self._registerSettings(debug_authorization=True)
-        logger = self._registerLogger()
-        router = self._makeOne()
-        start_response = DummyStartResponse()
-        result = router(environ, start_response)
-        self.assertEqual(start_response.status, '401 Unauthorized')
-        message = environ['repoze.bfg.message']
-        self.failUnless(
-            "ACLDenied permission 'permission' via ACE 'ace' in ACL 'acl' "
-            "on context" in message)
-        self.failUnless("for principals ['principals']" in message)
-        self.assertEqual(checker.context, context)
-        self.assertEqual(len(logger.messages), 1)
-        logged = logger.messages[0]
-        self.failUnless(
-            "debug_authorization of url http://localhost:8080/ (view name "
-            "'' against context" in logged)
-        self.failUnless(
-            "ACLDenied permission 'permission' via ACE 'ace' in ACL 'acl' on "
-            "context" in logged)
-        self.failUnless(
-            "for principals ['principals']" in logged)
+        response = router(environ, start_response)
+        self.assertEqual(start_response.status, '404 Not Found')
+        self.assertEqual(environ['repoze.bfg.message'], 'notfound')
 
     def test_call_eventsends(self):
         context = DummyContext()
@@ -601,65 +397,6 @@ class RouterTests(unittest.TestCase):
         self.assertEqual(len(router.threadlocal_manager.pushed), 1)
         self.assertEqual(len(router.threadlocal_manager.popped), 1)
 
-    def test_call_post_method(self):
-        from repoze.bfg.interfaces import INewRequest
-        from repoze.bfg.interfaces import IPOSTRequest
-        from repoze.bfg.interfaces import IPUTRequest
-        from repoze.bfg.interfaces import IRequest
-        context = DummyContext()
-        self._registerTraverserFactory(context)
-        response = DummyResponse()
-        response.app_iter = ['Hello world']
-        view = DummyView(response)
-        environ = self._makeEnviron(REQUEST_METHOD='POST')
-        self._registerView(view, '', None, None)
-        router = self._makeOne()
-        start_response = DummyStartResponse()
-        request_events = self._registerEventListener(INewRequest)
-        result = router(environ, start_response)
-        request = request_events[0].request
-        self.failUnless(IPOSTRequest.providedBy(request))
-        self.failIf(IPUTRequest.providedBy(request))
-        self.failUnless(IRequest.providedBy(request))
-
-    def test_call_put_method(self):
-        from repoze.bfg.interfaces import INewRequest
-        from repoze.bfg.interfaces import IPUTRequest
-        from repoze.bfg.interfaces import IPOSTRequest
-        from repoze.bfg.interfaces import IRequest
-        context = DummyContext()
-        self._registerTraverserFactory(context)
-        response = DummyResponse()
-        response.app_iter = ['Hello world']
-        view = DummyView(response)
-        environ = self._makeEnviron(REQUEST_METHOD='PUT')
-        self._registerView(view, '', None, None)
-        router = self._makeOne()
-        start_response = DummyStartResponse()
-        request_events = self._registerEventListener(INewRequest)
-        result = router(environ, start_response)
-        request = request_events[0].request
-        self.failUnless(IPUTRequest.providedBy(request))
-        self.failIf(IPOSTRequest.providedBy(request))
-        self.failUnless(IRequest.providedBy(request))
-
-    def test_call_unknown_method(self):
-        from repoze.bfg.interfaces import INewRequest
-        from repoze.bfg.interfaces import IRequest
-        context = DummyContext()
-        self._registerTraverserFactory(context)
-        response = DummyResponse()
-        response.app_iter = ['Hello world']
-        view = DummyView(response)
-        environ = self._makeEnviron(REQUEST_METHOD='UNKNOWN')
-        self._registerView(view, '', None, None)
-        router = self._makeOne()
-        start_response = DummyStartResponse()
-        request_events = self._registerEventListener(INewRequest)
-        result = router(environ, start_response)
-        request = request_events[0].request
-        self.failUnless(IRequest.providedBy(request))
-
 class MakeAppTests(unittest.TestCase):
     def setUp(self):
         cleanUp()
@@ -917,10 +654,19 @@ class DummyContext:
     pass
 
 class DummyView:
-    def __init__(self, response):
+    def __init__(self, response, raise_unauthorized=False,
+                 raise_notfound=False):
         self.response = response
+        self.raise_unauthorized = raise_unauthorized
+        self.raise_notfound = raise_notfound
 
     def __call__(self, context, request):
+        if self.raise_unauthorized:
+            from repoze.bfg.security import Unauthorized
+            raise Unauthorized('unauthorized')
+        if self.raise_notfound:
+            from repoze.bfg.view import NotFound
+            raise NotFound('notfound')
         return self.response
 
 class DummyRootFactory:
diff --git a/repoze/bfg/tests/test_security.py b/repoze/bfg/tests/test_security.py
index bb1a54e04..e06386fdb 100644
--- a/repoze/bfg/tests/test_security.py
+++ b/repoze/bfg/tests/test_security.py
@@ -27,29 +27,6 @@ class TestAllPermissionsList(unittest.TestCase):
         from repoze.bfg.security import ALL_PERMISSIONS
         self.assertEqual(ALL_PERMISSIONS.__class__, self._getTargetClass())
 
-class TestViewPermissionFactory(unittest.TestCase):
-    def setUp(self):
-        cleanUp()
-
-    def tearDown(self):
-        cleanUp()
-        
-    def _getTargetClass(self):
-        from repoze.bfg.security import ViewPermissionFactory
-        return ViewPermissionFactory
-    
-    def _makeOne(self, *arg, **kw):
-        klass = self._getTargetClass()
-        return klass(*arg, **kw)
-        
-    def test_call(self):
-        context = DummyContext()
-        request = DummyRequest({})
-        factory = self._makeOne('repoze.view')
-        self.assertEqual(factory.permission_name, 'repoze.view')
-        result = factory(context, request)
-        self.assertEqual(result, True)
-
 class TestAllowed(unittest.TestCase):
     def _getTargetClass(self):
         from repoze.bfg.security import Allowed
@@ -137,19 +114,19 @@ class TestViewExecutionPermitted(unittest.TestCase):
         from repoze.bfg.security import view_execution_permitted
         return view_execution_permitted(*arg, **kw)
 
-    def _registerViewPermission(self, view_name, allow=True):
+    def _registerSecuredView(self, view_name, allow=True):
         import zope.component
         from zope.interface import Interface
-        from repoze.bfg.interfaces import IViewPermission
+        from repoze.bfg.interfaces import ISecuredView
         class Checker(object):
-            def __call__(self, context, request):
+            def __permitted__(self, context, request):
                 self.context = context
                 self.request = request
                 return allow
         checker = Checker()
         gsm = zope.component.getGlobalSiteManager()
         gsm.registerAdapter(checker, (Interface, Interface),
-                            IViewPermission,
+                            ISecuredView,
                             view_name)
         return checker
 
@@ -175,7 +152,7 @@ class TestViewExecutionPermitted(unittest.TestCase):
             pass
         context = DummyContext()
         directlyProvides(context, IContext)
-        checker = self._registerViewPermission('', True)
+        checker = self._registerSecuredView('', True)
         request = DummyRequest({})
         directlyProvides(request, IRequest)
         result = self._callFUT(context, request, '')
diff --git a/repoze/bfg/tests/test_testing.py b/repoze/bfg/tests/test_testing.py
index 4ad3c83f6..e81a90219 100644
--- a/repoze/bfg/tests/test_testing.py
+++ b/repoze/bfg/tests/test_testing.py
@@ -4,9 +4,13 @@ import unittest
 class TestTestingFunctions(unittest.TestCase):
     def setUp(self):
         cleanUp()
+        from zope.deprecation import __show__
+        __show__.off()
 
     def tearDown(self):
         cleanUp()
+        from zope.deprecation import __show__
+        __show__.on()
 
     def test_registerDummySecurityPolicy(self):
         from repoze.bfg import testing
@@ -143,34 +147,78 @@ class TestTestingFunctions(unittest.TestCase):
         response = render_view_to_response(None, None, 'moo.html')
         self.assertEqual(response.body, '123')
 
-    def test_registerViewPermission_defaults(self):
+    def test_registerView_with_permission_denying(self):
+        from repoze.bfg import testing
+        from repoze.bfg.security import Unauthorized
+        def view(context, request):
+            """ """
+        view = testing.registerView('moo.html', view=view, permission='bar')
+        testing.registerDummySecurityPolicy(permissive=False)
+        import types
+        self.failUnless(isinstance(view, types.FunctionType))
+        from repoze.bfg.view import render_view_to_response
+        self.assertRaises(Unauthorized, render_view_to_response,
+                          None, None, 'moo.html')
+
+    def test_registerView_with_permission_denying2(self):
+        from repoze.bfg import testing
         from repoze.bfg.security import view_execution_permitted
+        def view(context, request):
+            """ """
+        view = testing.registerView('moo.html', view=view, permission='bar')
+        testing.registerDummySecurityPolicy(permissive=False)
+        import types
+        self.failUnless(isinstance(view, types.FunctionType))
+        result = view_execution_permitted(None, None, 'moo.html')
+        self.assertEqual(result, False)
+
+    def test_registerView_with_permission_allowing(self):
+        from repoze.bfg import testing
+        def view(context, request):
+            from webob import Response
+            return Response('123')
+        view = testing.registerView('moo.html', view=view, permission='bar')
+        testing.registerDummySecurityPolicy(permissive=True)
+        import types
+        self.failUnless(isinstance(view, types.FunctionType))
+        from repoze.bfg.view import render_view_to_response
+        result = render_view_to_response(None, None, 'moo.html')
+        self.assertEqual(result.app_iter, ['123'])
+
+    def test_registerViewPermission_defaults(self):
+        from zope.component import getSiteManager
+        from zope.interface import Interface
+        from repoze.bfg.interfaces import IViewPermission
         from repoze.bfg import testing
         view = testing.registerViewPermission('moo.html')
-        testing.registerDummySecurityPolicy()
-        result = view_execution_permitted(None, None, 'moo.html')
-        self.failUnless(result)
-        self.assertEqual(result.msg, 'message')
+        sm = getSiteManager()
+        result = sm.getMultiAdapter(
+            (Interface, Interface), IViewPermission, 'moo.html')
+        self.assertEqual(result, True)
         
     def test_registerViewPermission_denying(self):
-        from repoze.bfg.security import view_execution_permitted
+        from zope.component import getSiteManager
+        from zope.interface import Interface
+        from repoze.bfg.interfaces import IViewPermission
         from repoze.bfg import testing
         view = testing.registerViewPermission('moo.html', result=False)
-        testing.registerDummySecurityPolicy()
-        result = view_execution_permitted(None, None, 'moo.html')
-        self.failIf(result)
-        self.assertEqual(result.msg, 'message')
+        sm = getSiteManager()
+        result = sm.getMultiAdapter(
+            (Interface, Interface), IViewPermission, 'moo.html')
+        self.assertEqual(result, False)
 
     def test_registerViewPermission_custom(self):
-        from repoze.bfg.security import view_execution_permitted
+        from zope.component import getSiteManager
+        from zope.interface import Interface
+        from repoze.bfg.interfaces import IViewPermission
         def viewperm(context, request):
             return True
         from repoze.bfg import testing
-        view = testing.registerViewPermission('moo.html',
-                                              viewpermission=viewperm)
-        testing.registerDummySecurityPolicy()
-        result = view_execution_permitted(None, None, 'moo.html')
-        self.failUnless(result is True)
+        testing.registerViewPermission('moo.html', viewpermission=viewperm)
+        sm = getSiteManager()
+        result = sm.getMultiAdapter(
+            (Interface, Interface), IViewPermission, 'moo.html')
+        self.assertEqual(result, True)
 
     def test_registerAdapter(self):
         from zope.interface import implements
diff --git a/repoze/bfg/tests/test_view.py b/repoze/bfg/tests/test_view.py
index 3c7d6f853..f496ebb36 100644
--- a/repoze/bfg/tests/test_view.py
+++ b/repoze/bfg/tests/test_view.py
@@ -15,28 +15,6 @@ class BaseTest(object):
         from repoze.bfg.interfaces import IView
         gsm.registerAdapter(app, for_, IView, name)
 
-    def _registerViewPermission(self, view_name, allow=True):
-        import zope.component
-        from zope.interface import Interface
-        from repoze.bfg.interfaces import IViewPermission
-        class Checker(object):
-            def __call__(self, context, request):
-                self.context = context
-                self.request = request
-                return allow
-        checker = Checker()
-        gsm = zope.component.getGlobalSiteManager()
-        gsm.registerAdapter(checker, (Interface, Interface),
-                            IViewPermission,
-                            view_name)
-        return checker
-
-    def _registerSecurityPolicy(self, secpol):
-        import zope.component
-        gsm = zope.component.getGlobalSiteManager()
-        from repoze.bfg.interfaces import ISecurityPolicy
-        gsm.registerUtility(secpol, ISecurityPolicy)
-
     def _makeEnviron(self, **extras):
         environ = {
             'wsgi.url_scheme':'http',
@@ -61,7 +39,7 @@ class RenderViewToResponseTests(BaseTest, unittest.TestCase):
         result = self._callFUT(context, request, name='notregistered')
         self.assertEqual(result, None)
 
-    def test_call_view_registered_secure_permission_disallows(self):
+    def test_call_view_registered_secure(self):
         context = DummyContext()
         from zope.interface import Interface
         from zope.interface import directlyProvides
@@ -70,20 +48,18 @@ class RenderViewToResponseTests(BaseTest, unittest.TestCase):
             pass
         directlyProvides(context, IContext)
         response = DummyResponse()
-        secpol = DummySecurityPolicy()
         view = make_view(response)
         self._registerView(view, 'registered', IContext, IRequest)
-        self._registerSecurityPolicy(secpol)
-        self._registerViewPermission('registered', False)
         environ = self._makeEnviron()
         from webob import Request
         request = Request(environ)
         directlyProvides(request, IRequest)
-        from repoze.bfg.security import Unauthorized
-        self.assertRaises(Unauthorized, self._callFUT, context, request,
-                          name='registered', secure=True)
+        response = self._callFUT(context, request, name='registered',
+                                 secure=True)
+        self.assertEqual(response.status, '200 OK')
+
 
-    def test_call_view_registered_secure_permission_allows(self):
+    def test_call_view_registered_insecure_no_call_permissive(self):
         context = DummyContext()
         from zope.interface import Interface
         from zope.interface import directlyProvides
@@ -92,20 +68,17 @@ class RenderViewToResponseTests(BaseTest, unittest.TestCase):
             pass
         directlyProvides(context, IContext)
         response = DummyResponse()
-        secpol = DummySecurityPolicy()
         view = make_view(response)
         self._registerView(view, 'registered', IContext, IRequest)
-        self._registerSecurityPolicy(secpol)
-        self._registerViewPermission('registered', True)
         environ = self._makeEnviron()
         from webob import Request
         request = Request(environ)
         directlyProvides(request, IRequest)
         response = self._callFUT(context, request, name='registered',
-                                 secure=True)
+                                 secure=False)
         self.assertEqual(response.status, '200 OK')
 
-    def test_call_view_registered_insecure_permission_disallows(self):
+    def test_call_view_registered_insecure_with_call_permissive(self):
         context = DummyContext()
         from zope.interface import Interface
         from zope.interface import directlyProvides
@@ -114,11 +87,11 @@ class RenderViewToResponseTests(BaseTest, unittest.TestCase):
             pass
         directlyProvides(context, IContext)
         response = DummyResponse()
-        secpol = DummySecurityPolicy()
         view = make_view(response)
+        def anotherview(context, request):
+            return DummyResponse('anotherview')
+        view.__call_permissive__ = anotherview
         self._registerView(view, 'registered', IContext, IRequest)
-        self._registerSecurityPolicy(secpol)
-        self._registerViewPermission('registered', False)
         environ = self._makeEnviron()
         from webob import Request
         request = Request(environ)
@@ -126,6 +99,7 @@ class RenderViewToResponseTests(BaseTest, unittest.TestCase):
         response = self._callFUT(context, request, name='registered',
                                  secure=False)
         self.assertEqual(response.status, '200 OK')
+        self.assertEqual(response.app_iter, ['anotherview'])
 
 class RenderViewToIterableTests(BaseTest, unittest.TestCase):
     def _callFUT(self, *arg, **kw):
@@ -140,7 +114,7 @@ class RenderViewToIterableTests(BaseTest, unittest.TestCase):
         result = self._callFUT(context, request, name='notregistered')
         self.assertEqual(result, None)
 
-    def test_call_view_registered_secure_permission_disallows(self):
+    def test_call_view_registered_secure(self):
         context = DummyContext()
         from zope.interface import Interface
         from zope.interface import directlyProvides
@@ -149,20 +123,17 @@ class RenderViewToIterableTests(BaseTest, unittest.TestCase):
             pass
         directlyProvides(context, IContext)
         response = DummyResponse()
-        secpol = DummySecurityPolicy()
         view = make_view(response)
         self._registerView(view, 'registered', IContext, IRequest)
-        self._registerSecurityPolicy(secpol)
-        self._registerViewPermission('registered', False)
         environ = self._makeEnviron()
         from webob import Request
         request = Request(environ)
         directlyProvides(request, IRequest)
-        from repoze.bfg.security import Unauthorized
-        self.assertRaises(Unauthorized, self._callFUT, context, request,
-                          name='registered', secure=True)
+        iterable = self._callFUT(context, request, name='registered',
+                                 secure=True)
+        self.assertEqual(iterable, ())
 
-    def test_call_view_registered_secure_permission_allows(self):
+    def test_call_view_registered_insecure_no_call_permissive(self):
         context = DummyContext()
         from zope.interface import Interface
         from zope.interface import directlyProvides
@@ -171,20 +142,17 @@ class RenderViewToIterableTests(BaseTest, unittest.TestCase):
             pass
         directlyProvides(context, IContext)
         response = DummyResponse()
-        secpol = DummySecurityPolicy()
         view = make_view(response)
         self._registerView(view, 'registered', IContext, IRequest)
-        self._registerSecurityPolicy(secpol)
-        self._registerViewPermission('registered', True)
         environ = self._makeEnviron()
         from webob import Request
         request = Request(environ)
         directlyProvides(request, IRequest)
         iterable = self._callFUT(context, request, name='registered',
-                                 secure=True)
+                                 secure=False)
         self.assertEqual(iterable, ())
 
-    def test_call_view_registered_insecure_permission_disallows(self):
+    def test_call_view_registered_insecure_with_call_permissive(self):
         context = DummyContext()
         from zope.interface import Interface
         from zope.interface import directlyProvides
@@ -193,18 +161,18 @@ class RenderViewToIterableTests(BaseTest, unittest.TestCase):
             pass
         directlyProvides(context, IContext)
         response = DummyResponse()
-        secpol = DummySecurityPolicy()
         view = make_view(response)
+        def anotherview(context, request):
+            return DummyResponse('anotherview')
+        view.__call_permissive__ = anotherview
         self._registerView(view, 'registered', IContext, IRequest)
-        self._registerSecurityPolicy(secpol)
-        self._registerViewPermission('registered', False)
         environ = self._makeEnviron()
         from webob import Request
         request = Request(environ)
         directlyProvides(request, IRequest)
         iterable = self._callFUT(context, request, name='registered',
                                  secure=False)
-        self.assertEqual(iterable, ())
+        self.assertEqual(iterable, ['anotherview'])
 
 class RenderViewTests(unittest.TestCase, BaseTest):
     def _callFUT(self, *arg, **kw):
@@ -219,7 +187,7 @@ class RenderViewTests(unittest.TestCase, BaseTest):
         result = self._callFUT(context, request, name='notregistered')
         self.assertEqual(result, None)
 
-    def test_call_view_registered_secure_permission_disallows(self):
+    def test_call_view_registered_secure(self):
         context = DummyContext()
         from zope.interface import Interface
         from zope.interface import directlyProvides
@@ -228,20 +196,16 @@ class RenderViewTests(unittest.TestCase, BaseTest):
             pass
         directlyProvides(context, IContext)
         response = DummyResponse()
-        secpol = DummySecurityPolicy()
         view = make_view(response)
         self._registerView(view, 'registered', IContext, IRequest)
-        self._registerSecurityPolicy(secpol)
-        self._registerViewPermission('registered', False)
         environ = self._makeEnviron()
         from webob import Request
         request = Request(environ)
         directlyProvides(request, IRequest)
-        from repoze.bfg.security import Unauthorized
-        self.assertRaises(Unauthorized, self._callFUT, context, request,
-                          name='registered', secure=True)
+        s = self._callFUT(context, request, name='registered', secure=True)
+        self.assertEqual(s, '')
 
-    def test_call_view_registered_secure_permission_allows(self):
+    def test_call_view_registered_insecure_no_call_permissive(self):
         context = DummyContext()
         from zope.interface import Interface
         from zope.interface import directlyProvides
@@ -250,19 +214,16 @@ class RenderViewTests(unittest.TestCase, BaseTest):
             pass
         directlyProvides(context, IContext)
         response = DummyResponse()
-        secpol = DummySecurityPolicy()
         view = make_view(response)
         self._registerView(view, 'registered', IContext, IRequest)
-        self._registerSecurityPolicy(secpol)
-        self._registerViewPermission('registered', True)
         environ = self._makeEnviron()
         from webob import Request
         request = Request(environ)
         directlyProvides(request, IRequest)
-        s = self._callFUT(context, request, name='registered', secure=True)
+        s = self._callFUT(context, request, name='registered', secure=False)
         self.assertEqual(s, '')
 
-    def test_call_view_registered_insecure_permission_disallows(self):
+    def test_call_view_registered_insecure_with_call_permissive(self):
         context = DummyContext()
         from zope.interface import Interface
         from zope.interface import directlyProvides
@@ -271,17 +232,17 @@ class RenderViewTests(unittest.TestCase, BaseTest):
             pass
         directlyProvides(context, IContext)
         response = DummyResponse()
-        secpol = DummySecurityPolicy()
         view = make_view(response)
+        def anotherview(context, request):
+            return DummyResponse('anotherview')
+        view.__call_permissive__ = anotherview
         self._registerView(view, 'registered', IContext, IRequest)
-        self._registerSecurityPolicy(secpol)
-        self._registerViewPermission('registered', False)
         environ = self._makeEnviron()
         from webob import Request
         request = Request(environ)
         directlyProvides(request, IRequest)
         s = self._callFUT(context, request, name='registered', secure=False)
-        self.assertEqual(s, '')
+        self.assertEqual(s, 'anotherview')
 
 class TestIsResponse(unittest.TestCase):
     def _callFUT(self, *arg, **kw):
@@ -506,6 +467,461 @@ class TestDefaultNotFoundView(unittest.TestCase):
         self.assertEqual(response.status, '404 Not Found')
         self.failUnless('<code>abc&amp;123</code>' in response.body)
 
+class TestMultiView(unittest.TestCase):
+    def _getTargetClass(self):
+        from repoze.bfg.view import MultiView
+        return MultiView
+
+    def _makeOne(self, name='name'):
+        return self._getTargetClass()(name)
+    
+    def test_class_implements_ISecuredView(self):
+        from zope.interface.verify import verifyClass
+        from repoze.bfg.interfaces import ISecuredView
+        verifyClass(ISecuredView, self._getTargetClass())
+
+    def test_instance_implements_ISecuredView(self):
+        from zope.interface.verify import verifyObject
+        from repoze.bfg.interfaces import ISecuredView
+        verifyObject(ISecuredView, self._makeOne())
+
+    def test_add(self):
+        mv = self._makeOne()
+        mv.add('view', 100)
+        self.assertEqual(mv.views, [(100, 'view')])
+        mv.add('view2', 99)
+        self.assertEqual(mv.views, [(99, 'view2'), (100, 'view')])
+
+    def test_match_not_found(self):
+        from repoze.bfg.view import NotFound
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        self.assertRaises(NotFound, mv.match, context, request)
+
+    def test_match_predicate_fails(self):
+        from repoze.bfg.view import NotFound
+        mv = self._makeOne()
+        def view(context, request):
+            """ """
+        view.__predicated__ = lambda *arg: False
+        mv.views = [(100, view)]
+        context = DummyContext()
+        request = DummyRequest()
+        self.assertRaises(NotFound, mv.match, context, request)
+
+    def test_match_predicate_succeeds(self):
+        mv = self._makeOne()
+        def view(context, request):
+            """ """
+        view.__predicated__ = lambda *arg: True
+        mv.views = [(100, view)]
+        context = DummyContext()
+        request = DummyRequest()
+        result = mv.match(context, request)
+        self.assertEqual(result, view)
+
+    def test_permitted_no_views(self):
+        from repoze.bfg.view import NotFound
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        self.assertRaises(NotFound, mv.__permitted__, context, request)
+
+    def test_permitted_no_match_with__permitted__(self):
+        mv = self._makeOne()
+        def view(context, request):
+            """ """
+        mv.views = [(100, view)]
+        context = DummyContext()
+        request = DummyRequest()
+        self.assertEqual(mv.__permitted__(None, None), True)
+        
+    def test_permitted(self):
+        from zope.component import getSiteManager
+        mv = self._makeOne()
+        def view(context, request):
+            """ """
+        def permitted(context, request):
+            return False
+        view.__permitted__ = permitted
+        mv.views = [(100, view)]
+        context = DummyContext()
+        request = DummyRequest()
+        sm = getSiteManager()
+        result = mv.__permitted__(context, request)
+        self.assertEqual(result, False)
+
+    def test__call__not_found(self):
+        from repoze.bfg.view import NotFound
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        self.assertRaises(NotFound, mv, context, request)
+
+    def test___call__intermediate_not_found(self):
+        from repoze.bfg.view import NotFound
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        request.view_name = ''
+        expected_response = DummyResponse()
+        def view1(context, request):
+            raise NotFound
+        def view2(context, request):
+            return expected_response
+        mv.views = [(100, view1), (99, view2)]
+        response = mv(context, request)
+        self.assertEqual(response, expected_response)
+
+    def test___call__(self):
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        request.view_name = ''
+        expected_response = DummyResponse()
+        def view(context, request):
+            return expected_response
+        mv.views = [(100, view)]
+        response = mv(context, request)
+        self.assertEqual(response, expected_response)
+
+    def test__call_permissive__not_found(self):
+        from repoze.bfg.view import NotFound
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        self.assertRaises(NotFound, mv, context, request)
+
+    def test___call_permissive_has_call_permissive(self):
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        request.view_name = ''
+        expected_response = DummyResponse()
+        def view(context, request):
+            """ """
+        def permissive(context, request):
+            return expected_response
+        view.__call_permissive__ = permissive
+        mv.views = [(100, view)]
+        response = mv.__call_permissive__(context, request)
+        self.assertEqual(response, expected_response)
+
+    def test___call_permissive_has_no_call_permissive(self):
+        mv = self._makeOne()
+        context = DummyContext()
+        request = DummyRequest()
+        request.view_name = ''
+        expected_response = DummyResponse()
+        def view(context, request):
+            return expected_response
+        mv.views = [(100, view)]
+        response = mv.__call_permissive__(context, request)
+        self.assertEqual(response, expected_response)
+
+class TestMapView(unittest.TestCase):
+    def setUp(self):
+        cleanUp()
+
+    def tearDown(self):
+        cleanUp()
+        
+    def _callFUT(self, view, *arg, **kw):
+        from repoze.bfg.view import map_view
+        return map_view(view, *arg, **kw)
+
+    def test_view_as_function_context_and_request(self):
+        def view(context, request):
+            return 'OK'
+        result = self._callFUT(view)
+        self.failUnless(result is view)
+        self.assertEqual(view(None, None), 'OK')
+        
+    def test_view_as_function_requestonly(self):
+        def view(request):
+            return 'OK'
+        result = self._callFUT(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_view_as_newstyle_class_context_and_request(self):
+        class view(object):
+            def __init__(self, context, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = self._callFUT(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_view_as_newstyle_class_requestonly(self):
+        class view(object):
+            def __init__(self, context, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = self._callFUT(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_view_as_oldstyle_class_context_and_request(self):
+        class view:
+            def __init__(self, context, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = self._callFUT(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_view_as_oldstyle_class_requestonly(self):
+        class view:
+            def __init__(self, context, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = self._callFUT(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_view_as_instance_context_and_request(self):
+        class View:
+            def __call__(self, context, request):
+                return 'OK'
+        view = View()
+        result = self._callFUT(view)
+        self.failUnless(result is view)
+        self.assertEqual(result(None, None), 'OK')
+        
+    def test_view_as_instance_requestonly(self):
+        class View:
+            def __call__(self, request):
+                return 'OK'
+        view = View()
+        result = self._callFUT(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')
+
+class TestRequestOnly(unittest.TestCase):
+    def _callFUT(self, arg):
+        from repoze.bfg.view import requestonly
+        return requestonly(arg)
+    
+    def test_newstyle_class_no_init(self):
+        class foo(object):
+            """ """
+        self.assertFalse(self._callFUT(foo))
+
+    def test_newstyle_class_init_toomanyargs(self):
+        class foo(object):
+            def __init__(self, context, request):
+                """ """
+        self.assertFalse(self._callFUT(foo))
+        
+    def test_newstyle_class_init_onearg_named_request(self):
+        class foo(object):
+            def __init__(self, request):
+                """ """
+        self.assertTrue(self._callFUT(foo))
+
+    def test_newstyle_class_init_onearg_named_somethingelse(self):
+        class foo(object):
+            def __init__(self, req):
+                """ """
+        self.assertTrue(self._callFUT(foo))
+
+    def test_newstyle_class_init_defaultargs_firstname_not_request(self):
+        class foo(object):
+            def __init__(self, context, request=None):
+                """ """
+        self.assertFalse(self._callFUT(foo))
+
+    def test_newstyle_class_init_defaultargs_firstname_request(self):
+        class foo(object):
+            def __init__(self, request, foo=1, bar=2):
+                """ """
+        self.assertTrue(self._callFUT(foo))
+
+    def test_newstyle_class_init_noargs(self):
+        class foo(object):
+            def __init__():
+                """ """
+        self.assertFalse(self._callFUT(foo))
+
+    def test_oldstyle_class_no_init(self):
+        class foo:
+            """ """
+        self.assertFalse(self._callFUT(foo))
+
+    def test_oldstyle_class_init_toomanyargs(self):
+        class foo:
+            def __init__(self, context, request):
+                """ """
+        self.assertFalse(self._callFUT(foo))
+        
+    def test_oldstyle_class_init_onearg_named_request(self):
+        class foo:
+            def __init__(self, request):
+                """ """
+        self.assertTrue(self._callFUT(foo))
+
+    def test_oldstyle_class_init_onearg_named_somethingelse(self):
+        class foo:
+            def __init__(self, req):
+                """ """
+        self.assertTrue(self._callFUT(foo))
+
+    def test_oldstyle_class_init_defaultargs_firstname_not_request(self):
+        class foo:
+            def __init__(self, context, request=None):
+                """ """
+        self.assertFalse(self._callFUT(foo))
+
+    def test_oldstyle_class_init_defaultargs_firstname_request(self):
+        class foo:
+            def __init__(self, request, foo=1, bar=2):
+                """ """
+        self.assertTrue(self._callFUT(foo), True)
+
+    def test_oldstyle_class_init_noargs(self):
+        class foo:
+            def __init__():
+                """ """
+        self.assertFalse(self._callFUT(foo))
+
+    def test_function_toomanyargs(self):
+        def foo(context, request):
+            """ """
+        self.assertFalse(self._callFUT(foo))
+        
+    def test_function_onearg_named_request(self):
+        def foo(request):
+            """ """
+        self.assertTrue(self._callFUT(foo))
+
+    def test_function_onearg_named_somethingelse(self):
+        def foo(req):
+            """ """
+        self.assertTrue(self._callFUT(foo))
+
+    def test_function_defaultargs_firstname_not_request(self):
+        def foo(context, request=None):
+            """ """
+        self.assertFalse(self._callFUT(foo))
+
+    def test_function_defaultargs_firstname_request(self):
+        def foo(request, foo=1, bar=2):
+            """ """
+        self.assertTrue(self._callFUT(foo), True)
+
+    def test_instance_toomanyargs(self):
+        class Foo:
+            def __call__(self, context, request):
+                """ """
+        foo = Foo()
+        self.assertFalse(self._callFUT(foo))
+        
+    def test_instance_defaultargs_onearg_named_request(self):
+        class Foo:
+            def __call__(self, request):
+                """ """
+        foo = Foo()
+        self.assertTrue(self._callFUT(foo))
+
+    def test_instance_defaultargs_onearg_named_somethingelse(self):
+        class Foo:
+            def __call__(self, req):
+                """ """
+        foo = Foo()
+        self.assertTrue(self._callFUT(foo))
+
+    def test_instance_defaultargs_firstname_not_request(self):
+        class Foo:
+            def __call__(self, context, request=None):
+                """ """
+        foo = Foo()
+        self.assertFalse(self._callFUT(foo))
+
+    def test_instance_defaultargs_firstname_request(self):
+        class Foo:
+            def __call__(self, request, foo=1, bar=2):
+                """ """
+        foo = Foo()
+        self.assertTrue(self._callFUT(foo), True)
+
+    def test_instance_nocall(self):
+        class Foo: pass
+        foo = Foo()
+        self.assertFalse(self._callFUT(foo))
+
+class TestDecorateView(unittest.TestCase):
+    def _callFUT(self, wrapped, original):
+        from repoze.bfg.view import decorate_view
+        return decorate_view(wrapped, original)
+    
+    def test_it_same(self):
+        def view(context, request):
+            """ """
+        result = self._callFUT(view, view)
+        self.assertEqual(result, False)
+
+    def test_it_different(self):
+        class DummyView1:
+            """ 1 """
+            __name__ = '1'
+            __module__ = '1'
+            def __call__(self, context, request):
+                """ """
+            def __call_permissive__(self, context, reuqest):
+                """ """
+            def __predicated__(self, context, reuqest):
+                """ """
+            def __permitted__(self, context, request):
+                """ """
+        class DummyView2:
+            """ 2 """
+            __name__ = '2'
+            __module__ = '2'
+            def __call__(self, context, request):
+                """ """
+            def __call_permissive__(self, context, reuqest):
+                """ """
+            def __predicated__(self, context, reuqest):
+                """ """
+            def __permitted__(self, context, request):
+                """ """
+        view1 = DummyView1()
+        view2 = DummyView2()
+        result = self._callFUT(view1, view2)
+        self.assertEqual(result, True)
+        self.failUnless(view1.__doc__ is view2.__doc__)
+        self.failUnless(view1.__module__ is view2.__module__)
+        self.failUnless(view1.__name__ is view2.__name__)
+        self.failUnless(view1.__call_permissive__.im_func is
+                        view2.__call_permissive__.im_func)
+        self.failUnless(view1.__permitted__.im_func is
+                        view2.__permitted__.im_func)
+        self.failUnless(view1.__predicated__.im_func is
+                        view2.__predicated__.im_func)
 
 class DummyContext:
     pass
@@ -531,8 +947,9 @@ def make_view(response):
 class DummyResponse:
     status = '200 OK'
     headerlist = ()
-    app_iter = ()
-    
-class DummySecurityPolicy:
-    pass
-
+    def __init__(self, body=None):
+        if body is None:
+            self.app_iter = ()
+        else:
+            self.app_iter = [body]
+            
diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index 49baa3a34..fdf8fa9e3 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -20,185 +20,144 @@ class TestViewDirective(unittest.TestCase):
                           '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:
+        class IFoo(Interface):
             pass
         view = lambda *arg: None
         self._callFUT(context, 'repoze.view', IFoo, view=view)
         actions = context.actions
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-        from repoze.bfg.security import ViewPermissionFactory
-        from repoze.bfg.zcml import handler
 
-        self.assertEqual(len(actions), 2)
+        self.assertEqual(len(actions), 1)
 
-        permission = actions[0]
-        permission_discriminator = ('permission', IFoo, '', IRequest,
-                                    IViewPermission)
-        self.assertEqual(permission['discriminator'], permission_discriminator)
-        self.assertEqual(permission['callable'], handler)
-        self.assertEqual(permission['args'][0], 'registerAdapter')
-        self.failUnless(isinstance(permission['args'][1],ViewPermissionFactory))
-        self.assertEqual(permission['args'][1].permission_name, 'repoze.view')
-        self.assertEqual(permission['args'][2], (IFoo, IRequest))
-        self.assertEqual(permission['args'][3], IViewPermission)
-        self.assertEqual(permission['args'][4], '')
-        self.assertEqual(permission['args'][5], None)
-        
-        regadapt = actions[1]
-        regadapt_discriminator = ('view', IFoo, '', IRequest, IView)
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerAdapter')
-        self.assertEqual(regadapt['args'][1], view)
-        self.assertEqual(regadapt['args'][2], (IFoo, IRequest))
-        self.assertEqual(regadapt['args'][3], IView)
-        self.assertEqual(regadapt['args'][4], '')
-        self.assertEqual(regadapt['args'][5], None)
+        action = actions[0]
+        discrim = ('view', IFoo, '', IRequest, IView, None, 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:
+        class IFoo(Interface):
             pass
         
         self._callFUT(context, 'repoze.view', IFoo, view=view)
         actions = context.actions
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-        from repoze.bfg.security import ViewPermissionFactory
-        from repoze.bfg.zcml import handler
-
-        self.assertEqual(len(actions), 2)
+        self.assertEqual(len(actions), 1)
 
-        permission = actions[0]
-        permission_discriminator = ('permission', IFoo, '', IRequest,
-                                    IViewPermission)
-        self.assertEqual(permission['discriminator'], permission_discriminator)
-        self.assertEqual(permission['callable'], handler)
-        self.assertEqual(permission['args'][0], 'registerAdapter')
-        self.failUnless(isinstance(permission['args'][1],ViewPermissionFactory))
-        self.assertEqual(permission['args'][1].permission_name, 'repoze.view')
-        self.assertEqual(permission['args'][2], (IFoo, IRequest))
-        self.assertEqual(permission['args'][3], IViewPermission)
-        self.assertEqual(permission['args'][4], '')
-        self.assertEqual(permission['args'][5], None)
-        
-        regadapt = actions[1]
-        regadapt_discriminator = ('view', IFoo, '', IRequest, IView)
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerAdapter')
-        wrapper = regadapt['args'][1]
+        action = actions[0]
+        discrim = ('view', IFoo, '', IRequest, IView, None, 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.assertEqual(regadapt['args'][2], (IFoo, IRequest))
-        self.assertEqual(regadapt['args'][3], IView)
-        self.assertEqual(regadapt['args'][4], '')
-        self.assertEqual(regadapt['args'][5], None)
+        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:
+        class IFoo(Interface):
             pass
         self._callFUT(context, 'repoze.view', IFoo, view=view)
         actions = context.actions
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-        from repoze.bfg.security import ViewPermissionFactory
-        from repoze.bfg.zcml import handler
+        self.assertEqual(len(actions), 1)
 
-        self.assertEqual(len(actions), 2)
+        action = actions[0]
+        discrim = ('view', IFoo, '', IRequest, IView, None, 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__'))
 
-        permission = actions[0]
-        permission_discriminator = ('permission', IFoo, '', IRequest,
-                                    IViewPermission)
-        self.assertEqual(permission['discriminator'], permission_discriminator)
-        self.assertEqual(permission['callable'], handler)
-        self.assertEqual(permission['args'][0], 'registerAdapter')
-        self.failUnless(isinstance(permission['args'][1],ViewPermissionFactory))
-        self.assertEqual(permission['args'][1].permission_name, 'repoze.view')
-        self.assertEqual(permission['args'][2], (IFoo, IRequest))
-        self.assertEqual(permission['args'][3], IViewPermission)
-        self.assertEqual(permission['args'][4], '')
-        self.assertEqual(permission['args'][5], None)
-        
-        regadapt = actions[1]
-        regadapt_discriminator = ('view', IFoo, '', IRequest, IView)
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerAdapter')
-        self.assertEqual(regadapt['args'][1], view)
-        self.assertEqual(regadapt['args'][2], (IFoo, IRequest))
-        self.assertEqual(regadapt['args'][3], IView)
-        self.assertEqual(regadapt['args'][4], '')
-        self.assertEqual(regadapt['args'][5], None)
+        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:
+        class IFoo(Interface):
             pass
         self._callFUT(context, 'repoze.view', IFoo, view=view)
         actions = context.actions
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-        from repoze.bfg.security import ViewPermissionFactory
-        from repoze.bfg.zcml import handler
-
-        self.assertEqual(len(actions), 2)
+        self.assertEqual(len(actions), 1)
 
-        permission = actions[0]
-        permission_discriminator = ('permission', IFoo, '', IRequest,
-                                    IViewPermission)
-        self.assertEqual(permission['discriminator'], permission_discriminator)
-        self.assertEqual(permission['callable'], handler)
-        self.assertEqual(permission['args'][0], 'registerAdapter')
-        self.failUnless(isinstance(permission['args'][1],ViewPermissionFactory))
-        self.assertEqual(permission['args'][1].permission_name, 'repoze.view')
-        self.assertEqual(permission['args'][2], (IFoo, IRequest))
-        self.assertEqual(permission['args'][3], IViewPermission)
-        self.assertEqual(permission['args'][4], '')
-        self.assertEqual(permission['args'][5], None)
-        
-        regadapt = actions[1]
-        regadapt_discriminator = ('view', IFoo, '', IRequest, IView)
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerAdapter')
-        wrapper = regadapt['args'][1]
+        action = actions[0]
+        discrim = ('view', IFoo, '', IRequest, IView, None, 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.assertEqual(regadapt['args'][2], (IFoo, IRequest))
-        self.assertEqual(regadapt['args'][3], IView)
-        self.assertEqual(regadapt['args'][4], '')
-        self.assertEqual(regadapt['args'][5], 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(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:
+        class IFoo(Interface):
             pass
         class view:
             def __init__(self, context, request):
@@ -209,47 +168,36 @@ class TestViewDirective(unittest.TestCase):
                 return self
         self._callFUT(context, 'repoze.view', IFoo, view=view)
         actions = context.actions
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-        from repoze.bfg.security import ViewPermissionFactory
-        from repoze.bfg.zcml import handler
 
-        self.assertEqual(len(actions), 2)
+        self.assertEqual(len(actions), 1)
 
-        permission = actions[0]
-        permission_discriminator = ('permission', IFoo, '', IRequest,
-                                    IViewPermission)
-        self.assertEqual(permission['discriminator'], permission_discriminator)
-        self.assertEqual(permission['callable'], handler)
-        self.assertEqual(permission['args'][0], 'registerAdapter')
-        self.failUnless(isinstance(permission['args'][1],ViewPermissionFactory))
-        self.assertEqual(permission['args'][1].permission_name, 'repoze.view')
-        self.assertEqual(permission['args'][2], (IFoo, IRequest))
-        self.assertEqual(permission['args'][3], IViewPermission)
-        self.assertEqual(permission['args'][4], '')
-        self.assertEqual(permission['args'][5], None)
-        
-        regadapt = actions[1]
-        regadapt_discriminator = ('view', IFoo, '', IRequest, IView)
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerAdapter')
-        wrapper = regadapt['args'][1]
+        action = actions[0]
+        discrim = ('view', IFoo, '', IRequest, IView, None, 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.assertEqual(regadapt['args'][2], (IFoo, IRequest))
-        self.assertEqual(regadapt['args'][3], IView)
-        self.assertEqual(regadapt['args'][4], '')
-        self.assertEqual(regadapt['args'][5], 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:
+        class IFoo(Interface):
             pass
         class view:
             def __init__(self, request):
@@ -259,46 +207,35 @@ class TestViewDirective(unittest.TestCase):
                 return self
         self._callFUT(context, 'repoze.view', IFoo, view=view)
         actions = context.actions
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-        from repoze.bfg.security import ViewPermissionFactory
-        from repoze.bfg.zcml import handler
-
-        self.assertEqual(len(actions), 2)
+        self.assertEqual(len(actions), 1)
 
-        permission = actions[0]
-        permission_discriminator = ('permission', IFoo, '', IRequest,
-                                    IViewPermission)
-        self.assertEqual(permission['discriminator'], permission_discriminator)
-        self.assertEqual(permission['callable'], handler)
-        self.assertEqual(permission['args'][0], 'registerAdapter')
-        self.failUnless(isinstance(permission['args'][1],ViewPermissionFactory))
-        self.assertEqual(permission['args'][1].permission_name, 'repoze.view')
-        self.assertEqual(permission['args'][2], (IFoo, IRequest))
-        self.assertEqual(permission['args'][3], IViewPermission)
-        self.assertEqual(permission['args'][4], '')
-        self.assertEqual(permission['args'][5], None)
-        
-        regadapt = actions[1]
-        regadapt_discriminator = ('view', IFoo, '', IRequest, IView)
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerAdapter')
-        wrapper = regadapt['args'][1]
+        action = actions[0]
+        discrim = ('view', IFoo, '', IRequest, IView, None, 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.assertEqual(regadapt['args'][2], (IFoo, IRequest))
-        self.assertEqual(regadapt['args'][3], IView)
-        self.assertEqual(regadapt['args'][4], '')
-        self.assertEqual(regadapt['args'][5], 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:
+        class IFoo(Interface):
             pass
         class view(object):
             def __init__(self, context, request):
@@ -309,47 +246,35 @@ class TestViewDirective(unittest.TestCase):
                 return self
         self._callFUT(context, 'repoze.view', IFoo, view=view)
         actions = context.actions
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-        from repoze.bfg.security import ViewPermissionFactory
-        from repoze.bfg.zcml import handler
-
-        self.assertEqual(len(actions), 2)
+        self.assertEqual(len(actions), 1)
 
-        permission = actions[0]
-        permission_discriminator = ('permission', IFoo, '', IRequest,
-                                    IViewPermission)
-        self.assertEqual(permission['discriminator'], permission_discriminator)
-        self.assertEqual(permission['callable'], handler)
-        self.assertEqual(permission['args'][0], 'registerAdapter')
-        self.failUnless(isinstance(permission['args'][1],ViewPermissionFactory))
-        self.assertEqual(permission['args'][1].permission_name, 'repoze.view')
-        self.assertEqual(permission['args'][2], (IFoo, IRequest))
-        self.assertEqual(permission['args'][3], IViewPermission)
-        self.assertEqual(permission['args'][4], '')
-        self.assertEqual(permission['args'][5], None)
-        
-        regadapt = actions[1]
-        regadapt_discriminator = ('view', IFoo, '', IRequest, IView)
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerAdapter')
-        wrapper = regadapt['args'][1]
+        action = actions[0]
+        discrim = ('view', IFoo, '', IRequest, IView, None, 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.assertEqual(regadapt['args'][2], (IFoo, IRequest))
-        self.assertEqual(regadapt['args'][3], IView)
-        self.assertEqual(regadapt['args'][4], '')
-        self.assertEqual(regadapt['args'][5], 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:
+        class IFoo(Interface):
             pass
         class view(object):
             def __init__(self, request):
@@ -359,170 +284,470 @@ class TestViewDirective(unittest.TestCase):
                 return self
         self._callFUT(context, 'repoze.view', IFoo, view=view)
         actions = context.actions
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IViewPermission
-        from repoze.bfg.security import ViewPermissionFactory
-        from repoze.bfg.zcml import handler
-
-        self.assertEqual(len(actions), 2)
+        self.assertEqual(len(actions), 1)
 
-        permission = actions[0]
-        permission_discriminator = ('permission', IFoo, '', IRequest,
-                                    IViewPermission)
-        self.assertEqual(permission['discriminator'], permission_discriminator)
-        self.assertEqual(permission['callable'], handler)
-        self.assertEqual(permission['args'][0], 'registerAdapter')
-        self.failUnless(isinstance(permission['args'][1],ViewPermissionFactory))
-        self.assertEqual(permission['args'][1].permission_name, 'repoze.view')
-        self.assertEqual(permission['args'][2], (IFoo, IRequest))
-        self.assertEqual(permission['args'][3], IViewPermission)
-        self.assertEqual(permission['args'][4], '')
-        self.assertEqual(permission['args'][5], None)
-        
-        regadapt = actions[1]
-        regadapt_discriminator = ('view', IFoo, '', IRequest, IView)
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerAdapter')
-        wrapper = regadapt['args'][1]
+        action = actions[0]
+        discrim = ('view', IFoo, '', IRequest, IView, None, 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.assertEqual(regadapt['args'][2], (IFoo, IRequest))
-        self.assertEqual(regadapt['args'][3], IView)
-        self.assertEqual(regadapt['args'][4], '')
-        self.assertEqual(regadapt['args'][5], None)
+        self.failIf(hasattr(wrapper, '__call_permissive__'))
+
+        perm = sm.adapters.lookup((IFoo, IRequest), IViewPermission, name='')
+        self.assertEqual(perm, None)
+
 
     def test_request_type_asinterface(self):
-        context = DummyContext()
-        class IFoo:
+        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)
+        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
-        from repoze.bfg.interfaces import IViewPermission
-        from repoze.bfg.security import ViewPermissionFactory
-        from repoze.bfg.zcml import handler
+        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), 2)
+        self.assertEqual(len(actions), 1)
 
-        permission = actions[0]
-        permission_discriminator = ('permission', IFoo, '', DummyModule,
-                                    IViewPermission)
-        self.assertEqual(permission['discriminator'], permission_discriminator)
-        self.assertEqual(permission['callable'], handler)
-        self.assertEqual(permission['args'][0], 'registerAdapter')
-        self.failUnless(isinstance(permission['args'][1],ViewPermissionFactory))
-        self.assertEqual(permission['args'][1].permission_name, 'repoze.view')
-        self.assertEqual(permission['args'][2], (IFoo, DummyModule))
-        self.assertEqual(permission['args'][3], IViewPermission)
-        self.assertEqual(permission['args'][4], '')
-        self.assertEqual(permission['args'][5], None)
-        
-        regadapt = actions[1]
-        regadapt_discriminator = ('view', IFoo, '', DummyModule, IView)
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerAdapter')
-        self.assertEqual(regadapt['args'][1], view)
-        self.assertEqual(regadapt['args'][2], (IFoo, DummyModule))
-        self.assertEqual(regadapt['args'][3], IView)
-        self.assertEqual(regadapt['args'][4], '')
-        self.assertEqual(regadapt['args'][5], None)
+        action = actions[0]
+        discrim = ('view', IFoo, '', Dummy, IView, None, 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
+        from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import IRequest
         context = DummyContext()
-        class IFoo:
+        class IFoo(Interface):
             pass
         view = lambda *arg: None
         self._callFUT(context, 'repoze.view', IFoo, view=view,
                       request_type='GET')
         actions = context.actions
-        from repoze.bfg.interfaces import IView
-        from repoze.bfg.interfaces import IGETRequest
 
-        self.assertEqual(len(actions), 2)
+        self.assertEqual(len(actions), 1)
 
-        permission = actions[0]
-        self.assertEqual(permission['args'][2], (IFoo, IGETRequest))
-        regadapt = actions[1]
-        regadapt_discriminator = ('view', IFoo, '', IDummy, IView)
-        self.assertEqual(regadapt['args'][2], (IFoo, IGETRequest))
+        action = actions[0]
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, 'GET', None)
+        self.assertEqual(action['discriminator'], discrim)
+        register = action['callable']
+        register()
+        sm = getSiteManager()
+        wrapper = sm.adapters.lookup((IFoo, IRequest), IView, name='')
+        request = DummyRequest()
+        request.method = 'GET'
+        self.assertEqual(wrapper.__predicated__(None, request), True)
+        request.method = 'POST'
+        self.assertEqual(wrapper.__predicated__(None, request), False)
+        
 
     def test_request_type_asinterfacestring(self):
-        context = DummyContext()
-        class IFoo:
+        from zope.component import getSiteManager
+        from zope.interface import Interface
+        from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import IViewPermission
+        class IFoo(Interface):
+            pass
+        class IRequest(Interface):
             pass
+        context = DummyContext(IRequest)
         view = lambda *arg: None
         self._callFUT(context, 'repoze.view', IFoo, view=view,
                       request_type='whatever')
         actions = context.actions
-        from repoze.bfg.interfaces import IView
-        self.assertEqual(len(actions), 2)
+        self.assertEqual(len(actions), 1)
 
-        permission = actions[0]
-        self.assertEqual(permission['args'][2], (IFoo, DummyModule))
-        regadapt = actions[1]
-        regadapt_discriminator = ('view', IFoo, '', DummyModule, IView)
-        self.assertEqual(regadapt['args'][2], (IFoo, DummyModule))
+        discrim = ('view', IFoo, '', IRequest, IView, None, None, None, None)
+        self.assertEqual(actions[0]['discriminator'], discrim)
+        register = actions[0]['callable']
+        register()
+        sm = getSiteManager()
+        regview = sm.adapters.lookup((IFoo, IRequest), IView, name='')
+        self.assertEqual(view, regview)
+        self.failIf(hasattr(view, '__call_permissive__'))
+
+        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.interface import implementedBy
+        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() 
+        factory = sm.getUtility(IRouteRequest, 'foo')
+        request_type = implementedBy(factory)
+        discrim = ('view', IFoo, '', request_type, IView, None, None, None,
+                   'foo')
+        self.assertEqual(action['discriminator'], discrim)
+        the_view = sm.adapters.lookup((IFoo, request_type), IView, name='')
+        request = factory({})
+        self.assertEqual(the_view(None, request), '123')
+
+    def test_with_request_method_true(self):
         from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IRequestFactories
-        class IFoo:
+        from zope.interface import Interface
+        from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.interfaces import IView
+        context = DummyContext()
+        class IFoo(Interface):
             pass
-        class IDummyRequest:
+        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)
+        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.view 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)
+        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()
-        factories = {None:{'interface':IDummyRequest}}
+        class IFoo(Interface):
+            pass
+        view = lambda *arg: None
         sm = getSiteManager()
-        sm.registerUtility(factories, IRequestFactories, name='foo')
+        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)
+        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.view import NotFound
+        context = DummyContext()
+        class IFoo(Interface):
+            pass
         view = lambda *arg: None
-        self._callFUT(context, 'repoze.view', IFoo, view=view, route_name='foo')
+        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)
+        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_paramoval_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', 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.view 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', 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_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)
+        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.view 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)
+        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_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
-        from repoze.bfg.security import ViewPermissionFactory
-        from repoze.bfg.zcml import handler
-
-        self.assertEqual(len(actions), 2)
-
-        permission = actions[0]
-        permission_discriminator = ('permission', IFoo, '', IDummyRequest,
-                                    IViewPermission)
-        self.assertEqual(permission['discriminator'], permission_discriminator)
-        self.assertEqual(permission['callable'], handler)
-        self.assertEqual(permission['args'][0], 'registerAdapter')
-        self.failUnless(isinstance(permission['args'][1],ViewPermissionFactory))
-        self.assertEqual(permission['args'][1].permission_name, 'repoze.view')
-        self.assertEqual(permission['args'][2], (IFoo, IDummyRequest))
-        self.assertEqual(permission['args'][3], IViewPermission)
-        self.assertEqual(permission['args'][4], '')
-        self.assertEqual(permission['args'][5], None)
-        
-        regadapt = actions[1]
-        regadapt_discriminator = ('view', IFoo, '', IDummyRequest, IView)
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerAdapter')
-        self.assertEqual(regadapt['args'][1], view)
-        self.assertEqual(regadapt['args'][2], (IFoo, IDummyRequest))
-        self.assertEqual(regadapt['args'][3], IView)
-        self.assertEqual(regadapt['args'][4], '')
-        self.assertEqual(regadapt['args'][5], None)
-
-    def test_with_route_name_bad_order(self):
         context = DummyContext()
-        context.request_factories = {}
+        class IFoo(Interface):
+            pass
         view = lambda *arg: None
-        from zope.configuration.exceptions import ConfigurationError
-        self.assertRaises(ConfigurationError, self._callFUT, context,
-                          'repoze.view', None, view, '', None, 'foo')
+        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)
+        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_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)
+        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)
+        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 _callFUT(self, context, view):
@@ -530,27 +755,24 @@ class TestNotFoundDirective(unittest.TestCase):
         return notfound(context, view)
     
     def test_it(self):
+        from zope.component import getSiteManager
+        from repoze.bfg.interfaces import INotFoundView
+
         context = DummyContext()
         def view(request):
             return 'OK'
         self._callFUT(context, view)
         actions = context.actions
-        from repoze.bfg.interfaces import INotFoundView
-        from repoze.bfg.zcml import handler
-
         self.assertEqual(len(actions), 1)
 
         regadapt = actions[0]
-        regadapt_discriminator = ('notfound_view',)
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerUtility')
-        derived_view = regadapt['args'][1]
+        self.assertEqual(regadapt['discriminator'], INotFoundView)
+        register = regadapt['callable']
+        register()
+        sm = getSiteManager()
+        derived_view = sm.getUtility(INotFoundView)
         self.assertEqual(derived_view(None, None), 'OK')
         self.assertEqual(derived_view.__name__, view.__name__)
-        self.assertEqual(regadapt['args'][2], INotFoundView)
-        self.assertEqual(regadapt['args'][3], '')
-        self.assertEqual(regadapt['args'][4], None)
 
 class TestForbiddenDirective(unittest.TestCase):
     def _callFUT(self, context, view):
@@ -558,155 +780,143 @@ class TestForbiddenDirective(unittest.TestCase):
         return forbidden(context, view)
     
     def test_it(self):
+        from zope.component import getSiteManager
         context = DummyContext()
         def view(request):
             return 'OK'
         self._callFUT(context, view)
         actions = context.actions
         from repoze.bfg.interfaces import IForbiddenView
-        from repoze.bfg.zcml import handler
 
         self.assertEqual(len(actions), 1)
 
         regadapt = actions[0]
-        regadapt_discriminator = ('notfound_view',)
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerUtility')
-        derived_view = regadapt['args'][1]
+        self.assertEqual(regadapt['discriminator'], IForbiddenView)
+        register = regadapt['callable']
+        register()
+        sm = getSiteManager()
+        derived_view = sm.getUtility(IForbiddenView)
         self.assertEqual(derived_view(None, None), 'OK')
         self.assertEqual(derived_view.__name__, view.__name__)
-        self.assertEqual(regadapt['args'][2], IForbiddenView)
-        self.assertEqual(regadapt['args'][3], '')
-        self.assertEqual(regadapt['args'][4], None)
 
 class TestRepozeWho1AuthenticationPolicyDirective(unittest.TestCase):
+    def setUp(self):
+        cleanUp()
+
+    def tearDown(self):
+        cleanUp()
+        
     def _callFUT(self, context, **kw):
         from repoze.bfg.zcml import repozewho1authenticationpolicy
         return repozewho1authenticationpolicy(context, **kw)
 
     def test_it_defaults(self):
+        from zope.component import getUtility
+        from repoze.bfg.interfaces import IAuthenticationPolicy
         context = DummyContext()
         self._callFUT(context)
         actions = context.actions
-        from repoze.bfg.interfaces import IAuthenticationPolicy
-        from repoze.bfg.zcml import handler
-
         self.assertEqual(len(actions), 1)
-
         regadapt = actions[0]
-        regadapt_discriminator = 'authentication_policy'
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerUtility')
-        policy = regadapt['args'][1]
+        self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy)
+        self.assertEqual(regadapt['callable'], None)
+        self.assertEqual(regadapt['args'], ())
+        policy = getUtility(IAuthenticationPolicy)
         self.assertEqual(policy.callback, None)
         self.assertEqual(policy.identifier_name, 'auth_tkt')
-        self.assertEqual(regadapt['args'][2], IAuthenticationPolicy)
-        self.assertEqual(regadapt['args'][3], '')
-        self.assertEqual(regadapt['args'][4], None)
     
     def test_it(self):
+        from zope.component import getUtility
+        from repoze.bfg.interfaces import IAuthenticationPolicy
         context = DummyContext()
         def callback(identity, request):
             """ """
         self._callFUT(context, identifier_name='something', callback=callback)
         actions = context.actions
-        from repoze.bfg.interfaces import IAuthenticationPolicy
-        from repoze.bfg.zcml import handler
-
         self.assertEqual(len(actions), 1)
-
         regadapt = actions[0]
-        regadapt_discriminator = 'authentication_policy'
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerUtility')
-        policy = regadapt['args'][1]
+        self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy)
+        self.assertEqual(regadapt['callable'], None)
+        self.assertEqual(regadapt['args'], ())
+        policy = getUtility(IAuthenticationPolicy)
         self.assertEqual(policy.callback, callback)
         self.assertEqual(policy.identifier_name, 'something')
-        self.assertEqual(regadapt['args'][2], IAuthenticationPolicy)
-        self.assertEqual(regadapt['args'][3], '')
-        self.assertEqual(regadapt['args'][4], None)
 
 class TestRemoteUserAuthenticationPolicyDirective(unittest.TestCase):
+    def setUp(self):
+        cleanUp()
+
+    def tearDown(self):
+        cleanUp()
+        
     def _callFUT(self, context, **kw):
         from repoze.bfg.zcml import remoteuserauthenticationpolicy
         return remoteuserauthenticationpolicy(context, **kw)
 
     def test_defaults(self):
+        from repoze.bfg.interfaces import IAuthenticationPolicy
+        from zope.component import getUtility
         context = DummyContext()
         def callback(identity, request):
             """ """
         self._callFUT(context)
         actions = context.actions
-        from repoze.bfg.interfaces import IAuthenticationPolicy
-        from repoze.bfg.zcml import handler
-
         self.assertEqual(len(actions), 1)
-
         regadapt = actions[0]
         regadapt_discriminator = 'authentication_policy'
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerUtility')
-        policy = regadapt['args'][1]
+        self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy)
+        self.assertEqual(regadapt['callable'], None)
+        self.assertEqual(regadapt['args'], ())
+        policy = getUtility(IAuthenticationPolicy)
         self.assertEqual(policy.environ_key, 'REMOTE_USER')
         self.assertEqual(policy.callback, None)
-        self.assertEqual(regadapt['args'][2], IAuthenticationPolicy)
-        self.assertEqual(regadapt['args'][3], '')
-        self.assertEqual(regadapt['args'][4], None)
 
     def test_it(self):
+        from zope.component import getUtility
+        from repoze.bfg.interfaces import IAuthenticationPolicy
         context = DummyContext()
         def callback(identity, request):
             """ """
         self._callFUT(context, environ_key='BLAH', callback=callback)
         actions = context.actions
-        from repoze.bfg.interfaces import IAuthenticationPolicy
-        from repoze.bfg.zcml import handler
-
         self.assertEqual(len(actions), 1)
-
         regadapt = actions[0]
-        regadapt_discriminator = 'authentication_policy'
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerUtility')
-        policy = regadapt['args'][1]
+        self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy)
+        self.assertEqual(regadapt['callable'], None)
+        self.assertEqual(regadapt['args'], ())
+        policy = getUtility(IAuthenticationPolicy)
         self.assertEqual(policy.environ_key, 'BLAH')
         self.assertEqual(policy.callback, callback)
-        self.assertEqual(regadapt['args'][2], IAuthenticationPolicy)
-        self.assertEqual(regadapt['args'][3], '')
-        self.assertEqual(regadapt['args'][4], None)
 
 class TestAuthTktAuthenticationPolicyDirective(unittest.TestCase):
+    def setUp(self):
+        cleanUp()
+
+    def tearDown(self):
+        cleanUp()
+        
     def _callFUT(self, context, secret, **kw):
         from repoze.bfg.zcml import authtktauthenticationpolicy
         return authtktauthenticationpolicy(context, secret, **kw)
 
     def test_it_defaults(self):
+        from zope.component import getUtility
+        from repoze.bfg.interfaces import IAuthenticationPolicy
         context = DummyContext()
         self._callFUT(context, 'sosecret')
         actions = context.actions
-        from repoze.bfg.interfaces import IAuthenticationPolicy
-        from repoze.bfg.zcml import handler
-
         self.assertEqual(len(actions), 1)
-
         regadapt = actions[0]
-        regadapt_discriminator = 'authentication_policy'
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerUtility')
-        policy = regadapt['args'][1]
+        self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy)
+        self.assertEqual(regadapt['callable'], None)
+        self.assertEqual(regadapt['args'], ())
+        policy = getUtility(IAuthenticationPolicy)
         self.assertEqual(policy.cookie.secret, 'sosecret')
         self.assertEqual(policy.callback, None)
-        self.assertEqual(regadapt['args'][2], IAuthenticationPolicy)
-        self.assertEqual(regadapt['args'][3], '')
-        self.assertEqual(regadapt['args'][4], None)
 
     def test_it_noconfigerror(self):
+        from zope.component import getUtility
+        from repoze.bfg.interfaces import IAuthenticationPolicy
         context = DummyContext()
         def callback(identity, request):
             """ """
@@ -715,22 +925,14 @@ class TestAuthTktAuthenticationPolicyDirective(unittest.TestCase):
                       secure=True, include_ip=True, timeout=100,
                       reissue_time=60)
         actions = context.actions
-        from repoze.bfg.interfaces import IAuthenticationPolicy
-        from repoze.bfg.zcml import handler
-
         self.assertEqual(len(actions), 1)
-
         regadapt = actions[0]
-        regadapt_discriminator = 'authentication_policy'
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerUtility')
-        policy = regadapt['args'][1]
+        self.assertEqual(regadapt['discriminator'], IAuthenticationPolicy)
+        self.assertEqual(regadapt['callable'], None)
+        self.assertEqual(regadapt['args'], ())
+        policy = getUtility(IAuthenticationPolicy)
         self.assertEqual(policy.cookie.secret, 'sosecret')
         self.assertEqual(policy.callback, callback)
-        self.assertEqual(regadapt['args'][2], IAuthenticationPolicy)
-        self.assertEqual(regadapt['args'][3], '')
-        self.assertEqual(regadapt['args'][4], None)
 
     def test_it_configerror(self):
         from zope.configuration.exceptions import ConfigurationError
@@ -745,43 +947,74 @@ class TestAuthTktAuthenticationPolicyDirective(unittest.TestCase):
                           reissue_time=500)
 
 class TestACLAuthorizationPolicyDirective(unittest.TestCase):
+    def setUp(self):
+        cleanUp()
+
+    def tearDown(self):
+        cleanUp()
+        
     def _callFUT(self, context, **kw):
         from repoze.bfg.zcml import aclauthorizationpolicy
         return aclauthorizationpolicy(context, **kw)
     
     def test_it(self):
+        from zope.component import getUtility
         from repoze.bfg.authorization import ACLAuthorizationPolicy
         from repoze.bfg.interfaces import IAuthorizationPolicy
-        from repoze.bfg.zcml import handler
         context = DummyContext()
         def callback(identity, request):
             """ """
         self._callFUT(context)
         actions = context.actions
-
         self.assertEqual(len(actions), 1)
-
         regadapt = actions[0]
-        regadapt_discriminator = 'authorization_policy'
-        self.assertEqual(regadapt['discriminator'], regadapt_discriminator)
-        self.assertEqual(regadapt['callable'], handler)
-        self.assertEqual(regadapt['args'][0], 'registerUtility')
-        policy = regadapt['args'][1]
+        self.assertEqual(regadapt['discriminator'], IAuthorizationPolicy)
+        self.assertEqual(regadapt['callable'], None)
+        self.assertEqual(regadapt['args'], ())
+        policy = getUtility(IAuthorizationPolicy)
         self.assertEqual(policy.__class__, ACLAuthorizationPolicy)
-        self.assertEqual(regadapt['args'][2], IAuthorizationPolicy)
-        self.assertEqual(regadapt['args'][3], '')
-        self.assertEqual(regadapt['args'][4], None)
 
 class TestDeriveView(unittest.TestCase):
-    def _callFUT(self, view):
+    def setUp(self):
+        cleanUp()
+
+    def tearDown(self):
+        cleanUp()
+        
+    def _callFUT(self, view, *arg, **kw):
         from repoze.bfg.zcml import derive_view
-        return derive_view(view)
+        return derive_view(view, *arg, **kw)
+
+    def _registerLogger(self):
+        from repoze.bfg.interfaces import ILogger
+        from zope.component import getSiteManager
+        logger = DummyLogger()
+        sm = getSiteManager()
+        sm.registerUtility(logger, ILogger, 'repoze.bfg.debug')
+        return logger
+
+    def _registerSettings(self, **d):
+        from repoze.bfg.interfaces import ISettings
+        from zope.component import getSiteManager
+        settings = DummySettings(d)
+        sm = getSiteManager()
+        sm.registerUtility(settings, ISettings)
+
+    def _registerSecurityPolicy(self, permissive):
+        from repoze.bfg.interfaces import IAuthenticationPolicy
+        from repoze.bfg.interfaces import IAuthorizationPolicy
+        from zope.component import getSiteManager
+        policy = DummySecurityPolicy(permissive)
+        sm = getSiteManager()
+        sm.registerUtility(policy, IAuthenticationPolicy)
+        sm.registerUtility(policy, IAuthorizationPolicy)
     
     def test_view_as_function_context_and_request(self):
         def view(context, request):
             return 'OK'
         result = self._callFUT(view)
         self.failUnless(result is view)
+        self.failIf(hasattr(result, '__call_permissive__'))
         self.assertEqual(view(None, None), 'OK')
         
     def test_view_as_function_requestonly(self):
@@ -792,6 +1025,7 @@ class TestDeriveView(unittest.TestCase):
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
+        self.failIf(hasattr(result, '__call_permissive__'))
         self.assertEqual(result(None, None), 'OK')
 
     def test_view_as_newstyle_class_context_and_request(self):
@@ -805,6 +1039,7 @@ class TestDeriveView(unittest.TestCase):
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
+        self.failIf(hasattr(result, '__call_permissive__'))
         self.assertEqual(result(None, None), 'OK')
         
     def test_view_as_newstyle_class_requestonly(self):
@@ -818,6 +1053,7 @@ class TestDeriveView(unittest.TestCase):
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
+        self.failIf(hasattr(result, '__call_permissive__'))
         self.assertEqual(result(None, None), 'OK')
 
     def test_view_as_oldstyle_class_context_and_request(self):
@@ -831,6 +1067,7 @@ class TestDeriveView(unittest.TestCase):
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
+        self.failIf(hasattr(result, '__call_permissive__'))
         self.assertEqual(result(None, None), 'OK')
         
     def test_view_as_oldstyle_class_requestonly(self):
@@ -844,6 +1081,7 @@ class TestDeriveView(unittest.TestCase):
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
+        self.failIf(hasattr(result, '__call_permissive__'))
         self.assertEqual(result(None, None), 'OK')
 
     def test_view_as_instance_context_and_request(self):
@@ -853,6 +1091,7 @@ class TestDeriveView(unittest.TestCase):
         view = View()
         result = self._callFUT(view)
         self.failUnless(result is view)
+        self.failIf(hasattr(result, '__call_permissive__'))
         self.assertEqual(result(None, None), 'OK')
         
     def test_view_as_instance_requestonly(self):
@@ -865,8 +1104,158 @@ class TestDeriveView(unittest.TestCase):
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.failUnless('instance' in result.__name__)
+        self.failIf(hasattr(result, '__call_permissive__'))
         self.assertEqual(result(None, None), 'OK')
 
+    def test_view_with_debug_authorization_no_authpol(self):
+        def view(context, request):
+            return 'OK'
+        self._registerSettings(debug_authorization=True)
+        logger = self._registerLogger()
+        result = self._callFUT(view, permission='view')
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.failIf(hasattr(result, '__call_permissive__'))
+        request = DummyRequest()
+        request.view_name = 'view_name'
+        request.url = 'url'
+        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(len(logger.messages), 1)
+        self.assertEqual(logger.messages[0],
+                         "debug_authorization of url url (view name "
+                         "'view_name' against context None): Allowed "
+                         "(no authorization policy in use)")
+
+    def test_view_with_debug_authorization_no_permission(self):
+        def view(context, request):
+            return 'OK'
+        self._registerSettings(debug_authorization=True)
+        self._registerSecurityPolicy(True)
+        logger = self._registerLogger()
+        result = self._callFUT(view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.failIf(hasattr(result, '__call_permissive__'))
+        request = DummyRequest()
+        request.view_name = 'view_name'
+        request.url = 'url'
+        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(len(logger.messages), 1)
+        self.assertEqual(logger.messages[0],
+                         "debug_authorization of url url (view name "
+                         "'view_name' against context None): Allowed ("
+                         "no permission registered)")
+
+    def test_view_with_debug_authorization_permission_authpol_permitted(self):
+        def view(context, request):
+            return 'OK'
+        self._registerSettings(debug_authorization=True)
+        logger = self._registerLogger()
+        self._registerSecurityPolicy(True)
+        result = self._callFUT(view, permission='view')
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result.__call_permissive__, view)
+        request = DummyRequest()
+        request.view_name = 'view_name'
+        request.url = 'url'
+        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(len(logger.messages), 1)
+        self.assertEqual(logger.messages[0],
+                         "debug_authorization of url url (view name "
+                         "'view_name' against context None): True")
+        
+    def test_view_with_debug_authorization_permission_authpol_denied(self):
+        from repoze.bfg.security import Unauthorized
+        def view(context, request):
+            """ """
+        self._registerSettings(debug_authorization=True)
+        logger = self._registerLogger()
+        self._registerSecurityPolicy(False)
+        result = self._callFUT(view, permission='view')
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertEqual(result.__call_permissive__, view)
+        request = DummyRequest()
+        request.view_name = 'view_name'
+        request.url = 'url'
+        self.assertRaises(Unauthorized, result, None, request)
+        self.assertEqual(len(logger.messages), 1)
+        self.assertEqual(logger.messages[0],
+                         "debug_authorization of url url (view name "
+                         "'view_name' against context None): False")
+
+    def test_view_with_debug_authorization_permission_authpol_denied2(self):
+        def view(context, request):
+            """ """
+        self._registerSettings(debug_authorization=True)
+        logger = self._registerLogger()
+        self._registerSecurityPolicy(False)
+        result = self._callFUT(view, permission='view')
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        request = DummyRequest()
+        request.view_name = 'view_name'
+        request.url = 'url'
+        permitted = result.__permitted__(None, None)
+        self.assertEqual(permitted, False)
+
+    def test_view_with_predicates_all(self):
+        def view(context, request):
+            return '123'
+        predicates = []
+        def predicate1(context, request):
+            predicates.append(True)
+            return True
+        def predicate2(context, request):
+            predicates.append(True)
+            return True
+        result = self._callFUT(view, predicates=[predicate1, predicate2])
+        request = DummyRequest()
+        request.method = 'POST'
+        next = result(None, None)
+        self.assertEqual(next, '123')
+        self.assertEqual(predicates, [True, True])
+
+    def test_view_with_predicates_notall(self):
+        from repoze.bfg.view import NotFound
+        def view(context, request):
+            """ """
+        predicates = []
+        def predicate1(context, request):
+            predicates.append(True)
+            return True
+        def predicate2(context, request):
+            predicates.append(True)
+            return False
+        result = self._callFUT(view, predicates=[predicate1, predicate2])
+        request = DummyRequest()
+        request.method = 'POST'
+        self.assertRaises(NotFound, result, None, None)
+        self.assertEqual(predicates, [True, True])
+
+    def test_view_with_predicates_checker(self):
+        def view(context, request):
+            """ """
+        predicates = []
+        def predicate1(context, request):
+            predicates.append(True)
+            return True
+        def predicate2(context, request):
+            predicates.append(True)
+            return True
+        result = self._callFUT(view, predicates=[predicate1, predicate2])
+        request = DummyRequest()
+        request.method = 'POST'
+        next = result.__predicated__(None, None)
+        self.assertEqual(next, True)
+        self.assertEqual(predicates, [True, True])
+
 class TestConnectRouteFunction(unittest.TestCase):
     def setUp(self):
         cleanUp()
@@ -903,103 +1292,119 @@ class TestRouteDirective(unittest.TestCase):
         return route(*arg, **kw)
 
     def test_defaults(self):
-        from zope.component import getUtility
-        from repoze.bfg.interfaces import IRequestFactories
+        from repoze.bfg.zcml import connect_route
         context = DummyContext()
         self._callFUT(context, 'name', 'path')
-        self.failUnless(getUtility(IRequestFactories, name='name'))
+        actions = context.actions
+        self.assertEqual(len(actions), 1)
+
+        route_action = actions[0]
+        route_callable = route_action['callable']
+        route_discriminator = route_action['discriminator']
+        route_args = route_action['args']
+        self.assertEqual(route_callable, connect_route)
+        self.assertEqual(len(route_discriminator), 2)
+        self.assertEqual(route_discriminator[0], 'route')
+        self.assertEqual(route_discriminator[1], 'name')
+        self.assertEqual(route_args, ('path', 'name', None))
 
     def test_with_view(self):
-        from zope.component import getUtility
-        from repoze.bfg.interfaces import IRequestFactories
-        from repoze.bfg.zcml import handler
+        from zope.interface import Interface
+        from zope.interface import implementedBy
+        from zope.component import getSiteManager
+        from repoze.bfg.interfaces import IRouteRequest
         from repoze.bfg.zcml import connect_route
         from repoze.bfg.interfaces import IView
         
         context = DummyContext()
-        view = Dummy()
+        def view(context, request):
+            return '123'
         self._callFUT(context, 'name', 'path', view=view)
         actions = context.actions
         self.assertEqual(len(actions), 2)
 
-        factories = getUtility(IRequestFactories, name='name')
-        request_iface = factories[None]['interface']
-
         view_action = actions[0]
-        view_callable = view_action['callable']
+        register = view_action['callable']
+        register()
+        sm = getSiteManager()
+        request_factory = sm.getUtility(IRouteRequest, 'name')
+        request_type = implementedBy(request_factory)
         view_discriminator = view_action['discriminator']
-        view_args = view_action['args']
-        self.assertEqual(view_callable, handler)
-        self.assertEqual(len(view_discriminator), 5)
+        self.assertEqual(len(view_discriminator), 9)
         self.assertEqual(view_discriminator[0], 'view')
         self.assertEqual(view_discriminator[1], None)
         self.assertEqual(view_discriminator[2],'')
-        self.assertEqual(view_discriminator[3], request_iface)
+        self.assertEqual(view_discriminator[3], request_type)
         self.assertEqual(view_discriminator[4], IView)
-        self.assertEqual(view_args, ('registerAdapter', view,
-                                     (None, request_iface), IView,
-                                     '', None))
+        self.assertEqual(view_discriminator[5], None)
+        self.assertEqual(view_discriminator[6], None)
+        self.assertEqual(view_discriminator[7], None)
+        self.assertEqual(view_discriminator[8], 'name')
+        register = view_action['callable']
+        register()
+        sm = getSiteManager()
+        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']
         route_args = route_action['args']
         self.assertEqual(route_callable, connect_route)
-        self.assertEqual(len(route_discriminator), 4)
+        self.assertEqual(len(route_discriminator), 2)
         self.assertEqual(route_discriminator[0], 'route')
         self.assertEqual(route_discriminator[1], 'name')
-        self.assertEqual(route_discriminator[2], None)
-        self.assertEqual(route_discriminator[3], None)
         self.assertEqual(route_args, ('path', 'name', None))
 
     def test_with_view_and_view_for(self):
-        from zope.component import getUtility
-        from repoze.bfg.interfaces import IRequestFactories
-        from repoze.bfg.zcml import handler
+        from zope.component import getSiteManager
+        from zope.interface import implementedBy
         from repoze.bfg.zcml import connect_route
         from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import IRouteRequest
         
         context = DummyContext()
-        view = Dummy()
+        def view(context, request):
+            return '123'
         self._callFUT(context, 'name', 'path', view=view, view_for=IDummy)
         actions = context.actions
         self.assertEqual(len(actions), 2)
 
-        factories = getUtility(IRequestFactories, 'name')
-        request_iface = factories[None]['interface']
-
         view_action = actions[0]
-        view_callable = view_action['callable']
+        register = view_action['callable']
+        register()
+        sm = getSiteManager()
+        request_factory = sm.getUtility(IRouteRequest, 'name')
+        request_type = implementedBy(request_factory)
         view_discriminator = view_action['discriminator']
-        view_args = view_action['args']
-        self.assertEqual(view_callable, handler)
-        self.assertEqual(len(view_discriminator), 5)
+        self.assertEqual(len(view_discriminator), 9)
         self.assertEqual(view_discriminator[0], 'view')
         self.assertEqual(view_discriminator[1], IDummy)
         self.assertEqual(view_discriminator[2],'')
-        self.assertEqual(view_discriminator[3], request_iface)
-        self.assertEqual(view_discriminator[4], IView)
-        self.assertEqual(view_args, ('registerAdapter', view,
-                                     (IDummy, request_iface), IView,
-                                     '', None))
+        self.assertEqual(view_discriminator[3], request_type)
+        self.assertEqual(view_discriminator[4], IView) 
+        self.assertEqual(view_discriminator[5], None)
+        self.assertEqual(view_discriminator[6], None)
+        self.assertEqual(view_discriminator[7], None)
+        self.assertEqual(view_discriminator[8], 'name')
+        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']
         route_args = route_action['args']
         self.assertEqual(route_callable, connect_route)
-        self.assertEqual(len(route_discriminator), 4)
+        self.assertEqual(len(route_discriminator), 2)
         self.assertEqual(route_discriminator[0], 'route')
         self.assertEqual(route_discriminator[1], 'name')
-        self.assertEqual(route_discriminator[2], IDummy)
-        self.assertEqual(route_discriminator[3], None)
         self.assertEqual(route_args, ('path', 'name', None,))
 
     def test_without_view(self):
         from repoze.bfg.zcml import connect_route
-        
         context = DummyContext()
-        view = Dummy()
         self._callFUT(context, 'name', 'path')
         actions = context.actions
         self.assertEqual(len(actions), 1)
@@ -1009,32 +1414,275 @@ class TestRouteDirective(unittest.TestCase):
         route_discriminator = route_action['discriminator']
         route_args = route_action['args']
         self.assertEqual(route_callable, connect_route)
-        self.assertEqual(len(route_discriminator), 4)
+        self.assertEqual(len(route_discriminator), 2)
         self.assertEqual(route_discriminator[0], 'route')
         self.assertEqual(route_discriminator[1], 'name')
-        self.assertEqual(route_discriminator[2], None)
-        self.assertEqual(route_discriminator[3], None)
         self.assertEqual(route_args, ('path', 'name', None))
 
-    def test_with_request_type(self):
+    def test_with_view_request_type(self):
+        from zope.component import getSiteManager
+        from zope.interface import implementedBy
         from repoze.bfg.zcml import connect_route
+        from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import IRouteRequest
         
         context = DummyContext()
-        view = Dummy()
-        self._callFUT(context, 'name', 'path', request_type="GET")
+        def view(context, request):
+            """ """
+        self._callFUT(context, 'name', 'path', view=view,
+                      view_request_type="GET")
         actions = context.actions
-        self.assertEqual(len(actions), 1)
+        self.assertEqual(len(actions), 2)
 
-        route_action = actions[0]
+        view_action = actions[0]
+        register = view_action['callable']
+        register()
+        sm = getSiteManager()
+        request_factory = sm.getUtility(IRouteRequest, 'name')
+        request_type = implementedBy(request_factory)
+        view_discriminator = view_action['discriminator']
+        self.assertEqual(len(view_discriminator), 9)
+        self.assertEqual(view_discriminator[0], 'view')
+        self.assertEqual(view_discriminator[1], None)
+        self.assertEqual(view_discriminator[2],'')
+        self.assertEqual(view_discriminator[3], request_type)
+        self.assertEqual(view_discriminator[4], IView) 
+        self.assertEqual(view_discriminator[5], None)
+        self.assertEqual(view_discriminator[6], None)
+        self.assertEqual(view_discriminator[7], 'GET')
+        self.assertEqual(view_discriminator[8], 'name')
+        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_callable, connect_route)
+        self.assertEqual(len(route_discriminator), 2)
+        self.assertEqual(route_discriminator[0], 'route')
+        self.assertEqual(route_discriminator[1], 'name')
+        self.assertEqual(route_args, ('path', 'name', None))
+
+    def test_with_view_request_type_alias(self):
+        from zope.component import getSiteManager
+        from zope.interface import implementedBy
+        from repoze.bfg.zcml import connect_route
+        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_factory = sm.getUtility(IRouteRequest, 'name')
+        request_type = implementedBy(request_factory)
+        view_discriminator = view_action['discriminator']
+        self.assertEqual(len(view_discriminator), 9)
+        self.assertEqual(view_discriminator[0], 'view')
+        self.assertEqual(view_discriminator[1], None)
+        self.assertEqual(view_discriminator[2],'')
+        self.assertEqual(view_discriminator[3], request_type)
+        self.assertEqual(view_discriminator[4], IView) 
+        self.assertEqual(view_discriminator[5], None)
+        self.assertEqual(view_discriminator[6], None)
+        self.assertEqual(view_discriminator[7], 'GET')
+        self.assertEqual(view_discriminator[8], 'name')
+        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_callable, connect_route)
+        self.assertEqual(len(route_discriminator), 2)
+        self.assertEqual(route_discriminator[0], 'route')
+        self.assertEqual(route_discriminator[1], 'name')
+        self.assertEqual(route_args, ('path', 'name', None))
+
+    def test_with_view_request_method(self):
+        from zope.component import getSiteManager
+        from zope.interface import implementedBy
+        from repoze.bfg.zcml import connect_route
+        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_factory = sm.getUtility(IRouteRequest, 'name')
+        request_type = implementedBy(request_factory)
+        view_discriminator = view_action['discriminator']
+        self.assertEqual(len(view_discriminator), 9)
+        self.assertEqual(view_discriminator[0], 'view')
+        self.assertEqual(view_discriminator[1], None)
+        self.assertEqual(view_discriminator[2],'')
+        self.assertEqual(view_discriminator[3], request_type)
+        self.assertEqual(view_discriminator[4], IView) 
+        self.assertEqual(view_discriminator[5], None)
+        self.assertEqual(view_discriminator[6], None)
+        self.assertEqual(view_discriminator[7], 'GET')
+        self.assertEqual(view_discriminator[8], 'name')
+        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_callable, connect_route)
+        self.assertEqual(len(route_discriminator), 2)
+        self.assertEqual(route_discriminator[0], 'route')
+        self.assertEqual(route_discriminator[1], 'name')
+        self.assertEqual(route_args, ('path', 'name', None))
+
+    def test_with_view_request_method_alias(self):
+        from zope.component import getSiteManager
+        from zope.interface import implementedBy
+        from repoze.bfg.zcml import connect_route
+        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_factory = sm.getUtility(IRouteRequest, 'name')
+        request_type = implementedBy(request_factory)
+        view_discriminator = view_action['discriminator']
+        self.assertEqual(len(view_discriminator), 9)
+        self.assertEqual(view_discriminator[0], 'view')
+        self.assertEqual(view_discriminator[1], None)
+        self.assertEqual(view_discriminator[2],'')
+        self.assertEqual(view_discriminator[3], request_type)
+        self.assertEqual(view_discriminator[4], IView) 
+        self.assertEqual(view_discriminator[5], None)
+        self.assertEqual(view_discriminator[6], None)
+        self.assertEqual(view_discriminator[7], 'GET')
+        self.assertEqual(view_discriminator[8], 'name')
+        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_callable, connect_route)
+        self.assertEqual(len(route_discriminator), 2)
+        self.assertEqual(route_discriminator[0], 'route')
+        self.assertEqual(route_discriminator[1], 'name')
+        self.assertEqual(route_args, ('path', 'name', None))
+
+    def test_with_view_containment(self):
+        from zope.component import getSiteManager
+        from zope.interface import implementedBy
+        from repoze.bfg.zcml import connect_route
+        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_factory = sm.getUtility(IRouteRequest, 'name')
+        request_type = implementedBy(request_factory)
+        view_discriminator = view_action['discriminator']
+        self.assertEqual(len(view_discriminator), 9)
+        self.assertEqual(view_discriminator[0], 'view')
+        self.assertEqual(view_discriminator[1], None)
+        self.assertEqual(view_discriminator[2],'')
+        self.assertEqual(view_discriminator[3], request_type)
+        self.assertEqual(view_discriminator[4], IView) 
+        self.assertEqual(view_discriminator[5], True)
+        self.assertEqual(view_discriminator[6], None)
+        self.assertEqual(view_discriminator[7], None)
+        self.assertEqual(view_discriminator[8], 'name')
+        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_callable, connect_route)
-        self.assertEqual(len(route_discriminator), 4)
+        self.assertEqual(len(route_discriminator), 2)
+        self.assertEqual(route_discriminator[0], 'route')
+        self.assertEqual(route_discriminator[1], 'name')
+        self.assertEqual(route_args, ('path', 'name', None))
+
+    def test_with_view_containment_alias(self):
+        from zope.component import getSiteManager
+        from zope.interface import implementedBy
+        from repoze.bfg.zcml import connect_route
+        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, containment=True)
+        actions = context.actions
+        self.assertEqual(len(actions), 2)
+
+        view_action = actions[0]
+        register = view_action['callable']
+        register()
+        sm = getSiteManager()
+        request_factory = sm.getUtility(IRouteRequest, 'name')
+        request_type = implementedBy(request_factory)
+        view_discriminator = view_action['discriminator']
+        self.assertEqual(len(view_discriminator), 9)
+        self.assertEqual(view_discriminator[0], 'view')
+        self.assertEqual(view_discriminator[1], None)
+        self.assertEqual(view_discriminator[2],'')
+        self.assertEqual(view_discriminator[3], request_type)
+        self.assertEqual(view_discriminator[4], IView) 
+        self.assertEqual(view_discriminator[5], True)
+        self.assertEqual(view_discriminator[6], None)
+        self.assertEqual(view_discriminator[7], None)
+        self.assertEqual(view_discriminator[8], 'name')
+        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_callable, connect_route)
+        self.assertEqual(len(route_discriminator), 2)
         self.assertEqual(route_discriminator[0], 'route')
         self.assertEqual(route_discriminator[1], 'name')
-        self.assertEqual(route_discriminator[2], None)
-        self.assertEqual(route_discriminator[3], 'GET')
         self.assertEqual(route_args, ('path', 'name', None))
 
 class TestStaticDirective(unittest.TestCase):
@@ -1049,65 +1697,87 @@ class TestStaticDirective(unittest.TestCase):
         return static(*arg, **kw)
 
     def test_absolute(self):
+        from paste.urlparser import StaticURLParser
+        from zope.interface import implementedBy
+        from zope.component import getSiteManager
+        from repoze.bfg.zcml import connect_route
+        from repoze.bfg.zcml import StaticRootFactory
+        from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import IRouteRequest
         import os
         here = os.path.dirname(__file__)
         static_path = os.path.join(here, 'fixtures', 'static')
-        from repoze.bfg.zcml import handler
-        from repoze.bfg.zcml import connect_route
-        from repoze.bfg.interfaces import IView
         context = DummyContext()
         self._callFUT(context, 'name', static_path)
         actions = context.actions
         self.assertEqual(len(actions), 2)
 
         action = actions[0]
-        callable = action['callable']
         discriminator = action['discriminator']
-        args = action['args']
-        self.assertEqual(callable, handler)
-        self.assertEqual(discriminator[:3], ('view', None, ''))
+        self.assertEqual(discriminator[:3], ('view', StaticRootFactory, ''))
         self.assertEqual(discriminator[4], IView)
-        self.assertEqual(args[1].app.directory, static_path)
+        sm = getSiteManager()
+        register = action['callable']
+        register()
+        sm = getSiteManager()
+        iface = implementedBy(StaticRootFactory)
+        request_factory = sm.getUtility(IRouteRequest, 'name')
+        request_type = implementedBy(request_factory)
+        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']
         args = action['args']
         self.assertEqual(callable, connect_route)
-        self.assertEqual(discriminator, ('route', 'name', None, None))
+        self.assertEqual(discriminator, ('route', 'name'))
         self.assertEqual(args[0], 'name*subpath')
 
     def test_package_relative(self):
-        from repoze.bfg.zcml import handler
+        from repoze.bfg.static import PackageURLParser
+        from zope.component import getSiteManager
+        from zope.interface import implementedBy
         from repoze.bfg.zcml import connect_route
+        from repoze.bfg.zcml import StaticRootFactory
         from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import IRouteRequest
         context = DummyContext()
         self._callFUT(context, 'name', 'repoze.bfg.tests:fixtures/static')
         actions = context.actions
         self.assertEqual(len(actions), 2)
 
         action = actions[0]
-        callable = action['callable']
         discriminator = action['discriminator']
-        args = action['args']
-        self.assertEqual(callable, handler)
-        self.assertEqual(discriminator[:3], ('view', None, ''))
+        self.assertEqual(discriminator[:3], ('view', StaticRootFactory, ''))
         self.assertEqual(discriminator[4], IView)
-        self.assertEqual(args[1].app.package_name, 'repoze.bfg.tests')
-        self.assertEqual(args[1].app.resource_name, 'fixtures/static')
+        register = action['callable']
+        register()
+        sm = getSiteManager()
+        iface = implementedBy(StaticRootFactory)
+        request_factory = sm.getUtility(IRouteRequest, 'name')
+        request_type = implementedBy(request_factory)
+        view = sm.adapters.lookup((iface, request_type), IView, name='')
+        request = DummyRequest()
+        self.assertEqual(view(None, request).__class__, PackageURLParser)
 
         action = actions[1]
         callable = action['callable']
         discriminator = action['discriminator']
         args = action['args']
         self.assertEqual(callable, connect_route)
-        self.assertEqual(discriminator, ('route', 'name', None, None))
+        self.assertEqual(discriminator, ('route', 'name'))
         self.assertEqual(args[0], 'name*subpath')
 
     def test_here_relative(self):
-        from repoze.bfg.zcml import handler
+        from repoze.bfg.static import PackageURLParser
+        from zope.component import getSiteManager
+        from zope.interface import implementedBy
         from repoze.bfg.zcml import connect_route
+        from repoze.bfg.zcml import StaticRootFactory
         from repoze.bfg.interfaces import IView
+        from repoze.bfg.interfaces import IRouteRequest
         import repoze.bfg.tests
         context = DummyContext(repoze.bfg.tests)
         self._callFUT(context, 'name', 'fixtures/static')
@@ -1115,21 +1785,25 @@ class TestStaticDirective(unittest.TestCase):
         self.assertEqual(len(actions), 2)
 
         action = actions[0]
-        callable = action['callable']
         discriminator = action['discriminator']
-        args = action['args']
-        self.assertEqual(callable, handler)
-        self.assertEqual(discriminator[:3], ('view', None, ''))
+        self.assertEqual(discriminator[:3], ('view', StaticRootFactory, ''))
         self.assertEqual(discriminator[4], IView)
-        self.assertEqual(args[1].app.package_name, 'repoze.bfg.tests')
-        self.assertEqual(args[1].app.resource_name, 'fixtures/static')
+        register = action['callable']
+        register()
+        sm = getSiteManager()
+        iface = implementedBy(StaticRootFactory)
+        request_factory = sm.getUtility(IRouteRequest, 'name')
+        request_type = implementedBy(request_factory)
+        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']
         args = action['args']
         self.assertEqual(callable, connect_route)
-        self.assertEqual(discriminator, ('route', 'name', None, None))
+        self.assertEqual(discriminator, ('route', 'name'))
         self.assertEqual(args[0], 'name*subpath')
 
 class TestResourceDirective(unittest.TestCase):
@@ -1372,22 +2046,36 @@ class TestBFGViewFunctionGrokker(unittest.TestCase):
         return self._getTargetClass()(*arg, **kw)
 
     def test_grok_is_bfg_view(self):
+        from zope.component import getSiteManager
         from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.interfaces import IView
         from zope.interface import Interface
         grokker = self._makeOne()
         class obj:
-            pass
+            def __init__(self, context, request):
+                pass
+            def __call__(self):
+                return 'OK'
         obj.__is_bfg_view__ = True
         obj.__permission__ = 'foo'
         obj.__for__ = Interface
         obj.__view_name__ = 'foo.html'
         obj.__request_type__ = IRequest
         obj.__route_name__ = None
+        obj.__request_method__ = None
+        obj.__request_param__ = None
+        obj.__containment__ = None
         context = DummyContext()
         result = grokker.grok('name', obj, context=context)
         self.assertEqual(result, True)
         actions = context.actions
-        self.assertEqual(len(actions), 2)
+        self.assertEqual(len(actions), 1)
+        register = actions[0]['callable']
+        register()
+        sm = getSiteManager()
+        wrapped = sm.adapters.lookup((Interface, IRequest), IView,
+                                     name='foo.html')
+        self.assertEqual(wrapped(None, None), 'OK')
 
     def test_grok_is_not_bfg_view(self):
         grokker = self._makeOne()
@@ -1436,152 +2124,17 @@ class TestExcludeFunction(unittest.TestCase):
         self.assertEqual(self._callFUT('.foo'), True)
         self.assertEqual(self._callFUT('foo'), False)
 
-class TestRequestOnly(unittest.TestCase):
-    def _callFUT(self, arg):
-        from repoze.bfg.zcml import requestonly
-        return requestonly(arg)
-    
-    def test_newstyle_class_no_init(self):
-        class foo(object):
-            """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_newstyle_class_init_toomanyargs(self):
-        class foo(object):
-            def __init__(self, context, request):
-                """ """
-        self.assertFalse(self._callFUT(foo))
-        
-    def test_newstyle_class_init_onearg_named_request(self):
-        class foo(object):
-            def __init__(self, request):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_newstyle_class_init_onearg_named_somethingelse(self):
-        class foo(object):
-            def __init__(self, req):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_newstyle_class_init_defaultargs_firstname_not_request(self):
-        class foo(object):
-            def __init__(self, context, request=None):
-                """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_newstyle_class_init_defaultargs_firstname_request(self):
-        class foo(object):
-            def __init__(self, request, foo=1, bar=2):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_newstyle_class_init_noargs(self):
-        class foo(object):
-            def __init__():
-                """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_oldstyle_class_no_init(self):
-        class foo:
-            """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_oldstyle_class_init_toomanyargs(self):
-        class foo:
-            def __init__(self, context, request):
-                """ """
-        self.assertFalse(self._callFUT(foo))
-        
-    def test_oldstyle_class_init_onearg_named_request(self):
-        class foo:
-            def __init__(self, request):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_oldstyle_class_init_onearg_named_somethingelse(self):
-        class foo:
-            def __init__(self, req):
-                """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_oldstyle_class_init_defaultargs_firstname_not_request(self):
-        class foo:
-            def __init__(self, context, request=None):
-                """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_oldstyle_class_init_defaultargs_firstname_request(self):
-        class foo:
-            def __init__(self, request, foo=1, bar=2):
-                """ """
-        self.assertTrue(self._callFUT(foo), True)
-
-    def test_oldstyle_class_init_noargs(self):
-        class foo:
-            def __init__():
-                """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_function_toomanyargs(self):
-        def foo(context, request):
-            """ """
-        self.assertFalse(self._callFUT(foo))
-        
-    def test_function_onearg_named_request(self):
-        def foo(request):
-            """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_function_onearg_named_somethingelse(self):
-        def foo(req):
-            """ """
-        self.assertTrue(self._callFUT(foo))
-
-    def test_function_defaultargs_firstname_not_request(self):
-        def foo(context, request=None):
-            """ """
-        self.assertFalse(self._callFUT(foo))
-
-    def test_function_defaultargs_firstname_request(self):
-        def foo(request, foo=1, bar=2):
-            """ """
-        self.assertTrue(self._callFUT(foo), True)
-
-    def test_instance_toomanyargs(self):
-        class Foo:
-            def __call__(self, context, request):
-                """ """
-        foo = Foo()
-        self.assertFalse(self._callFUT(foo))
-        
-    def test_instance_defaultargs_onearg_named_request(self):
-        class Foo:
-            def __call__(self, request):
-                """ """
-        foo = Foo()
-        self.assertTrue(self._callFUT(foo))
-
-    def test_instance_defaultargs_onearg_named_somethingelse(self):
-        class Foo:
-            def __call__(self, req):
-                """ """
-        foo = Foo()
-        self.assertTrue(self._callFUT(foo))
-
-    def test_instance_defaultargs_firstname_not_request(self):
-        class Foo:
-            def __call__(self, context, request=None):
-                """ """
-        foo = Foo()
-        self.assertFalse(self._callFUT(foo))
+class TestAll(unittest.TestCase):
+    def test_it(self):
+        from repoze.bfg.zcml import all
+        self.assertEqual(all([True, True]), True)
+        self.assertEqual(all([False, False]), False)
+        self.assertEqual(all([False, True]), False)
 
-    def test_instance_defaultargs_firstname_request(self):
-        class Foo:
-            def __call__(self, request, foo=1, bar=2):
-                """ """
-        foo = Foo()
-        self.assertTrue(self._callFUT(foo), True)
+class TestStaticRootFactory(unittest.TestCase):
+    def test_it(self):
+        from repoze.bfg.zcml import StaticRootFactory
+        StaticRootFactory({}) # it just needs construction
 
 class DummyModule:
     __path__ = "foo"
@@ -1612,7 +2165,7 @@ class DummyContext:
         self.info = None
         self.resolved = resolved
 
-    def action(self, discriminator, callable, args):
+    def action(self, discriminator, callable=None, args=(), kw={}, order=0):
         self.actions.append(
             {'discriminator':discriminator,
              'callable':callable,
@@ -1639,9 +2192,6 @@ from zope.interface import Interface
 class IDummy(Interface):
     pass
 
-class DummySecurityPolicy:
-    pass
-
 class DummyLogger:
     def __init__(self):
         self.messages = []
@@ -1651,9 +2201,18 @@ class DummyLogger:
     debug = info
 
 class DummyRequest:
+    subpath = ()
+    def __init__(self, environ=None):
+        if environ is None:
+            environ = {}
+        self.environ = environ
+        
     def get_response(self, app):
         return app
-    
+
+    def copy(self):
+        return self
+
 class DummyOverrides:
     def __init__(self, package):
         self.package = package
@@ -1666,3 +2225,17 @@ class DummyPackage:
     def __init__(self, name):
         self.__name__ = name
         
+class DummySettings(dict):
+    def __getattr__(self, name):
+        return self[name]
+    
+class DummySecurityPolicy:
+    def __init__(self, permitted=True):
+        self.permitted = permitted
+
+    def effective_principals(self, request):
+        return []
+
+    def permits(self, context, principals, permission):
+        return self.permitted
+