- Each of the ``repoze.bfg.view.render_view``,

  ``repoze.bfg.view.render_view_to_iterable``,
  ``repoze.bfg.view.render_view_to_response``,
  ``repoze.bfg.view.append_slash_notfound_view``,
  ``repoze.bfg.view.default_notfound_view``,
  ``repoze.bfg.view.default_forbidden_view``, and the
  ``repoze.bfg.configuration.rendered_response`` functions now expects
  to be called with a request object that has a ``registry`` attribute
  which represents the current ZCA registry.  This should only be a
  problem when passing a custom request object to code which ends up
  calling these functions in a unit test.  To retrofit tests that end
  up calling these functions which expect to be able to use a
  non-registry-aware request object, use the
  ``repoze.bfg.threadlocal.get_current_request`` API in the test to
  create the request; this will return a
  ``repoze.bfg.testing.DummyRequest`` that has the current registry as
  its ``registry`` attribute.  Alternatively, use the
  ``repoze.bfg.threadlocal.get_current_registry`` API: call this
  function and add an attribute to your unit test request object named
  ``registry`` with the result.

- The ``repoze.bfg.view.derive_view`` callable has been removed.  Use
  ``repoze.bfg.configuration.Configurator.derive_view`` instead (still
  not an API, however).

1 files changed, 85 insertions, 488 deletions

diff --git a/repoze/bfg/tests/test_view.py b/repoze/bfg/tests/test_view.py
index c293394c1..43e435eab 100644
--- a/repoze/bfg/tests/test_view.py
+++ b/repoze/bfg/tests/test_view.py
@@ -9,11 +9,12 @@ class BaseTest(object):
     def tearDown(self):
         cleanUp()
 
-    def _registerView(self, app, name, *for_):
-        import zope.component
-        sm = zope.component.getSiteManager()
+    def _registerView(self, reg, app, name, *for_):
+        from repoze.bfg.interfaces import IRequest
+        if not for_:
+            for_ = (IContext, IRequest)
         from repoze.bfg.interfaces import IView
-        sm.registerAdapter(app, for_, IView, name)
+        reg.registerAdapter(app, for_, IView, name)
 
     def _makeEnviron(self, **extras):
         environ = {
@@ -26,76 +27,64 @@ class BaseTest(object):
         environ.update(extras)
         return environ
 
+    def _makeRequest(self, **environ):
+        from repoze.bfg.interfaces import IRequest
+        from zope.interface import directlyProvides
+        from webob import Request
+        from repoze.bfg.registry import Registry
+        environ = self._makeEnviron(**environ)
+        request = Request(environ)
+        request.registry = Registry()
+        directlyProvides(request, IRequest)
+        return request
+
+    def _makeContext(self):
+        from zope.interface import directlyProvides
+        context = DummyContext()
+        directlyProvides(context, IContext)
+        return context
+        
+
 class RenderViewToResponseTests(BaseTest, unittest.TestCase):
     def _callFUT(self, *arg, **kw):
         from repoze.bfg.view import render_view_to_response
         return render_view_to_response(*arg, **kw)
     
     def test_call_no_view_registered(self):
-        environ = self._makeEnviron()
-        from webob import Request
-        request = Request(environ)
-        context = DummyContext()
+        request = self._makeRequest()
+        context = self._makeContext()
         result = self._callFUT(context, request, name='notregistered')
         self.assertEqual(result, None)
 
     def test_call_view_registered_secure(self):
-        context = DummyContext()
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        from repoze.bfg.interfaces import IRequest
-        class IContext(Interface):
-            pass
-        directlyProvides(context, IContext)
+        request = self._makeRequest()
+        context = self._makeContext()
         response = DummyResponse()
         view = make_view(response)
-        self._registerView(view, 'registered', IContext, IRequest)
-        environ = self._makeEnviron()
-        from webob import Request
-        request = Request(environ)
-        directlyProvides(request, IRequest)
+        self._registerView(request.registry, view, 'registered')
         response = self._callFUT(context, request, name='registered',
                                  secure=True)
         self.assertEqual(response.status, '200 OK')
 
-
     def test_call_view_registered_insecure_no_call_permissive(self):
-        context = DummyContext()
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        from repoze.bfg.interfaces import IRequest
-        class IContext(Interface):
-            pass
-        directlyProvides(context, IContext)
+        context = self._makeContext()
+        request = self._makeRequest()
         response = DummyResponse()
         view = make_view(response)
-        self._registerView(view, 'registered', IContext, IRequest)
-        environ = self._makeEnviron()
-        from webob import Request
-        request = Request(environ)
-        directlyProvides(request, IRequest)
+        self._registerView(request.registry, view, 'registered')
         response = self._callFUT(context, request, name='registered',
                                  secure=False)
         self.assertEqual(response.status, '200 OK')
 
     def test_call_view_registered_insecure_with_call_permissive(self):
-        context = DummyContext()
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        from repoze.bfg.interfaces import IRequest
-        class IContext(Interface):
-            pass
-        directlyProvides(context, IContext)
+        context = self._makeContext()
+        request = self._makeRequest()
         response = DummyResponse()
         view = make_view(response)
         def anotherview(context, request):
             return DummyResponse('anotherview')
         view.__call_permissive__ = anotherview
-        self._registerView(view, 'registered', IContext, IRequest)
-        environ = self._makeEnviron()
-        from webob import Request
-        request = Request(environ)
-        directlyProvides(request, IRequest)
+        self._registerView(request.registry, view, 'registered')
         response = self._callFUT(context, request, name='registered',
                                  secure=False)
         self.assertEqual(response.status, '200 OK')
@@ -107,140 +96,82 @@ class RenderViewToIterableTests(BaseTest, unittest.TestCase):
         return render_view_to_iterable(*arg, **kw)
     
     def test_call_no_view_registered(self):
-        environ = self._makeEnviron()
-        from webob import Request
-        request = Request(environ)
-        context = DummyContext()
+        request = self._makeRequest()
+        context = self._makeContext()
         result = self._callFUT(context, request, name='notregistered')
         self.assertEqual(result, None)
 
     def test_call_view_registered_secure(self):
-        context = DummyContext()
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        from repoze.bfg.interfaces import IRequest
-        class IContext(Interface):
-            pass
-        directlyProvides(context, IContext)
+        request = self._makeRequest()
+        context = self._makeContext()
         response = DummyResponse()
         view = make_view(response)
-        self._registerView(view, 'registered', IContext, IRequest)
-        environ = self._makeEnviron()
-        from webob import Request
-        request = Request(environ)
-        directlyProvides(request, IRequest)
+        self._registerView(request.registry, view, 'registered')
         iterable = self._callFUT(context, request, name='registered',
                                  secure=True)
         self.assertEqual(iterable, ())
 
     def test_call_view_registered_insecure_no_call_permissive(self):
-        context = DummyContext()
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        from repoze.bfg.interfaces import IRequest
-        class IContext(Interface):
-            pass
-        directlyProvides(context, IContext)
+        context = self._makeContext()
+        request = self._makeRequest()
         response = DummyResponse()
         view = make_view(response)
-        self._registerView(view, 'registered', IContext, IRequest)
-        environ = self._makeEnviron()
-        from webob import Request
-        request = Request(environ)
-        directlyProvides(request, IRequest)
+        self._registerView(request.registry, view, 'registered')
         iterable = self._callFUT(context, request, name='registered',
                                  secure=False)
         self.assertEqual(iterable, ())
 
     def test_call_view_registered_insecure_with_call_permissive(self):
-        context = DummyContext()
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        from repoze.bfg.interfaces import IRequest
-        class IContext(Interface):
-            pass
-        directlyProvides(context, IContext)
+        context = self._makeContext()
+        request = self._makeRequest()
         response = DummyResponse()
         view = make_view(response)
         def anotherview(context, request):
             return DummyResponse('anotherview')
         view.__call_permissive__ = anotherview
-        self._registerView(view, 'registered', IContext, IRequest)
-        environ = self._makeEnviron()
-        from webob import Request
-        request = Request(environ)
-        directlyProvides(request, IRequest)
+        self._registerView(request.registry, view, 'registered')
         iterable = self._callFUT(context, request, name='registered',
                                  secure=False)
         self.assertEqual(iterable, ['anotherview'])
 
-class RenderViewTests(unittest.TestCase, BaseTest):
+class RenderViewTests(BaseTest, unittest.TestCase):
     def _callFUT(self, *arg, **kw):
         from repoze.bfg.view import render_view
         return render_view(*arg, **kw)
     
     def test_call_no_view_registered(self):
-        environ = self._makeEnviron()
-        from webob import Request
-        request = Request(environ)
-        context = DummyContext()
+        request = self._makeRequest()
+        context = self._makeContext()
         result = self._callFUT(context, request, name='notregistered')
         self.assertEqual(result, None)
 
     def test_call_view_registered_secure(self):
-        context = DummyContext()
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        from repoze.bfg.interfaces import IRequest
-        class IContext(Interface):
-            pass
-        directlyProvides(context, IContext)
+        request = self._makeRequest()
+        context = self._makeContext()
         response = DummyResponse()
         view = make_view(response)
-        self._registerView(view, 'registered', IContext, IRequest)
-        environ = self._makeEnviron()
-        from webob import Request
-        request = Request(environ)
-        directlyProvides(request, IRequest)
+        self._registerView(request.registry, view, 'registered')
         s = self._callFUT(context, request, name='registered', secure=True)
         self.assertEqual(s, '')
 
     def test_call_view_registered_insecure_no_call_permissive(self):
-        context = DummyContext()
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        from repoze.bfg.interfaces import IRequest
-        class IContext(Interface):
-            pass
-        directlyProvides(context, IContext)
+        context = self._makeContext()
+        request = self._makeRequest()
         response = DummyResponse()
         view = make_view(response)
-        self._registerView(view, 'registered', IContext, IRequest)
-        environ = self._makeEnviron()
-        from webob import Request
-        request = Request(environ)
-        directlyProvides(request, IRequest)
+        self._registerView(request.registry, view, 'registered')
         s = self._callFUT(context, request, name='registered', secure=False)
         self.assertEqual(s, '')
 
     def test_call_view_registered_insecure_with_call_permissive(self):
-        context = DummyContext()
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        from repoze.bfg.interfaces import IRequest
-        class IContext(Interface):
-            pass
-        directlyProvides(context, IContext)
+        context = self._makeContext()
+        request = self._makeRequest()
         response = DummyResponse()
         view = make_view(response)
         def anotherview(context, request):
             return DummyResponse('anotherview')
         view.__call_permissive__ = anotherview
-        self._registerView(view, 'registered', IContext, IRequest)
-        environ = self._makeEnviron()
-        from webob import Request
-        request = Request(environ)
-        directlyProvides(request, IRequest)
+        self._registerView(request.registry, view, 'registered')
         s = self._callFUT(context, request, name='registered', secure=False)
         self.assertEqual(s, 'anotherview')
 
@@ -267,7 +198,7 @@ class TestIsResponse(unittest.TestCase):
         response.status = None
         self.assertEqual(self._callFUT(response), False)
 
-class TestStaticView(unittest.TestCase, BaseTest):
+class TestStaticView(BaseTest, unittest.TestCase):
     def setUp(self):
         cleanUp()
 
@@ -431,56 +362,52 @@ class TestBFGViewDecorator(unittest.TestCase):
         self.assertEqual(settings[0]['attr'], 'foo')
         self.assertEqual(settings[1]['attr'], 'bar')
 
-class TestDefaultForbiddenView(unittest.TestCase):
+class TestDefaultForbiddenView(BaseTest, unittest.TestCase):
     def _callFUT(self, context, request):
         from repoze.bfg.view import default_forbidden_view
         return default_forbidden_view(context, request)
 
     def test_nomessage(self):
-        request = DummyRequest({})
-        context = DummyContext()
+        request = self._makeRequest()
+        context = self._makeContext()
         response = self._callFUT(context, request)
         self.assertEqual(response.status, '401 Unauthorized')
         self.failUnless('<code></code>' in response.body)
 
     def test_withmessage(self):
-        request = DummyRequest({'repoze.bfg.message':'abc&123'})
-        context = DummyContext()
+        request = self._makeRequest()
+        request.environ['repoze.bfg.message'] = 'abc&123'
+        context = self._makeContext()
         response = self._callFUT(context, request)
         self.assertEqual(response.status, '401 Unauthorized')
         self.failUnless('<code>abc&amp;123</code>' in response.body)
 
-class TestDefaultNotFoundView(unittest.TestCase):
+class TestDefaultNotFoundView(BaseTest, unittest.TestCase):
     def _callFUT(self, context, request):
         from repoze.bfg.view import default_notfound_view
         return default_notfound_view(context, request)
 
     def test_nomessage(self):
-        request = DummyRequest({})
-        context = DummyContext()
+        request = self._makeRequest()
+        context = self._makeContext()
         response = self._callFUT(context, request)
         self.assertEqual(response.status, '404 Not Found')
         self.failUnless('<code></code>' in response.body)
 
     def test_withmessage(self):
-        request = DummyRequest({'repoze.bfg.message':'abc&123'})
-        context = DummyContext()
+        request = self._makeRequest()
+        request.environ['repoze.bfg.message'] = 'abc&123'
+        context = self._makeContext()
         response = self._callFUT(context, request)
         self.assertEqual(response.status, '404 Not Found')
         self.failUnless('<code>abc&amp;123</code>' in response.body)
 
-class AppendSlashNotFoundView(unittest.TestCase):
-    def setUp(self):
-        cleanUp()
-
-    def tearDown(self):
-        cleanUp()
-        
+class AppendSlashNotFoundView(BaseTest, unittest.TestCase):
     def _callFUT(self, context, request):
         from repoze.bfg.view import append_slash_notfound_view
         return append_slash_notfound_view(context, request)
 
-    def _registerMapper(self, match=True):
+    def _registerMapper(self, reg, match=True):
         from repoze.bfg.interfaces import IRoutesMapper
         class DummyRoute(object):
             def __init__(self, val):
@@ -493,354 +420,38 @@ class AppendSlashNotFoundView(unittest.TestCase):
             def get_routes(self):
                 return self.routelist
         mapper = DummyMapper()
-        import zope.component
-        sm = zope.component.getSiteManager()
-        sm.registerUtility(mapper, IRoutesMapper)
+        reg.registerUtility(mapper, IRoutesMapper)
         return mapper
 
     def test_no_mapper(self):
-        request = DummyRequest({'PATH_INFO':'/abc'})
+        request = self._makeRequest(PATH_INFO='/abc')
         context = DummyContext()
         response = self._callFUT(context, request)
         self.assertEqual(response.status, '404 Not Found')
 
     def test_no_path(self):
-        self._registerMapper(True)
-        request = DummyRequest({})
-        context = DummyContext()
+        request = self._makeRequest()
+        context = self._makeContext()
+        self._registerMapper(request.registry, True)
         response = self._callFUT(context, request)
         self.assertEqual(response.status, '404 Not Found')
 
     def test_mapper_path_already_slash_ending(self):
-        self._registerMapper(True)
-        request = DummyRequest({'PATH_INFO':'/abc/'})
+        request = self._makeRequest(PATH_INFO='/abc/')
         context = DummyContext()
+        self._registerMapper(request.registry, True)
         response = self._callFUT(context, request)
         self.assertEqual(response.status, '404 Not Found')
 
     def test_matches(self):
-        self._registerMapper(True)
-        request = DummyRequest({'PATH_INFO':'/abc'})
+        request = self._makeRequest(PATH_INFO='/abc')
         context = DummyContext()
+        self._registerMapper(request.registry, True)
         response = self._callFUT(context, request)
         self.assertEqual(response.status, '302 Found')
         self.assertEqual(response.location, '/abc/')
 
 
-class TestDeriveView(unittest.TestCase):
-    def setUp(self):
-        cleanUp()
-
-    def tearDown(self):
-        cleanUp()
-        
-    def _callFUT(self, view, *arg, **kw):
-        from repoze.bfg.view import derive_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, **settings):
-        from repoze.bfg.interfaces import ISettings
-        from zope.component import getSiteManager
-        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):
-        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.failIf(hasattr(result, '__call_permissive__'))
-        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.failIf(hasattr(result, '__call_permissive__'))
-        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.failIf(hasattr(result, '__call_permissive__'))
-        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.failIf(hasattr(result, '__call_permissive__'))
-        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.failIf(hasattr(result, '__call_permissive__'))
-        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.failIf(hasattr(result, '__call_permissive__'))
-        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.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, reload_templates=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, reload_templates=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, reload_templates=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.exceptions import Forbidden
-        def view(context, request):
-            """ """
-        self._registerSettings(debug_authorization=True, reload_templates=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(Forbidden, 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, reload_templates=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.exceptions 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])
-
-    def test_view_with_wrapper_viewname(self):
-        from webob import Response
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IView
-        inner_response = Response('OK')
-        def inner_view(context, request):
-            return inner_response
-        def outer_view(context, request):
-            self.assertEqual(request.wrapped_response, inner_response)
-            self.assertEqual(request.wrapped_body, inner_response.body)
-            self.assertEqual(request.wrapped_view, inner_view)
-            return Response('outer ' + request.wrapped_body)
-        sm = getSiteManager()
-        sm.registerAdapter(outer_view, (None, None), IView, 'owrap')
-        result = self._callFUT(inner_view, viewname='inner',
-                               wrapper_viewname='owrap')
-        self.failIf(result is inner_view)
-        self.assertEqual(inner_view.__module__, result.__module__)
-        self.assertEqual(inner_view.__doc__, result.__doc__)
-        request = DummyRequest()
-        response = result(None, request)
-        self.assertEqual(response.body, 'outer OK')
-
-    def test_view_with_wrapper_viewname_notfound(self):
-        from webob import Response
-        inner_response = Response('OK')
-        def inner_view(context, request):
-            return inner_response
-        request = DummyRequest()
-        wrapped = self._callFUT(
-            inner_view, viewname='inner', wrapper_viewname='owrap')
-        result = self.assertRaises(ValueError, wrapped, None, request)
-
 class DummyContext:
     pass
 
@@ -870,21 +481,7 @@ class DummyResponse:
             self.app_iter = ()
         else:
             self.app_iter = [body]
-            
-class DummyLogger:
-    def __init__(self):
-        self.messages = []
-    def info(self, msg):
-        self.messages.append(msg)
-    warn = info
-    debug = info
-
-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
+
+from zope.interface import Interface
+class IContext(Interface):
+    pass