reg -> registry

2 files changed, 90 insertions, 84 deletions

diff --git a/repoze/bfg/configuration.py b/repoze/bfg/configuration.py
index 27a9bd282..3a3a0d893 100644
--- a/repoze/bfg/configuration.py
+++ b/repoze/bfg/configuration.py
@@ -86,12 +86,12 @@ class Configurator(object):
     default), the package is assumed to be the Python package in which
     the *caller* of the ``Configurator`` constructor lives.
     """
-    def __init__(self, registry=None, package=None):
+    def __init__(self, registry=None, package=None, settings=None):
         self.package = package or caller_package()
-        self.reg = registry
+        self.registry = registry
         if registry is None:
             registry = Registry(self.package.__name__)
-            self.reg = registry
+            self.registry = registry
             self._default_configuration()
 
     def _default_configuration(self):
@@ -108,16 +108,16 @@ class Configurator(object):
         the current configuration state."""
         # manager and getSiteManager in arglist for testing dep injection only
         from repoze.bfg.router import Router # avoid circdep
-        app = Router(self.reg)
+        app = Router(self.registry)
         # executing sethook means we're taking over getSiteManager for
         # the lifetime of this process
         getSiteManager.sethook(get_current_registry)
         # We push the registry on to the stack here in case any ZCA API is
         # used in listeners subscribed to the WSGIApplicationCreatedEvent
         # we send.
-        manager.push({'registry':self.reg, 'request':None})
+        manager.push({'registry':self.registry, 'request':None})
         try:
-            self.reg.notify(WSGIApplicationCreatedEvent(app))
+            self.registry.notify(WSGIApplicationCreatedEvent(app))
         finally:
             manager.pop()
         return app
@@ -182,7 +182,7 @@ class Configurator(object):
             package = sys.modules[package_name]
 
         lock.acquire()
-        manager.push({'registry':self.reg, 'request':None})
+        manager.push({'registry':self.registry, 'request':None})
         try:
             getSiteManager.sethook(get_current_registry)
             zope.component.getGlobalSiteManager = get_current_registry
@@ -192,7 +192,7 @@ class Configurator(object):
             lock.release()
             manager.pop()
             getSiteManager.reset()
-        return self.reg
+        return self.registry
 
     def view(self, view=None, name="", for_=None, permission=None, 
              request_type=None, route_name=None, request_method=None,
@@ -220,11 +220,12 @@ class Configurator(object):
             request_type = IRequest
 
         if route_name is not None:
-            request_type = self.reg.queryUtility(IRouteRequest, name=route_name)
+            request_type = self.registry.queryUtility(IRouteRequest,
+                                                      name=route_name)
             if request_type is None:
                 request_type = route_request_iface(route_name)
-                self.reg.registerUtility(request_type, IRouteRequest,
-                                         name=route_name)
+                self.registry.registerUtility(request_type, IRouteRequest,
+                                              name=route_name)
 
         score, predicates = _make_predicates(
             xhr=xhr, request_method=request_method, path_info=path_info,
@@ -241,15 +242,15 @@ class Configurator(object):
             r_for_ = implementedBy(r_for_)
         if not IInterface.providedBy(r_request_type):
             r_request_type = implementedBy(r_request_type)
-        old_view = self.reg.adapters.lookup((r_for_, r_request_type),
-                                            IView, name=name)
+        old_view = self.registry.adapters.lookup((r_for_, r_request_type),
+                                                 IView, name=name)
         if old_view is None:
             if hasattr(derived_view, '__call_permissive__'):
                 view_iface = ISecuredView
             else:
                 view_iface = IView
-            self.reg.registerAdapter(derived_view, (for_, request_type),
-                                     view_iface, name, info=_info)
+            self.registry.registerAdapter(derived_view, (for_, request_type),
+                                          view_iface, name, info=_info)
         else:
             # XXX we could try to be more efficient here and register
             # a non-secured view for a multiview if none of the
@@ -264,20 +265,19 @@ class Configurator(object):
             multiview.add(derived_view, score)
             for i in (IView, ISecuredView):
                 # unregister any existing views
-                self.reg.adapters.unregister((r_for_, r_request_type), i,
-                                             name=name)
-            self.reg.registerAdapter(multiview, (for_, request_type),
-                                     IMultiView, name, info=_info)
+                self.registry.adapters.unregister((r_for_, r_request_type), i,
+                                                  name=name)
+            self.registry.registerAdapter(multiview, (for_, request_type),
+                                          IMultiView, name, info=_info)
 
     def derive_view(self, view, permission=None, predicates=(),
                     attr=None, renderer_name=None, wrapper_viewname=None,
                     viewname=None):
-        reg = self.reg
         renderer = self.renderer_from_name(renderer_name)
-        authn_policy = self.reg.queryUtility(IAuthenticationPolicy)
-        authz_policy = self.reg.queryUtility(IAuthorizationPolicy)
-        settings = self.reg.queryUtility(ISettings)
-        logger = self.reg.queryUtility(ILogger, 'repoze.bfg.debug')
+        authn_policy = self.registry.queryUtility(IAuthenticationPolicy)
+        authz_policy = self.registry.queryUtility(IAuthorizationPolicy)
+        settings = self.registry.queryUtility(ISettings)
+        logger = self.registry.queryUtility(ILogger, 'repoze.bfg.debug')
         mapped_view = _map_view(view, attr, renderer, renderer_name)
         owrapped_view = _owrap_view(mapped_view, viewname, wrapper_viewname)
         secured_view = _secure_view(owrapped_view, permission,
@@ -291,7 +291,7 @@ class Configurator(object):
     def renderer_from_name(self, path_or_spec):
         if path_or_spec is None:
             # check for global default renderer
-            factory = self.reg.queryUtility(IRendererFactory)
+            factory = self.registry.queryUtility(IRendererFactory)
             if factory is not None:
                 return factory(path_or_spec)
             return None
@@ -303,7 +303,7 @@ class Configurator(object):
             name = path_or_spec
             spec = path_or_spec
 
-        factory = self.reg.queryUtility(IRendererFactory, name=name)
+        factory = self.registry.queryUtility(IRendererFactory, name=name)
         if factory is None:
             raise ValueError('No renderer for renderer name %r' % name)
         return factory(spec)
@@ -329,10 +329,11 @@ class Configurator(object):
                                          header=header,
                                          accept=accept)
 
-        request_iface = self.reg.queryUtility(IRouteRequest, name=name)
+        request_iface = self.registry.queryUtility(IRouteRequest, name=name)
         if request_iface is None:
             request_iface = route_request_iface(name)
-            self.reg.registerUtility(request_iface, IRouteRequest, name=name)
+            self.registry.registerUtility(
+                request_iface, IRouteRequest, name=name)
 
         if view:
             view_for = view_for or for_
@@ -356,10 +357,10 @@ class Configurator(object):
                 _info=_info,
                 )
 
-        mapper = self.reg.queryUtility(IRoutesMapper)
+        mapper = self.registry.queryUtility(IRoutesMapper)
         if mapper is None:
             mapper = RoutesMapper()
-            self.reg.registerUtility(mapper, IRoutesMapper)
+            self.registry.registerUtility(mapper, IRoutesMapper)
         mapper.connect(path, name, factory, predicates=predicates)
 
     def scan(self, package, _info=u'', martian=martian):
@@ -378,12 +379,12 @@ class Configurator(object):
     def authentication_policy(self, policy, _info=u''):
         """ Add a :mod:`repoze.bfg` :term:`authentication policy` to
         the current configuration."""
-        self.reg.registerUtility(policy, IAuthenticationPolicy, info=_info)
+        self.registry.registerUtility(policy, IAuthenticationPolicy, info=_info)
         
     def authorization_policy(self, policy, _info=u''):
         """ Add a :mod:`repoze.bfg` :term:`authorization policy` to
         the current configuration state."""
-        self.reg.registerUtility(policy, IAuthorizationPolicy, info=_info)
+        self.registry.registerUtility(policy, IAuthorizationPolicy, info=_info)
 
     def renderer(self, factory, name, _info=u''):
         """ Add a :mod:`repoze.bfg` :term:`renderer` to the current
@@ -391,7 +392,7 @@ class Configurator(object):
         iface = IRendererFactory
         if name.startswith('.'):
             iface = ITemplateRendererFactory
-        self.reg.registerUtility(factory, iface, name=name, info=_info)
+        self.registry.registerUtility(factory, iface, name=name, info=_info)
 
     def resource(self, to_override, override_with, _info=u'', _override=None,):
         """ Add a :mod:`repoze.bfg` resource override to the current
@@ -436,11 +437,12 @@ class Configurator(object):
                   _info=u'', PackageOverrides=PackageOverrides):
             pkg_name = package.__name__
             override_pkg_name = override_package.__name__
-            override = self.reg.queryUtility(IPackageOverrides, name=pkg_name)
+            override = self.registry.queryUtility(
+                IPackageOverrides, name=pkg_name)
             if override is None:
                 override = PackageOverrides(package)
-                self.reg.registerUtility(override, IPackageOverrides,
-                                         name=pkg_name, info=_info)
+                self.registry.registerUtility(override, IPackageOverrides,
+                                              name=pkg_name, info=_info)
             override.insert(path, override_pkg_name, override_prefix)
 
     def forbidden(self, *arg, **kw):
@@ -468,7 +470,7 @@ class Configurator(object):
         derived_view = self.derive_view(view, attr=attr,
                                         renderer_name=renderer,
                                         wrapper_viewname=wrapper)
-        self.reg.registerUtility(derived_view, iface, '', info=_info)
+        self.registry.registerUtility(derived_view, iface, '', info=_info)
 
     def static(self, name, path, cache_max_age=3600, _info=u''):
         """ Add a static view to the current configuration state."""
@@ -483,18 +485,18 @@ class Configurator(object):
         of the value returned by the
         ``repoze.bfg.settings.get_settings`` API."""
         settings = Settings(settings)
-        self.reg.registerUtility(settings, ISettings)
+        self.registry.registerUtility(settings, ISettings)
 
     def debug_logger(self, logger):
         if logger is None:
             logger = make_stream_logger('repoze.bfg.debug', sys.stderr)
-        self.reg.registerUtility(logger, ILogger, 'repoze.bfg.debug')
+        self.registry.registerUtility(logger, ILogger, 'repoze.bfg.debug')
 
     def root_factory(self, factory):
         """ Add a :term:`root factory` to the current configuration
         state."""
-        self.reg.registerUtility(factory, IRootFactory)
-        self.reg.registerUtility(factory, IDefaultRootFactory) # b/c
+        self.registry.registerUtility(factory, IRootFactory)
+        self.registry.registerUtility(factory, IDefaultRootFactory) # b/c
         
 def _make_predicates(xhr=None, request_method=None, path_info=None,
                      request_param=None, header=None, accept=None,
diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py
index 0c13385ba..0fdf1922a 100644
--- a/repoze/bfg/tests/test_configuration.py
+++ b/repoze/bfg/tests/test_configuration.py
@@ -20,7 +20,7 @@ class ConfiguratorTests(unittest.TestCase):
                 self.__class__.path = path
             def __call__(self, *arg):
                 return 'Hello!'
-        config.reg.registerUtility(Renderer, IRendererFactory, name=name)
+        config.registry.registerUtility(Renderer, IRendererFactory, name=name)
         return Renderer
 
     def _getViewCallable(self, config, ctx_iface=None, request_iface=None,
@@ -32,18 +32,18 @@ class ConfiguratorTests(unittest.TestCase):
             ctx_iface = Interface
         if request_iface is None:
             request_iface = IRequest
-        return config.reg.adapters.lookup(
+        return config.registry.adapters.lookup(
             (ctx_iface, request_iface), IView, name=name,
             default=None)
 
     def _callDeclarative(self, *arg, **kw):
         inst = self._makeOne()
         inst.declarative(*arg, **kw)
-        return inst.reg
+        return inst.registry
 
     def _getRouteRequestIface(self, config, name):
         from repoze.bfg.interfaces import IRouteRequest
-        iface = config.reg.getUtility(IRouteRequest, name)
+        iface = config.registry.getUtility(IRouteRequest, name)
         return iface
 
     def _assertNotFound(self, wrapper, *arg):
@@ -65,30 +65,30 @@ class ConfiguratorTests(unittest.TestCase):
         L = []
         def subscriber(*event):
             L.extend(event)
-        config.reg.registerHandler(subscriber, (event_iface,))
+        config.registry.registerHandler(subscriber, (event_iface,))
         return L
 
     def _registerLogger(self, config):
         from repoze.bfg.interfaces import ILogger
         logger = DummyLogger()
-        config.reg.registerUtility(logger, ILogger, 'repoze.bfg.debug')
+        config.registry.registerUtility(logger, ILogger, 'repoze.bfg.debug')
         return logger
 
     def _makeRequest(self, config):
         request = DummyRequest()
-        request.registry = config.reg
+        request.registry = config.registry
         return request
 
     def _registerSecurityPolicy(self, config, permissive):
         from repoze.bfg.interfaces import IAuthenticationPolicy
         from repoze.bfg.interfaces import IAuthorizationPolicy
         policy = DummySecurityPolicy(permissive)
-        config.reg.registerUtility(policy, IAuthenticationPolicy)
-        config.reg.registerUtility(policy, IAuthorizationPolicy)
+        config.registry.registerUtility(policy, IAuthenticationPolicy)
+        config.registry.registerUtility(policy, IAuthorizationPolicy)
 
     def _registerSettings(self, config, **settings):
         from repoze.bfg.interfaces import ISettings
-        config.reg.registerUtility(settings, ISettings)
+        config.registry.registerUtility(settings, ISettings)
 
     def test_ctor_no_registry(self):
         import sys
@@ -96,7 +96,7 @@ class ConfiguratorTests(unittest.TestCase):
         from repoze.bfg.configuration import Configurator
         config = Configurator()
         this_pkg = sys.modules['repoze.bfg.tests']
-        self.failUnless(config.reg.getUtility(ISettings))
+        self.failUnless(config.registry.getUtility(ISettings))
         self.assertEqual(config.package, this_pkg)
 
     def test_ctor_with_package_registry(self):
@@ -112,8 +112,8 @@ class ConfiguratorTests(unittest.TestCase):
         registry = Registry()
         config = self._makeOne(registry)
         config._default_configuration()
-        self.assertEqual(config.reg, registry)
-        self.failIf(config.reg.getUtility(ISettings) is None)
+        self.assertEqual(config.registry, registry)
+        self.failIf(config.registry.getUtility(ISettings) is None)
 
     def test_make_wsgi_app(self):
         from repoze.bfg.threadlocal import get_current_registry
@@ -135,7 +135,7 @@ class ConfiguratorTests(unittest.TestCase):
         app = config.make_wsgi_app(getSiteManager=gsm, manager=manager)
         self.assertEqual(app.__class__, Router)
         self.assertEqual(gsm.hook, get_current_registry)
-        self.assertEqual(manager.pushed['registry'], config.reg)
+        self.assertEqual(manager.pushed['registry'], config.registry)
         self.assertEqual(manager.pushed['request'], None)
         self.failUnless(manager.popped)
         self.assertEqual(len(subscriber), 1)
@@ -366,7 +366,7 @@ class ConfiguratorTests(unittest.TestCase):
         view.__call_permissive__ = view
         config = self._makeOne()
         config.view(view=view)
-        wrapper = config.reg.adapters.lookup(
+        wrapper = config.registry.adapters.lookup(
             (Interface, IRequest), ISecuredView, name='', default=None)
         self.assertEqual(wrapper, view)
 
@@ -377,7 +377,8 @@ class ConfiguratorTests(unittest.TestCase):
         from repoze.bfg.interfaces import IMultiView
         view = lambda *arg: 'OK'
         config = self._makeOne()
-        config.reg.registerAdapter(view, (Interface, IRequest), IView, name='')
+        config.registry.registerAdapter(
+            view, (Interface, IRequest), IView, name='')
         config.view(view=view)
         wrapper = self._getViewCallable(config)
         self.failUnless(IMultiView.providedBy(wrapper))
@@ -401,8 +402,8 @@ class ConfiguratorTests(unittest.TestCase):
                 """ """
         view = DummyMultiView()
         config = self._makeOne()
-        config.reg.registerAdapter(view, (Interface, IRequest),
-                                   IMultiView, name='')
+        config.registry.registerAdapter(view, (Interface, IRequest),
+                                        IMultiView, name='')
         view2 = lambda *arg: 'OK2'
         config.view(view=view2)
         wrapper = self._getViewCallable(config)
@@ -722,7 +723,7 @@ class ConfiguratorTests(unittest.TestCase):
 
     def _assertRoute(self, config, name, path, num_predicates=0):
         from repoze.bfg.interfaces import IRoutesMapper
-        mapper = config.reg.getUtility(IRoutesMapper)
+        mapper = config.registry.getUtility(IRoutesMapper)
         routes = mapper.get_routes()
         route = routes[0]
         self.assertEqual(len(routes), 1)
@@ -961,8 +962,8 @@ class ConfiguratorTests(unittest.TestCase):
         from repoze.bfg.interfaces import IAuthorizationPolicy
         config = self._makeOne()
         policy = lambda *arg: None
-        config.reg.registerUtility(policy, IAuthenticationPolicy)
-        config.reg.registerUtility(policy, IAuthorizationPolicy)
+        config.registry.registerUtility(policy, IAuthenticationPolicy)
+        config.registry.registerUtility(policy, IAuthorizationPolicy)
         view = lambda *arg: 'OK'
         config.route('name', 'path', view=view, view_permission='edit')
         request_type = self._getRouteRequestIface(config, 'name')
@@ -975,8 +976,8 @@ class ConfiguratorTests(unittest.TestCase):
         from repoze.bfg.interfaces import IAuthorizationPolicy
         config = self._makeOne()
         policy = lambda *arg: None
-        config.reg.registerUtility(policy, IAuthenticationPolicy)
-        config.reg.registerUtility(policy, IAuthorizationPolicy)
+        config.registry.registerUtility(policy, IAuthenticationPolicy)
+        config.registry.registerUtility(policy, IAuthorizationPolicy)
         view = lambda *arg: 'OK'
         config.route('name', 'path', view=view, permission='edit')
         request_type = self._getRouteRequestIface(config, 'name')
@@ -991,8 +992,8 @@ class ConfiguratorTests(unittest.TestCase):
         config = self._makeOne()
         config._override(package, 'path', opackage, 'oprefix',
                          PackageOverrides=DummyOverrides)
-        overrides = config.reg.queryUtility(IPackageOverrides,
-                                            name='package')
+        overrides = config.registry.queryUtility(IPackageOverrides,
+                                                 name='package')
         self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')])
         self.assertEqual(overrides.package, package)
 
@@ -1002,8 +1003,8 @@ class ConfiguratorTests(unittest.TestCase):
         opackage = DummyPackage('opackage')
         overrides = DummyOverrides(package)
         config = self._makeOne()
-        config.reg.registerUtility(overrides, IPackageOverrides,
-                                   name='package')
+        config.registry.registerUtility(overrides, IPackageOverrides,
+                                        name='package')
         config._override(package, 'path', opackage, 'oprefix',
                          PackageOverrides=DummyOverrides)
         self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')])
@@ -1020,7 +1021,7 @@ class ConfiguratorTests(unittest.TestCase):
         route = self._assertRoute(config, 'static', 'static*subpath')
         self.assertEqual(route.factory.__class__, StaticRootFactory)
         iface = implementedBy(StaticRootFactory)
-        wrapped = config.reg.adapters.lookup(
+        wrapped = config.registry.adapters.lookup(
             (iface, request_type), IView, name='')
         request = self._makeRequest(config)
         self.assertEqual(wrapped(None, request).__class__, PackageURLParser)
@@ -1036,7 +1037,7 @@ class ConfiguratorTests(unittest.TestCase):
         route = self._assertRoute(config, 'static', 'static*subpath')
         self.assertEqual(route.factory.__class__, StaticRootFactory)
         iface = implementedBy(StaticRootFactory)
-        wrapped = config.reg.adapters.lookup(
+        wrapped = config.registry.adapters.lookup(
             (iface, request_type), IView, name='')
         request = self._makeRequest(config)
         self.assertEqual(wrapped(None, request).__class__, PackageURLParser)
@@ -1055,7 +1056,7 @@ class ConfiguratorTests(unittest.TestCase):
         route = self._assertRoute(config, 'static', 'static*subpath')
         self.assertEqual(route.factory.__class__, StaticRootFactory)
         iface = implementedBy(StaticRootFactory)
-        wrapped = config.reg.adapters.lookup(
+        wrapped = config.registry.adapters.lookup(
             (iface, request_type), IView, name='')
         request = self._makeRequest(config)
         self.assertEqual(wrapped(None, request).__class__, StaticURLParser)
@@ -1071,7 +1072,7 @@ class ConfiguratorTests(unittest.TestCase):
         config.system_view(IDummy,
                            renderer='repoze.bfg.tests:fixtures/minimal.pt')
         request = self._makeRequest(config)
-        view = config.reg.getUtility(IDummy)
+        view = config.registry.getUtility(IDummy)
         result = view(None, request)
         self.assertEqual(result.body, 'Hello!')
 
@@ -1083,7 +1084,7 @@ class ConfiguratorTests(unittest.TestCase):
             def index(self):
                 return 'OK'
         config.system_view(IDummy, view=view, attr='index')
-        view = config.reg.getUtility(IDummy)
+        view = config.registry.getUtility(IDummy)
         request = self._makeRequest(config)
         result = view(None, request)
         self.assertEqual(result, 'OK')
@@ -1096,13 +1097,13 @@ class ConfiguratorTests(unittest.TestCase):
         config = self._makeOne()
         view = lambda *arg: DummyResponse()
         wrapper = lambda *arg: 'OK2'
-        config.reg.registerAdapter(wrapper, (Interface, Interface),
-                                   IView, name='wrapper')
+        config.registry.registerAdapter(wrapper, (Interface, Interface),
+                                        IView, name='wrapper')
         config.system_view(IDummy, view=view, wrapper='wrapper')
-        view = config.reg.getUtility(IDummy)
+        view = config.registry.getUtility(IDummy)
         request = self._makeRequest(config)
         directlyProvides(request, IRequest)
-        request.registry = config.reg
+        request.registry = config.registry
         context = DummyContext()
         result = view(context, request)
         self.assertEqual(result, 'OK2')
@@ -1113,7 +1114,7 @@ class ConfiguratorTests(unittest.TestCase):
         view = lambda *arg: 'OK'
         config.notfound(view)
         request = self._makeRequest(config)
-        view = config.reg.getUtility(INotFoundView)
+        view = config.registry.getUtility(INotFoundView)
         result = view(None, request)
         self.assertEqual(result, 'OK')
 
@@ -1123,7 +1124,7 @@ class ConfiguratorTests(unittest.TestCase):
         view = lambda *arg: 'OK'
         config.forbidden(view)
         request = self._makeRequest(config)
-        view = config.reg.getUtility(IForbiddenView)
+        view = config.registry.getUtility(IForbiddenView)
         result = view(None, request)
         self.assertEqual(result, 'OK')
 
@@ -1132,14 +1133,16 @@ class ConfiguratorTests(unittest.TestCase):
         config = self._makeOne()
         policy = object()
         config.authentication_policy(policy)
-        self.assertEqual(config.reg.getUtility(IAuthenticationPolicy), policy)
+        self.assertEqual(
+            config.registry.getUtility(IAuthenticationPolicy), policy)
 
     def test_authorization_policy(self):
         from repoze.bfg.interfaces import IAuthorizationPolicy
         config = self._makeOne()
         policy = object()
         config.authorization_policy(policy)
-        self.assertEqual(config.reg.getUtility(IAuthorizationPolicy), policy)
+        self.assertEqual(
+            config.registry.getUtility(IAuthorizationPolicy), policy)
 
     def test_derive_view_as_function_context_and_request(self):
         def view(context, request):
@@ -1413,14 +1416,15 @@ class ConfiguratorTests(unittest.TestCase):
             self.assertEqual(request.wrapped_view, inner_view)
             return Response('outer ' + request.wrapped_body)
         config = self._makeOne()
-        config.reg.registerAdapter(outer_view, (None, None), IView, 'owrap')
+        config.registry.registerAdapter(
+            outer_view, (None, None), IView, 'owrap')
         result = config.derive_view(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 = self._makeRequest(config)
-        request.registry = config.reg
+        request.registry = config.registry
         response = result(None, request)
         self.assertEqual(response.body, 'outer OK')
 
@@ -1431,7 +1435,7 @@ class ConfiguratorTests(unittest.TestCase):
             return inner_response
         config = self._makeOne()
         request = self._makeRequest(config)
-        request.registry = config.reg
+        request.registry = config.registry
         wrapped = config.derive_view(
             inner_view, viewname='inner', wrapper_viewname='owrap')
         result = self.assertRaises(ValueError, wrapped, None, request)