- Tease out an extra 4% performance boost by changing the Router;

  instead of using imported ZCA APIs, use the same APIs directly
  against the registry that is an attribute of the Router.  As a
  result, the registry used by BFG is now a subclass of
  ``zope.component.registry.Components`` (defined as
  ``repoze.bfg.registry.Registry``); it has a ``notify`` method.

5 files changed, 154 insertions, 161 deletions

diff --git a/CHANGES.txt b/CHANGES.txt
index 229264d7f..8c6be8eb8 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -12,6 +12,13 @@ Implementation Changes
   purely an optimization (e.g. preventing calls to ``alsoProvides``
   means the difference between 590 r/s and 690 r/s on a MacBook 2GHz).
 
+- Tease out an extra 4% performance boost by changing the Router;
+  instead of using imported ZCA APIs, use the same APIs directly
+  against the registry that is an attribute of the Router.  As a
+  result, the registry used by BFG is now a subclass of
+  ``zope.component.registry.Components`` (defined as
+  ``repoze.bfg.registry.Registry``); it has a ``notify`` method.
+
 0.6.3 (2009-01-19)
 ==================
 
diff --git a/repoze/bfg/registry.py b/repoze/bfg/registry.py
index c62a92a7d..d1dff6744 100644
--- a/repoze/bfg/registry.py
+++ b/repoze/bfg/registry.py
@@ -3,9 +3,10 @@ import threading
 import zope.component
 
 from zope.component import getGlobalSiteManager
+from zope.component import getSiteManager as original_getSiteManager
 from zope.component.interfaces import ComponentLookupError
 from zope.component.interfaces import IComponentLookup
-from zope.component import getSiteManager as original_getSiteManager
+from zope.component.registry import Components
 
 from zope.deferredimport import deprecated
 
@@ -23,6 +24,12 @@ deprecated(
     get_options = "repoze.bfg.settings:get_options",
     )
 
+class Registry(Components):
+    def notify(self, *events):
+        # iterating over subscribers assures they get executed
+        for ignored in self.subscribers(events, None):
+            pass
+
 class ThreadLocalRegistryManager(threading.local):
     def __init__(self):
         self.stack = []
@@ -90,9 +97,5 @@ def getSiteManager(context=None):
             raise ComponentLookupError(*error.args)
 
 from zope.testing.cleanup import addCleanUp
-try:
-    addCleanUp(original_getSiteManager.reset)
-except AttributeError:
-    # zope.hookable not yet installed
-    pass
+addCleanUp(original_getSiteManager.reset) # AttributeError: zope.hookable not installed
 addCleanUp(registry_manager.clear)
diff --git a/repoze/bfg/router.py b/repoze/bfg/router.py
index 6630d0a0a..05236cfed 100644
--- a/repoze/bfg/router.py
+++ b/repoze/bfg/router.py
@@ -1,11 +1,7 @@
 import sys
 from cgi import escape
 
-from zope.component import getAdapter
-from zope.component import getUtility
-from zope.component import queryUtility
 from zope.component.event import dispatch
-from zope.component.registry import Components
 
 from zope.interface import implements
 
@@ -17,19 +13,22 @@ from repoze.bfg.events import NewResponse
 from repoze.bfg.events import WSGIApplicationCreatedEvent
 
 from repoze.bfg.interfaces import ILogger
-from repoze.bfg.interfaces import ITraverserFactory
 from repoze.bfg.interfaces import IRequestFactory
-from repoze.bfg.interfaces import IRoutesMapper
-from repoze.bfg.interfaces import IRouter
 from repoze.bfg.interfaces import IRootFactory
+from repoze.bfg.interfaces import IRouter
+from repoze.bfg.interfaces import IRoutesMapper
+from repoze.bfg.interfaces import ITraverserFactory
 from repoze.bfg.interfaces import ISettings
 
 from repoze.bfg.log import make_stream_logger
 
+from repoze.bfg.registry import Registry
 from repoze.bfg.registry import registry_manager
 from repoze.bfg.registry import populateRegistry
+
 from repoze.bfg.request import HTTP_METHOD_FACTORIES
 from repoze.bfg.request import Request
+
 from repoze.bfg.settings import Settings
 
 from repoze.bfg.urldispatch import RoutesRootFactory
@@ -49,7 +48,7 @@ class Router(object):
     @property
     def root_policy(self):
         """  Backwards compatibility alias """
-        return getUtility(IRootFactory)
+        return self.registry.getUtility(IRootFactory)
 
     def __call__(self, environ, start_response):
         """
@@ -57,22 +56,23 @@ class Router(object):
         'view' code based on registrations within the application
         registry; call ``start_response`` and return an iterable.
         """
-        registry_manager.push(self.registry)
+        reg = self.registry
+        registry_manager.push(reg)
 
         try:
-            
-            request_factory = queryUtility(IRequestFactory)
+            request_factory = reg.queryUtility(IRequestFactory)
             if request_factory is None:
                 method = environ.get('REQUEST_METHOD', 'GET')
                 request_factory = HTTP_METHOD_FACTORIES.get(method, Request)
             request = request_factory(environ)
 
-            dispatch(NewRequest(request))
-            root_factory = getUtility(IRootFactory)
+            reg.notify(NewRequest(request))
+            root_factory = reg.getUtility(IRootFactory)
             root = root_factory(environ)
-            traverser = getAdapter(root, ITraverserFactory)
+            traverser = reg.getAdapter(root, ITraverserFactory)
             context, view_name, subpath = traverser(environ)
 
+            # XXX webob.Request's __setattr__ is slow here: investigate.
             request.root = root
             request.context = context
             request.view_name = view_name
@@ -80,11 +80,13 @@ class Router(object):
 
             permitted = view_execution_permitted(context, request, view_name)
 
-            settings = queryUtility(ISettings)
+            settings = reg.queryUtility(ISettings)
             debug_authorization = settings and settings.debug_authorization
 
+            logger = None
+
             if debug_authorization:
-                logger = queryUtility(ILogger, 'repoze.bfg.debug')
+                logger = reg.queryUtility(ILogger, 'repoze.bfg.debug')
                 logger and logger.debug(
                     'debug_authorization of url %s (view name %r against '
                     'context %r): %s' % (
@@ -104,7 +106,8 @@ class Router(object):
             if response is None:
                 debug_notfound = settings and settings.debug_notfound
                 if debug_notfound:
-                    logger = queryUtility(ILogger, 'repoze.bfg.debug')
+                    if logger is None:
+                        logger = reg.queryUtility(ILogger, 'repoze.bfg.debug')
                     msg = (
                         'debug_notfound of url %s; path_info: %r, context: %r, '
                         'view_name: %r, subpath: %r' % (
@@ -117,7 +120,7 @@ class Router(object):
                 app = HTTPNotFound(escape(msg))
                 return app(environ, start_response)
 
-            dispatch(NewResponse(response))
+            reg.notify(NewResponse(response))
 
             start_response(response.status, response.headerlist)
             return response.app_iter
@@ -143,7 +146,7 @@ def make_app(root_factory, package=None, filename='configure.zcml',
     regname = filename
     if package:
         regname = package.__name__
-    registry = Components(regname)
+    registry = Registry(regname)
     debug_logger = make_stream_logger('repoze.bfg.debug', sys.stderr)
     registry.registerUtility(debug_logger, ILogger, 'repoze.bfg.debug')
     settings = Settings(options)
@@ -164,8 +167,13 @@ def make_app(root_factory, package=None, filename='configure.zcml',
     registry.registerUtility(root_factory, IRootFactory)
     app = Router(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.
+    registry_manager.push(registry)
     try:
-        registry_manager.push(registry)
+        # use dispatch here instead of registry.notify to make unit
+        # tests possible
         dispatch(WSGIApplicationCreatedEvent(app))
     finally:
         registry_manager.pop()
diff --git a/repoze/bfg/tests/test_registry.py b/repoze/bfg/tests/test_registry.py
index edd45b458..2c26d850e 100644
--- a/repoze/bfg/tests/test_registry.py
+++ b/repoze/bfg/tests/test_registry.py
@@ -2,6 +2,24 @@ import unittest
 
 from zope.testing.cleanup import cleanUp
 
+class TestRegistry(unittest.TestCase):
+    def _getTargetClass(self):
+        from repoze.bfg.registry import Registry
+        return Registry
+    
+    def _makeOne(self):
+        return self._getTargetClass()()
+
+    def test_notify(self):
+        registry = self._makeOne()
+        L = []
+        def subscribers(events, *arg):
+            L.extend(events)
+            return ['abc']
+        registry.subscribers = subscribers
+        registry.notify('123')
+        self.assertEqual(L, ['123'])
+
 class TestPopulateRegistry(unittest.TestCase):
     def setUp(self):
         cleanUp()
diff --git a/repoze/bfg/tests/test_router.py b/repoze/bfg/tests/test_router.py
index 2a8539d4c..8c2a5cf04 100644
--- a/repoze/bfg/tests/test_router.py
+++ b/repoze/bfg/tests/test_router.py
@@ -4,9 +4,14 @@ from zope.testing.cleanup import cleanUp
 
 class RouterTests(unittest.TestCase):
     def setUp(self):
-        cleanUp()
+        from repoze.bfg.registry import Registry
+        from zope.component import getSiteManager
+        self.registry = Registry()
+        getSiteManager.sethook(lambda *arg: self.registry)
 
     def tearDown(self):
+        from zope.component import getSiteManager
+        getSiteManager.reset()
         cleanUp()
 
     def _registerLogger(self):
@@ -18,9 +23,7 @@ class RouterTests(unittest.TestCase):
                 self.messages.append(msg)
             debug = info
         logger = Logger()
-        from zope.component import getGlobalSiteManager
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(logger, ILogger, name='repoze.bfg.debug')
+        self.registry.registerUtility(logger, ILogger, name='repoze.bfg.debug')
         return logger
 
     def _registerSettings(self, **kw):
@@ -32,56 +35,42 @@ class RouterTests(unittest.TestCase):
         defaultkw = {'debug_authorization':False, 'debug_notfound':False}
         defaultkw.update(kw)
         settings = Settings(**defaultkw)
-        from zope.component import getGlobalSiteManager
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(settings, ISettings)
+        self.registry.registerUtility(settings, ISettings)
 
     def _registerTraverserFactory(self, app, name, *for_):
         from repoze.bfg.interfaces import ITraverserFactory
-        from zope.component import getGlobalSiteManager
-        gsm = getGlobalSiteManager()
-        gsm.registerAdapter(app, for_, ITraverserFactory, name)
+        self.registry.registerAdapter(app, for_, ITraverserFactory, name)
 
     def _registerView(self, app, name, *for_):
         from repoze.bfg.interfaces import IView
-        from zope.component import getGlobalSiteManager
-        gsm = getGlobalSiteManager()
-        gsm.registerAdapter(app, for_, IView, name)
+        self.registry.registerAdapter(app, for_, IView, name)
 
     def _registerPermission(self, permission, name, *for_):
         from repoze.bfg.interfaces import IViewPermission
-        from zope.component import getGlobalSiteManager
-        gsm = getGlobalSiteManager()
-        gsm.registerAdapter(permission, for_, IViewPermission, name)
+        self.registry.registerAdapter(permission, for_, IViewPermission, name)
 
     def _registerSecurityPolicy(self, secpol):
         from repoze.bfg.interfaces import ISecurityPolicy
-        from zope.component import getGlobalSiteManager
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(secpol, ISecurityPolicy)
+        self.registry.registerUtility(secpol, ISecurityPolicy)
 
     def _registerEventListener(self, iface):
-        from zope.component import getGlobalSiteManager
-        gsm = getGlobalSiteManager()
         L = []
         def listener(event):
             L.append(event)
-        gsm.registerHandler(listener, (iface,))
+        self.registry.registerHandler(listener, (iface,))
         return L
 
     def _registerRootFactory(self, root_factory):
         from repoze.bfg.interfaces import IRootFactory
-        from zope.component import getGlobalSiteManager
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(root_factory, IRootFactory)
+        self.registry.registerUtility(root_factory, IRootFactory)
 
     def _getTargetClass(self):
         from repoze.bfg.router import Router
         return Router
 
-    def _makeOne(self, *arg, **kw):
+    def _makeOne(self):
         klass = self._getTargetClass()
-        return klass(*arg, **kw)
+        return klass(self.registry)
 
     def _makeEnviron(self, **extras):
         environ = {
@@ -101,7 +90,7 @@ class RouterTests(unittest.TestCase):
         self._registerTraverserFactory(traversalfactory, '', None)
         logger = self._registerLogger()
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         self.assertEqual(router.root_policy, rootfactory)
 
     def test_call_no_view_registered_no_isettings(self):
@@ -112,7 +101,7 @@ class RouterTests(unittest.TestCase):
         self._registerTraverserFactory(traversalfactory, '', None)
         logger = self._registerLogger()
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         headers = start_response.headers
@@ -135,7 +124,7 @@ class RouterTests(unittest.TestCase):
         start_response = DummyStartResponse()
         rootfactory = make_rootfactory(NotFound())
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         result = router(environ, start_response)
         status = start_response.status
         self.assertEqual(status, '404 Not Found')
@@ -150,7 +139,7 @@ class RouterTests(unittest.TestCase):
         logger = self._registerLogger()
         self._registerSettings(debug_notfound=False)
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         headers = start_response.headers
@@ -170,7 +159,7 @@ class RouterTests(unittest.TestCase):
         self._registerSettings(debug_notfound=True)
         logger = self._registerLogger()
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         headers = start_response.headers
@@ -202,7 +191,7 @@ class RouterTests(unittest.TestCase):
         self._registerTraverserFactory(traversalfactory, '', None)
         self._registerView(view, '', None, None)
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         self.assertEqual(result, ['Hello world'])
@@ -224,7 +213,7 @@ class RouterTests(unittest.TestCase):
         self._registerTraverserFactory(traversalfactory, '', None)
         self._registerView(view, 'foo', None, None)
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         self.assertEqual(result, ['Hello world'])
@@ -252,7 +241,7 @@ class RouterTests(unittest.TestCase):
         self._registerTraverserFactory(traversalfactory, '', None)
         self._registerView(view, '', IContext, IRequest)
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         self.assertEqual(result, ['Hello world'])
@@ -281,7 +270,7 @@ class RouterTests(unittest.TestCase):
         self._registerTraverserFactory(traversalfactory, '', None)
         self._registerView(view, '', IContext, IRequest)
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         self.assertEqual(start_response.status, '404 Not Found')
@@ -305,7 +294,7 @@ class RouterTests(unittest.TestCase):
         secpol = DummySecurityPolicy()
         self._registerSecurityPolicy(secpol)
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         self.assertEqual(start_response.status, '200 OK')
@@ -330,7 +319,7 @@ class RouterTests(unittest.TestCase):
         self._registerSecurityPolicy(secpol)
         self._registerPermission(permissionfactory, '', IContext, IRequest)
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         self.assertEqual(start_response.status, '200 OK')
@@ -359,7 +348,7 @@ class RouterTests(unittest.TestCase):
         self._registerSecurityPolicy(secpol)
         self._registerPermission(permissionfactory, '', IContext, IRequest)
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         self.assertEqual(start_response.status, '401 Unauthorized')
@@ -391,7 +380,7 @@ class RouterTests(unittest.TestCase):
         self._registerPermission(permissionfactory, '', IContext, IRequest)
         self._registerSettings(debug_authorization=False)
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         self.assertEqual(start_response.status, '401 Unauthorized')
@@ -424,7 +413,7 @@ class RouterTests(unittest.TestCase):
         self._registerSettings(debug_authorization=True)
         logger = self._registerLogger()
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         self.assertEqual(start_response.status, '401 Unauthorized')
@@ -460,7 +449,7 @@ class RouterTests(unittest.TestCase):
         request_events = self._registerEventListener(INewRequest)
         response_events = self._registerEventListener(INewResponse)
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
         self.assertEqual(len(request_events), 1)
@@ -483,7 +472,7 @@ class RouterTests(unittest.TestCase):
         self._registerTraverserFactory(traversalfactory, '', None)
         self._registerView(view, '', None, None)
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         request_events = self._registerEventListener(INewRequest)
         result = router(environ, start_response)
@@ -507,7 +496,7 @@ class RouterTests(unittest.TestCase):
         self._registerTraverserFactory(traversalfactory, '', None)
         self._registerView(view, '', None, None)
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         request_events = self._registerEventListener(INewRequest)
         result = router(environ, start_response)
@@ -522,9 +511,7 @@ class RouterTests(unittest.TestCase):
         from webob import Request
         class Request2(Request):
             pass
-        from zope.component import getGlobalSiteManager
-        gsm = getGlobalSiteManager()
-        gsm.registerUtility(Request2, IRequestFactory)
+        self.registry.registerUtility(Request2, IRequestFactory)
         rootfactory = make_rootfactory(None)
         context = DummyContext()
         traversalfactory = make_traversal_factory(context, '', [])
@@ -535,7 +522,7 @@ class RouterTests(unittest.TestCase):
         self._registerTraverserFactory(traversalfactory, '', None)
         self._registerView(view, '', None, None)
         self._registerRootFactory(rootfactory)
-        router = self._makeOne(None)
+        router = self._makeOne()
         start_response = DummyStartResponse()
         request_events = self._registerEventListener(INewRequest)
         result = router(environ, start_response)
@@ -545,9 +532,16 @@ class RouterTests(unittest.TestCase):
 class MakeAppTests(unittest.TestCase):
     def setUp(self):
         cleanUp()
+        import repoze.bfg.router
+        self.old_registry_manager = repoze.bfg.router.registry_manager
+        self.regmgr = DummyRegistryManager()
+        repoze.bfg.router.registry_manager = self.regmgr
 
     def tearDown(self):
         cleanUp()
+        import repoze.bfg.router
+        repoze.bfg.router.registry_manager = self.old_registry_manager
+        
 
     def _callFUT(self, *arg, **kw):
         from repoze.bfg.router import make_app
@@ -563,116 +557,79 @@ class MakeAppTests(unittest.TestCase):
         def subscriber(event):
             event.app.created = True        
         from repoze.bfg.interfaces import IWSGIApplicationCreatedEvent
-        import repoze.bfg.router
         from zope.component import getGlobalSiteManager
-        old_registry_manager = repoze.bfg.router.registry_manager
-        repoze.bfg.router.registry_manager = DummyRegistryManager()
         getGlobalSiteManager().registerHandler(
             subscriber,
             (IWSGIApplicationCreatedEvent,)
             )
-        try:
-            from repoze.bfg.tests import fixtureapp
-            rootpolicy = make_rootfactory(None)
-            app = self._callFUT(rootpolicy, fixtureapp)
-            assert app.created is True
-        finally:
-            repoze.bfg.router.registry_manager = old_registry_manager
+        from repoze.bfg.tests import fixtureapp
+        rootpolicy = make_rootfactory(None)
+        app = self._callFUT(rootpolicy, fixtureapp)
+        assert app.created is True
 
     def test_registrations(self):
         options= {'reload_templates':True,
                   'debug_authorization':True}
-        import repoze.bfg.router
-        old_registry_manager = repoze.bfg.router.registry_manager
-        dummy_registry_manager = DummyRegistryManager()
-        repoze.bfg.router.registry_manager = dummy_registry_manager
-        try:
-            from repoze.bfg.tests import fixtureapp
-            rootpolicy = make_rootfactory(None)
-            app = self._callFUT(rootpolicy, fixtureapp, options=options)
-            from repoze.bfg.interfaces import ISettings
-            from repoze.bfg.interfaces import ILogger
-            from repoze.bfg.interfaces import IRootFactory
-            settings = app.registry.getUtility(ISettings)
-            logger = app.registry.getUtility(ILogger, name='repoze.bfg.debug')
-            rootfactory = app.registry.getUtility(IRootFactory)
-            self.assertEqual(logger.name, 'repoze.bfg.debug')
-            self.assertEqual(settings.reload_templates, True)
-            self.assertEqual(settings.debug_authorization, True)
-            self.assertEqual(rootfactory, rootpolicy)
-            self.assertEqual(dummy_registry_manager.pushed, True)
-            self.assertEqual(dummy_registry_manager.popped, True)
-        finally:
-            repoze.bfg.router.registry_manager = old_registry_manager
+        from repoze.bfg.tests import fixtureapp
+        rootpolicy = make_rootfactory(None)
+        app = self._callFUT(rootpolicy, fixtureapp, options=options)
+        from repoze.bfg.interfaces import ISettings
+        from repoze.bfg.interfaces import ILogger
+        from repoze.bfg.interfaces import IRootFactory
+        settings = app.registry.getUtility(ISettings)
+        logger = app.registry.getUtility(ILogger, name='repoze.bfg.debug')
+        rootfactory = app.registry.getUtility(IRootFactory)
+        self.assertEqual(logger.name, 'repoze.bfg.debug')
+        self.assertEqual(settings.reload_templates, True)
+        self.assertEqual(settings.debug_authorization, True)
+        self.assertEqual(rootfactory, rootpolicy)
+        self.failUnless(self.regmgr.pushed and self.regmgr.popped)
 
     def test_routes_in_config_with_rootpolicy(self):
         options= {'reload_templates':True,
                   'debug_authorization':True}
-        import repoze.bfg.router
-        old_registry_manager = repoze.bfg.router.registry_manager
-        dummy_registry_manager = DummyRegistryManager()
-        repoze.bfg.router.registry_manager = dummy_registry_manager
         from repoze.bfg.urldispatch import RoutesRootFactory
-        try:
-            from repoze.bfg.tests import routesapp
-            rootpolicy = make_rootfactory(None)
-            app = self._callFUT(rootpolicy, routesapp, options=options)
-            from repoze.bfg.interfaces import ISettings
-            from repoze.bfg.interfaces import ILogger
-            from repoze.bfg.interfaces import IRootFactory
-            settings = app.registry.getUtility(ISettings)
-            logger = app.registry.getUtility(ILogger, name='repoze.bfg.debug')
-            rootfactory = app.registry.getUtility(IRootFactory)
-            self.assertEqual(logger.name, 'repoze.bfg.debug')
-            self.assertEqual(settings.reload_templates, True)
-            self.assertEqual(settings.debug_authorization, True)
-            self.failUnless(isinstance(rootfactory, RoutesRootFactory))
-            self.assertEqual(rootfactory.get_root, rootpolicy)
-            self.assertEqual(dummy_registry_manager.pushed, True)
-            self.assertEqual(dummy_registry_manager.popped, True)
-        finally:
-            repoze.bfg.router.registry_manager = old_registry_manager
+        from repoze.bfg.tests import routesapp
+        rootpolicy = make_rootfactory(None)
+        app = self._callFUT(rootpolicy, routesapp, options=options)
+        from repoze.bfg.interfaces import ISettings
+        from repoze.bfg.interfaces import ILogger
+        from repoze.bfg.interfaces import IRootFactory
+        settings = app.registry.getUtility(ISettings)
+        logger = app.registry.getUtility(ILogger, name='repoze.bfg.debug')
+        rootfactory = app.registry.getUtility(IRootFactory)
+        self.assertEqual(logger.name, 'repoze.bfg.debug')
+        self.assertEqual(settings.reload_templates, True)
+        self.assertEqual(settings.debug_authorization, True)
+        self.failUnless(isinstance(rootfactory, RoutesRootFactory))
+        self.assertEqual(rootfactory.get_root, rootpolicy)
+        self.failUnless(self.regmgr.pushed and self.regmgr.popped)
 
     def test_routes_in_config_no_rootpolicy(self):
         options= {'reload_templates':True,
                   'debug_authorization':True}
-        import repoze.bfg.router
-        old_registry_manager = repoze.bfg.router.registry_manager
-        dummy_registry_manager = DummyRegistryManager()
-        repoze.bfg.router.registry_manager = dummy_registry_manager
         from repoze.bfg.urldispatch import RoutesRootFactory
-        try:
-            from repoze.bfg.tests import routesapp
-            app = self._callFUT(None, routesapp, options=options)
-            from repoze.bfg.interfaces import ISettings
-            from repoze.bfg.interfaces import ILogger
-            from repoze.bfg.interfaces import IRootFactory
-            settings = app.registry.getUtility(ISettings)
-            logger = app.registry.getUtility(ILogger, name='repoze.bfg.debug')
-            rootfactory = app.registry.getUtility(IRootFactory)
-            self.assertEqual(logger.name, 'repoze.bfg.debug')
-            self.assertEqual(settings.reload_templates, True)
-            self.assertEqual(settings.debug_authorization, True)
-            self.failUnless(isinstance(rootfactory, RoutesRootFactory))
-            self.assertEqual(rootfactory.get_root, None)
-            self.assertEqual(dummy_registry_manager.pushed, True)
-            self.assertEqual(dummy_registry_manager.popped, True)
-        finally:
-            repoze.bfg.router.registry_manager = old_registry_manager
+        from repoze.bfg.tests import routesapp
+        app = self._callFUT(None, routesapp, options=options)
+        from repoze.bfg.interfaces import ISettings
+        from repoze.bfg.interfaces import ILogger
+        from repoze.bfg.interfaces import IRootFactory
+        settings = app.registry.getUtility(ISettings)
+        logger = app.registry.getUtility(ILogger, name='repoze.bfg.debug')
+        rootfactory = app.registry.getUtility(IRootFactory)
+        self.assertEqual(logger.name, 'repoze.bfg.debug')
+        self.assertEqual(settings.reload_templates, True)
+        self.assertEqual(settings.debug_authorization, True)
+        self.failUnless(isinstance(rootfactory, RoutesRootFactory))
+        self.assertEqual(rootfactory.get_root, None)
+        self.failUnless(self.regmgr.pushed and self.regmgr.popped)
         
     def test_no_routes_in_config_no_rootpolicy(self):
         options= {'reload_templates':True,
                   'debug_authorization':True}
-        import repoze.bfg.router
-        old_registry_manager = repoze.bfg.router.registry_manager
-        dummy_registry_manager = DummyRegistryManager()
-        repoze.bfg.router.registry_manager = dummy_registry_manager
-        try:
-            from repoze.bfg.tests import fixtureapp
-            self.assertRaises(ValueError, self._callFUT, None, fixtureapp,
-                              options=options)
-        finally:
-            repoze.bfg.router.registry_manager = old_registry_manager
+        from repoze.bfg.tests import fixtureapp
+        self.assertRaises(ValueError, self._callFUT, None, fixtureapp,
+                          options=options)
 
 class DummyRegistryManager:
     def push(self, registry):