Merge multiview2 branch to HEAD.

1 files changed, 494 insertions, 77 deletions

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]
+