massive test rejiggering to account for the addition of response_resolved_view

2 files changed, 154 insertions, 118 deletions

diff --git a/pyramid/config.py b/pyramid/config.py
index 918331405..41af9e832 100644
--- a/pyramid/config.py
+++ b/pyramid/config.py
@@ -2866,54 +2866,42 @@ class MultiView(object):
                 continue
         raise PredicateMismatch(self.name)
 
-def wraps_view(wrapped):
+def wraps_view(wrapper):
     def inner(self, view):
-        wrapped_view = wrapped(self, view)
-        return preserve_view_attrs(view, wrapped_view)
+        wrapper_view = wrapper(self, view)
+        return preserve_view_attrs(view, wrapper_view)
     return inner
 
-def preserve_view_attrs(view, wrapped_view):
-    if wrapped_view is view:
+def preserve_view_attrs(view, wrapper):
+    if wrapper is view:
         return view
+
     original_view = getattr(view, '__original_view__', None)
+
     if original_view is None:
         original_view = view
-    wrapped_view.__original_view__ = original_view
-    wrapped_view.__module__ = view.__module__
-    wrapped_view.__doc__ = view.__doc__
-    try:
-        wrapped_view.__name__ = view.__name__
-    except AttributeError:
-        wrapped_view.__name__ = repr(view)
-    try:
-        wrapped_view.__permitted__ = view.__permitted__
-    except AttributeError:
-        pass
-    try:
-        wrapped_view.__call_permissive__ = view.__call_permissive__
-    except AttributeError:
-        pass
-    try:
-        wrapped_view.__permission__ = view.__permission__
-    except AttributeError:
-        pass
-    try:
-        wrapped_view.__predicated__ = view.__predicated__
-    except AttributeError:
-        pass
-    try:
-        wrapped_view.__predicates__ = view.__predicates__
-    except AttributeError:
-        pass
-    try:
-        wrapped_view.__accept__ = view.__accept__
-    except AttributeError:
-        pass
+
+    wrapper.__wraps__ = view
+    wrapper.__original_view__ = original_view
+    wrapper.__module__ = view.__module__
+    wrapper.__doc__ = view.__doc__
+
     try:
-        wrapped_view.__order__ = view.__order__
+        wrapper.__name__ = view.__name__
     except AttributeError:
-        pass
-    return wrapped_view
+        wrapper.__name__ = repr(view)
+
+    # attrs that may not exist on "view", but, if so, must be attached to
+    # "wrapped view"
+    for attr in ('__permitted__', '__call_permissive__', '__permission__',
+                 '__predicated__', '__predicates__', '__accept__',
+                 '__order__'):
+        try:
+            setattr(wrapper, attr, getattr(view, attr))
+        except AttributeError:
+            pass
+
+    return wrapper
 
 class ViewDeriver(object):
     def __init__(self, **kw):
@@ -2938,6 +2926,10 @@ class ViewDeriver(object):
     @wraps_view
     def response_resolved_view(self, view):
         registry = self.registry
+        if hasattr(registry, '_dont_resolve_responses'):
+            # for Pyramid unit tests only
+            return view
+
         def viewresult_to_response(context, request):
             result = view(context, request)
             response = registry.queryAdapterOrSelf(result, IResponse)
@@ -2946,6 +2938,7 @@ class ViewDeriver(object):
                     'Could not convert view return value "%s" into a '
                     'response object' % (result,))
             return response
+
         return viewresult_to_response
 
     @wraps_view
diff --git a/pyramid/tests/test_config.py b/pyramid/tests/test_config.py
index 255dd4b6e..4827cdd70 100644
--- a/pyramid/tests/test_config.py
+++ b/pyramid/tests/test_config.py
@@ -10,7 +10,9 @@ except:
 class ConfiguratorTests(unittest.TestCase):
     def _makeOne(self, *arg, **kw):
         from pyramid.config import Configurator
-        return Configurator(*arg, **kw)
+        config = Configurator(*arg, **kw)
+        config.registry._dont_resolve_responses = True
+        return config
 
     def _registerRenderer(self, config, name='.txt'):
         from pyramid.interfaces import IRendererFactory
@@ -211,7 +213,7 @@ class ConfiguratorTests(unittest.TestCase):
         view = self._getViewCallable(config,
                                      ctx_iface=IExceptionResponse,
                                      request_iface=IRequest)
-        self.assertTrue(view is default_exceptionresponse_view)
+        self.assertTrue(view.__wraps__ is default_exceptionresponse_view)
 
     def test_ctor_exceptionresponse_view_None(self):
         from pyramid.interfaces import IExceptionResponse
@@ -230,7 +232,7 @@ class ConfiguratorTests(unittest.TestCase):
         view = self._getViewCallable(config,
                                      ctx_iface=IExceptionResponse,
                                      request_iface=IRequest)
-        self.assertTrue(view is exceptionresponse_view)
+        self.assertTrue(view.__wraps__ is exceptionresponse_view)
 
     def test_with_package_module(self):
         from pyramid.tests import test_configuration
@@ -3190,8 +3192,10 @@ class TestConfiguratorDeprecatedFeatures(unittest.TestCase):
 
     def _makeOne(self, *arg, **kw):
         from pyramid.config import Configurator
-        return Configurator(*arg, **kw)
-
+        config = Configurator(*arg, **kw)
+        config.registry._dont_resolve_responses = True
+        return config
+    
     def _getRouteRequestIface(self, config, name):
         from pyramid.interfaces import IRouteRequest
         iface = config.registry.getUtility(IRouteRequest, name)
@@ -3498,29 +3502,31 @@ class TestViewDeriver(unittest.TestCase):
         self.config.registry.registerUtility(policy, IAuthorizationPolicy)
 
     def test_requestonly_function(self):
+        response = DummyResponse()
         def view(request):
-            return 'OK'
+            return response
         deriver = self._makeOne()
         result = deriver(view)
         self.assertFalse(result is view)
-        self.assertEqual(result(None, None), 'OK')
+        self.assertEqual(result(None, None), response)
 
     def test_requestonly_function_with_renderer(self):
+        response = DummyResponse()
         class moo(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
                 self.assertEqual(resp, 'OK')
                 self.assertEqual(view_inst, view)
                 self.assertEqual(ctx, context)
-                return 'moo'
+                return response
         def view(request):
             return 'OK'
         deriver = self._makeOne(renderer=moo())
         result = deriver(view)
-        self.assertFalse(result is view)
+        self.assertFalse(result.__wraps__ is view)
         request = self._makeRequest()
         context = testing.DummyResource()
-        self.assertEqual(result(context, request), 'moo')
+        self.assertEqual(result(context, request), response)
 
     def test_requestonly_function_with_renderer_request_override(self):
         def moo(info):
@@ -3542,46 +3548,50 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(result(context, request).body, 'moo')
 
     def test_requestonly_function_with_renderer_request_has_view(self):
+        response = DummyResponse()
         class moo(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
                 self.assertEqual(resp, 'OK')
                 self.assertEqual(view_inst, 'view')
                 self.assertEqual(ctx, context)
-                return 'moo'
+                return response
         def view(request):
             return 'OK'
         deriver = self._makeOne(renderer=moo())
         result = deriver(view)
-        self.assertFalse(result is view)
+        self.assertFalse(result.__wraps__ is view)
         request = self._makeRequest()
         request.__view__ = 'view'
         context = testing.DummyResource()
-        self.assertEqual(result(context, request), 'moo')
+        r = result(context, request)
+        self.assertEqual(r, response)
         self.assertFalse(hasattr(request, '__view__'))
 
     def test_class_without_attr(self):
+        response = DummyResponse()
         class View(object):
             def __init__(self, request):
                 pass
             def __call__(self):
-                return 'OK'
+                return response
         deriver = self._makeOne()
         result = deriver(View)
         request = self._makeRequest()
-        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(result(None, request), response)
         self.assertEqual(request.__view__.__class__, View)
 
     def test_class_with_attr(self):
+        response = DummyResponse()
         class View(object):
             def __init__(self, request):
                 pass
             def another(self):
-                return 'OK'
+                return response
         deriver = self._makeOne(attr='another')
         result = deriver(View)
         request = self._makeRequest()
-        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(result(None, request), response)
         self.assertEqual(request.__view__.__class__, View)
 
     def test_as_function_context_and_request(self):
@@ -3589,13 +3599,14 @@ class TestViewDeriver(unittest.TestCase):
             return 'OK'
         deriver = self._makeOne()
         result = deriver(view)
-        self.assertTrue(result is view)
+        self.assertTrue(result.__wraps__ is view)
         self.assertFalse(hasattr(result, '__call_permissive__'))
         self.assertEqual(view(None, None), 'OK')
 
     def test_as_function_requestonly(self):
+        response = DummyResponse()
         def view(request):
-            return 'OK'
+            return response
         deriver = self._makeOne()
         result = deriver(view)
         self.assertFalse(result is view)
@@ -3603,14 +3614,15 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
         self.assertFalse(hasattr(result, '__call_permissive__'))
-        self.assertEqual(result(None, None), 'OK')
+        self.assertEqual(result(None, None), response)
 
     def test_as_newstyle_class_context_and_request(self):
+        response = DummyResponse()
         class view(object):
             def __init__(self, context, request):
                 pass
             def __call__(self):
-                return 'OK'
+                return response
         deriver = self._makeOne()
         result = deriver(view)
         self.assertFalse(result is view)
@@ -3619,15 +3631,16 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(view.__name__, result.__name__)
         self.assertFalse(hasattr(result, '__call_permissive__'))
         request = self._makeRequest()
-        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(result(None, request), response)
         self.assertEqual(request.__view__.__class__, view)
 
     def test_as_newstyle_class_requestonly(self):
+        response = DummyResponse()
         class view(object):
             def __init__(self, context, request):
                 pass
             def __call__(self):
-                return 'OK'
+                return response
         deriver = self._makeOne()
         result = deriver(view)
         self.assertFalse(result is view)
@@ -3636,15 +3649,16 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(view.__name__, result.__name__)
         self.assertFalse(hasattr(result, '__call_permissive__'))
         request = self._makeRequest()
-        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(result(None, request), response)
         self.assertEqual(request.__view__.__class__, view)
 
     def test_as_oldstyle_class_context_and_request(self):
+        response = DummyResponse()
         class view:
             def __init__(self, context, request):
                 pass
             def __call__(self):
-                return 'OK'
+                return response
         deriver = self._makeOne()
         result = deriver(view)
         self.assertFalse(result is view)
@@ -3653,15 +3667,16 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(view.__name__, result.__name__)
         self.assertFalse(hasattr(result, '__call_permissive__'))
         request = self._makeRequest()
-        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(result(None, request), response)
         self.assertEqual(request.__view__.__class__, view)
 
     def test_as_oldstyle_class_requestonly(self):
+        response = DummyResponse()
         class view:
             def __init__(self, context, request):
                 pass
             def __call__(self):
-                return 'OK'
+                return response
         deriver = self._makeOne()
         result = deriver(view)
         self.assertFalse(result is view)
@@ -3670,24 +3685,26 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(view.__name__, result.__name__)
         self.assertFalse(hasattr(result, '__call_permissive__'))
         request = self._makeRequest()
-        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(result(None, request), response)
         self.assertEqual(request.__view__.__class__, view)
 
     def test_as_instance_context_and_request(self):
+        response = DummyResponse()
         class View:
             def __call__(self, context, request):
-                return 'OK'
+                return response
         view = View()
         deriver = self._makeOne()
         result = deriver(view)
-        self.assertTrue(result is view)
+        self.assertTrue(result.__wraps__ is view)
         self.assertFalse(hasattr(result, '__call_permissive__'))
-        self.assertEqual(result(None, None), 'OK')
+        self.assertEqual(result(None, None), response)
 
     def test_as_instance_requestonly(self):
+        response = DummyResponse()
         class View:
             def __call__(self, request):
-                return 'OK'
+                return response
         view = View()
         deriver = self._makeOne()
         result = deriver(view)
@@ -3696,10 +3713,11 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertTrue('instance' in result.__name__)
         self.assertFalse(hasattr(result, '__call_permissive__'))
-        self.assertEqual(result(None, None), 'OK')
+        self.assertEqual(result(None, None), response)
 
     def test_with_debug_authorization_no_authpol(self):
-        view = lambda *arg: 'OK'
+        response = DummyResponse()
+        view = lambda *arg: response
         self.config.registry.settings = dict(
             debug_authorization=True, reload_templates=True)
         logger = self._registerLogger()
@@ -3712,7 +3730,7 @@ class TestViewDeriver(unittest.TestCase):
         request = self._makeRequest()
         request.view_name = 'view_name'
         request.url = 'url'
-        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(result(None, request), response)
         self.assertEqual(len(logger.messages), 1)
         self.assertEqual(logger.messages[0],
                          "debug_authorization of url url (view name "
@@ -3720,7 +3738,8 @@ class TestViewDeriver(unittest.TestCase):
                          "(no authorization policy in use)")
 
     def test_with_debug_authorization_authn_policy_no_authz_policy(self):
-        view = lambda *arg: 'OK'
+        response = DummyResponse()
+        view = lambda *arg: response
         self.config.registry.settings = dict(debug_authorization=True)
         from pyramid.interfaces import IAuthenticationPolicy
         policy = DummySecurityPolicy(False)
@@ -3735,7 +3754,7 @@ class TestViewDeriver(unittest.TestCase):
         request = self._makeRequest()
         request.view_name = 'view_name'
         request.url = 'url'
-        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(result(None, request), response)
         self.assertEqual(len(logger.messages), 1)
         self.assertEqual(logger.messages[0],
                          "debug_authorization of url url (view name "
@@ -3743,7 +3762,8 @@ class TestViewDeriver(unittest.TestCase):
                          "(no authorization policy in use)")
 
     def test_with_debug_authorization_authz_policy_no_authn_policy(self):
-        view = lambda *arg: 'OK'
+        response = DummyResponse()
+        view = lambda *arg: response
         self.config.registry.settings = dict(debug_authorization=True)
         from pyramid.interfaces import IAuthorizationPolicy
         policy = DummySecurityPolicy(False)
@@ -3758,7 +3778,7 @@ class TestViewDeriver(unittest.TestCase):
         request = self._makeRequest()
         request.view_name = 'view_name'
         request.url = 'url'
-        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(result(None, request), response)
         self.assertEqual(len(logger.messages), 1)
         self.assertEqual(logger.messages[0],
                          "debug_authorization of url url (view name "
@@ -3766,7 +3786,8 @@ class TestViewDeriver(unittest.TestCase):
                          "(no authorization policy in use)")
 
     def test_with_debug_authorization_no_permission(self):
-        view = lambda *arg: 'OK'
+        response = DummyResponse()
+        view = lambda *arg: response
         self.config.registry.settings = dict(
             debug_authorization=True, reload_templates=True)
         self._registerSecurityPolicy(True)
@@ -3780,7 +3801,7 @@ class TestViewDeriver(unittest.TestCase):
         request = self._makeRequest()
         request.view_name = 'view_name'
         request.url = 'url'
-        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(result(None, request), response)
         self.assertEqual(len(logger.messages), 1)
         self.assertEqual(logger.messages[0],
                          "debug_authorization of url url (view name "
@@ -3788,7 +3809,8 @@ class TestViewDeriver(unittest.TestCase):
                          "no permission registered)")
 
     def test_debug_auth_permission_authpol_permitted(self):
-        view = lambda *arg: 'OK'
+        response = DummyResponse()
+        view = lambda *arg: response
         self.config.registry.settings = dict(
             debug_authorization=True, reload_templates=True)
         logger = self._registerLogger()
@@ -3798,18 +3820,19 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result.__call_permissive__, view)
+        self.assertEqual(result.__call_permissive__.__wraps__, view)
         request = self._makeRequest()
         request.view_name = 'view_name'
         request.url = 'url'
-        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(result(None, request), response)
         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_debug_auth_permission_authpol_permitted_no_request(self):
-        view = lambda *arg: 'OK'
+        response = DummyResponse()
+        view = lambda *arg: response
         self.config.registry.settings = dict(
             debug_authorization=True, reload_templates=True)
         logger = self._registerLogger()
@@ -3819,8 +3842,8 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result.__call_permissive__, view)
-        self.assertEqual(result(None, None), 'OK')
+        self.assertEqual(result.__call_permissive__.__wraps__, view)
+        self.assertEqual(result(None, None), response)
         self.assertEqual(len(logger.messages), 1)
         self.assertEqual(logger.messages[0],
                          "debug_authorization of url None (view name "
@@ -3828,7 +3851,8 @@ class TestViewDeriver(unittest.TestCase):
 
     def test_debug_auth_permission_authpol_denied(self):
         from pyramid.httpexceptions import HTTPForbidden
-        view = lambda *arg: 'OK'
+        response = DummyResponse()
+        view = lambda *arg: response
         self.config.registry.settings = dict(
             debug_authorization=True, reload_templates=True)
         logger = self._registerLogger()
@@ -3838,7 +3862,7 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(view.__module__, result.__module__)
         self.assertEqual(view.__doc__, result.__doc__)
         self.assertEqual(view.__name__, result.__name__)
-        self.assertEqual(result.__call_permissive__, view)
+        self.assertEqual(result.__call_permissive__.__wraps__, view)
         request = self._makeRequest()
         request.view_name = 'view_name'
         request.url = 'url'
@@ -3866,7 +3890,8 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(permitted, False)
 
     def test_debug_auth_permission_authpol_overridden(self):
-        view = lambda *arg: 'OK'
+        response = DummyResponse()
+        view = lambda *arg: response
         self.config.registry.settings = dict(
             debug_authorization=True, reload_templates=True)
         logger = self._registerLogger()
@@ -3880,14 +3905,15 @@ class TestViewDeriver(unittest.TestCase):
         request = self._makeRequest()
         request.view_name = 'view_name'
         request.url = 'url'
-        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(result(None, request), response)
         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_secured_view_authn_policy_no_authz_policy(self):
-        view = lambda *arg: 'OK'
+        response = DummyResponse()
+        view = lambda *arg: response
         self.config.registry.settings = {}
         from pyramid.interfaces import IAuthenticationPolicy
         policy = DummySecurityPolicy(False)
@@ -3901,10 +3927,11 @@ class TestViewDeriver(unittest.TestCase):
         request = self._makeRequest()
         request.view_name = 'view_name'
         request.url = 'url'
-        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(result(None, request), response)
 
     def test_secured_view_authz_policy_no_authn_policy(self):
-        view = lambda *arg: 'OK'
+        response = DummyResponse()
+        view = lambda *arg: response
         self.config.registry.settings = {}
         from pyramid.interfaces import IAuthorizationPolicy
         policy = DummySecurityPolicy(False)
@@ -3918,10 +3945,11 @@ class TestViewDeriver(unittest.TestCase):
         request = self._makeRequest()
         request.view_name = 'view_name'
         request.url = 'url'
-        self.assertEqual(result(None, request), 'OK')
+        self.assertEqual(result(None, request), response)
 
     def test_with_predicates_all(self):
-        view = lambda *arg: 'OK'
+        response = DummyResponse()
+        view = lambda *arg: response
         predicates = []
         def predicate1(context, request):
             predicates.append(True)
@@ -3934,7 +3962,7 @@ class TestViewDeriver(unittest.TestCase):
         request = self._makeRequest()
         request.method = 'POST'
         next = result(None, None)
-        self.assertEqual(next, 'OK')
+        self.assertEqual(next, response)
         self.assertEqual(predicates, [True, True])
 
     def test_with_predicates_checker(self):
@@ -4007,13 +4035,14 @@ class TestViewDeriver(unittest.TestCase):
         self.assertRaises(ValueError, wrapped, None, request)
 
     def test_as_newstyle_class_context_and_request_attr_and_renderer(self):
+        response = DummyResponse()
         class renderer(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
                 self.assertEqual(resp, {'a':'1'})
                 self.assertEqual(view_inst.__class__, View)
                 self.assertEqual(ctx, context)
-                return resp
+                return response
         class View(object):
             def __init__(self, context, request):
                 pass
@@ -4027,16 +4056,17 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(result.__name__, View.__name__)
         request = self._makeRequest()
         context = testing.DummyResource()
-        self.assertEqual(result(context, request), {'a':'1'})
+        self.assertEqual(result(context, request), response)
 
     def test_as_newstyle_class_requestonly_attr_and_renderer(self):
+        response = DummyResponse()
         class renderer(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
                 self.assertEqual(resp, {'a':'1'})
                 self.assertEqual(view_inst.__class__, View)
                 self.assertEqual(ctx, context)
-                return resp
+                return response
         class View(object):
             def __init__(self, request):
                 pass
@@ -4050,16 +4080,17 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(result.__name__, View.__name__)
         request = self._makeRequest()
         context = testing.DummyResource()
-        self.assertEqual(result(context, request), {'a':'1'})
+        self.assertEqual(result(context, request), response)
 
     def test_as_oldstyle_cls_context_request_attr_and_renderer(self):
+        response = DummyResponse()
         class renderer(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
                 self.assertEqual(resp, {'a':'1'})
                 self.assertEqual(view_inst.__class__, View)
                 self.assertEqual(ctx, context)
-                return resp
+                return response
         class View:
             def __init__(self, context, request):
                 pass
@@ -4073,16 +4104,17 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(result.__name__, View.__name__)
         request = self._makeRequest()
         context = testing.DummyResource()
-        self.assertEqual(result(context, request), {'a':'1'})
+        self.assertEqual(result(context, request), response)
 
     def test_as_oldstyle_cls_requestonly_attr_and_renderer(self):
+        response = DummyResponse()
         class renderer(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
                 self.assertEqual(resp, {'a':'1'})
                 self.assertEqual(view_inst.__class__, View)
                 self.assertEqual(ctx, context)
-                return resp
+                return response
         class View:
             def __init__(self, request):
                 pass
@@ -4096,16 +4128,17 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(result.__name__, View.__name__)
         request = self._makeRequest()
         context = testing.DummyResource()
-        self.assertEqual(result(context, request), {'a':'1'})
+        self.assertEqual(result(context, request), response)
 
     def test_as_instance_context_and_request_attr_and_renderer(self):
+        response = DummyResponse()
         class renderer(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
                 self.assertEqual(resp, {'a':'1'})
                 self.assertEqual(view_inst, view)
                 self.assertEqual(ctx, context)
-                return resp
+                return response
         class View:
             def index(self, context, request):
                 return {'a':'1'}
@@ -4117,16 +4150,17 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(result.__doc__, view.__doc__)
         request = self._makeRequest()
         context = testing.DummyResource()
-        self.assertEqual(result(context, request), {'a':'1'})
+        self.assertEqual(result(context, request), response)
 
     def test_as_instance_requestonly_attr_and_renderer(self):
+        response = DummyResponse()
         class renderer(object):
             def render_view(inself, req, resp, view_inst, ctx):
                 self.assertEqual(req, request)
                 self.assertEqual(resp, {'a':'1'})
                 self.assertEqual(view_inst, view)
                 self.assertEqual(ctx, context)
-                return resp
+                return response
         class View:
             def index(self, request):
                 return {'a':'1'}
@@ -4138,58 +4172,63 @@ class TestViewDeriver(unittest.TestCase):
         self.assertEqual(result.__doc__, view.__doc__)
         request = self._makeRequest()
         context = testing.DummyResource()
-        self.assertEqual(result(context, request), {'a':'1'})
+        self.assertEqual(result(context, request), response)
 
     def test_with_view_mapper_config_specified(self):
+        response = DummyResponse()
         class mapper(object):
             def __init__(self, **kw):
                 self.kw = kw
             def __call__(self, view):
                 def wrapped(context, request):
-                    return 'OK'
+                    return response
                 return wrapped
         def view(context, request): return 'NOTOK'
         deriver = self._makeOne(mapper=mapper)
         result = deriver(view)
-        self.assertFalse(result is view)
-        self.assertEqual(result(None, None), 'OK')
+        self.assertFalse(result.__wraps__ is view)
+        self.assertEqual(result(None, None), response)
 
     def test_with_view_mapper_view_specified(self):
+        from pyramid.response import Response
+        response = Response()
         def mapper(**kw):
             def inner(view):
                 def superinner(context, request):
                     self.assertEqual(request, None)
-                    return 'OK'
+                    return response
                 return superinner
             return inner
         def view(context, request): return 'NOTOK'
         view.__view_mapper__ = mapper
         deriver = self._makeOne()
         result = deriver(view)
-        self.assertFalse(result is view)
-        self.assertEqual(result(None, None), 'OK')
+        self.assertFalse(result.__wraps__ is view)
+        self.assertEqual(result(None, None), response)
 
     def test_with_view_mapper_default_mapper_specified(self):
+        from pyramid.response import Response
+        response = Response()
         def mapper(**kw):
             def inner(view):
                 def superinner(context, request):
                     self.assertEqual(request, None)
-                    return 'OK'
+                    return  response
                 return superinner
             return inner
         self.config.set_view_mapper(mapper)
         def view(context, request): return 'NOTOK'
         deriver = self._makeOne()
         result = deriver(view)
-        self.assertFalse(result is view)
-        self.assertEqual(result(None, None), 'OK')
+        self.assertFalse(result.__wraps__ is view)
+        self.assertEqual(result(None, None), response)
 
     def test_attr_wrapped_view_branching_default_phash(self):
         from pyramid.config import DEFAULT_PHASH
         def view(context, request): pass
         deriver = self._makeOne(phash=DEFAULT_PHASH)
         result = deriver(view)
-        self.assertEqual(result, view)
+        self.assertEqual(result.__wraps__, view)
 
     def test_attr_wrapped_view_branching_nondefault_phash(self):
         def view(context, request): pass
@@ -5405,4 +5444,8 @@ def parse_httpdate(s):
 def assert_similar_datetime(one, two):
     for attr in ('year', 'month', 'day', 'hour', 'minute'):
         assert(getattr(one, attr) == getattr(two, attr))
+
+from pyramid.interfaces import IResponse
+class DummyResponse(object):
+    implements(IResponse)