Move configuration methods into Configurator.

7 files changed, 700 insertions, 768 deletions

diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py
index 026002253..d7f707f87 100644
--- a/repoze/bfg/tests/test_configuration.py
+++ b/repoze/bfg/tests/test_configuration.py
@@ -8,61 +8,447 @@ class MakeRegistryTests(unittest.TestCase):
 
     def tearDown(self):
         cleanUp()
+
+    def _makeOne(self):
+        from repoze.bfg.registry import Registry
+        from repoze.bfg.configuration import Configurator
+        reg = Registry()
+        config = Configurator(reg)
+        
+
+class ConfiguratorTests(unittest.TestCase):
+    def _makeOne(self, registry=None):
+        from repoze.bfg.registry import Registry
+        from repoze.bfg.configuration import Configurator
+        if registry is None:
+            registry = Registry()
+        return Configurator(registry)
+
+    def _registerRenderer(self, config, name='.txt'):
+        from repoze.bfg.interfaces import IRendererFactory
+        from repoze.bfg.interfaces import ITemplateRenderer
+        from zope.interface import implements
+        class Renderer:
+            implements(ITemplateRenderer)
+            def __init__(self, path):
+                pass
+            def __call__(self, *arg):
+                return 'Hello!'
+        config.reg.registerUtility(Renderer, IRendererFactory, name=name)
+
+    def test__override_not_yet_registered(self):
+        from repoze.bfg.interfaces import IPackageOverrides
+        package = DummyPackage('package')
+        opackage = DummyPackage('opackage')
+        config = self._makeOne()
+        config._override(package, 'path', opackage, 'oprefix',
+                         PackageOverrides=DummyOverrides)
+        overrides = config.reg.queryUtility(IPackageOverrides,
+                                            name='package')
+        self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')])
+        self.assertEqual(overrides.package, package)
+
+    def test__override_already_registered(self):
+        from repoze.bfg.interfaces import IPackageOverrides
+        package = DummyPackage('package')
+        opackage = DummyPackage('opackage')
+        overrides = DummyOverrides(package)
+        config = self._makeOne()
+        config.reg.registerUtility(overrides, IPackageOverrides,
+                                   name='package')
+        config._override(package, 'path', opackage, 'oprefix',
+                         PackageOverrides=DummyOverrides)
+        self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')])
+        self.assertEqual(overrides.package, package)
+
+    def test_map_view_as_function_context_and_request(self):
+        def view(context, request):
+            return 'OK'
+        config = self._makeOne()
+        result = config.map_view(view)
+        self.failUnless(result is view)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_function_with_attr(self):
+        def view(context, request):
+            """ """
+        config = self._makeOne()
+        result = config.map_view(view, attr='__name__')
+        self.failIf(result is view)
+        self.assertRaises(TypeError, result, None, None)
+
+    def test_map_view_as_function_with_attr_and_renderer(self):
+        config = self._makeOne()
+        self._registerRenderer(config)
+        def view(context, request):
+            """ """
+        result = config.map_view(view, attr='__name__',
+                                 renderer_name='fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertRaises(TypeError, result, None, None)
         
-    def _callFUT(self, *arg, **kw):
-        from repoze.bfg.router import make_registry
-        return make_registry(*arg, **kw)
+    def test_map_view_as_function_requestonly(self):
+        config = self._makeOne()
+        def view(request):
+            return 'OK'
+        result = config.map_view(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_map_view_as_function_requestonly_with_attr(self):
+        config = self._makeOne()
+        def view(request):
+            """ """
+        result = config.map_view(view, attr='__name__')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        self.assertRaises(TypeError, result, None, None)
+
+    def test_map_view_as_newstyle_class_context_and_request(self):
+        config = self._makeOne()
+        class view(object):
+            def __init__(self, context, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = config.map_view(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_map_view_as_newstyle_class_context_and_request_with_attr(self):
+        config = self._makeOne()
+        class view(object):
+            def __init__(self, context, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = config.map_view(view, attr='index')
+        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_map_view_as_newstyle_class_context_and_request_attr_and_renderer(
+        self):
+        config = self._makeOne()
+        self._registerRenderer(config)
+        class view(object):
+            def __init__(self, context, request):
+                pass
+            def index(self):
+                return {'a':'1'}
+        result = config.map_view(
+            view, attr='index',
+            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+        
+    def test_map_view_as_newstyle_class_requestonly(self):
+        config = self._makeOne()
+        class view(object):
+            def __init__(self, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = config.map_view(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_map_view_as_newstyle_class_requestonly_with_attr(self):
+        config = self._makeOne()
+        class view(object):
+            def __init__(self, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = config.map_view(view, attr='index')
+        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_map_view_as_newstyle_class_requestonly_with_attr_and_renderer(
+        self):
+        config = self._makeOne()
+        self._registerRenderer(config)
+        class view(object):
+            def __init__(self, request):
+                pass
+            def index(self):
+                return {'a':'1'}
+        result = config.map_view(
+            view, attr='index',
+            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test_map_view_as_oldstyle_class_context_and_request(self):
+        config = self._makeOne()
+        class view:
+            def __init__(self, context, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = config.map_view(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_map_view_as_oldstyle_class_context_and_request_with_attr(self):
+        config = self._makeOne()
+        class view:
+            def __init__(self, context, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = config.map_view(view, attr='index')
+        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_map_view_as_oldstyle_class_context_and_request_attr_and_renderer(
+        self):
+        config = self._makeOne()
+        self._registerRenderer(config)
+        class view:
+            def __init__(self, context, request):
+                pass
+            def index(self):
+                return {'a':'1'}
+        result = config.map_view(
+            view, attr='index',
+            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
 
-    def test_fixtureapp_default_filename_withpackage(self):
+    def test_map_view_as_oldstyle_class_requestonly(self):
+        config = self._makeOne()
+        class view:
+            def __init__(self, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        result = config.map_view(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_map_view_as_oldstyle_class_requestonly_with_attr(self):
+        config = self._makeOne()
+        class view:
+            def __init__(self, request):
+                pass
+            def index(self):
+                return 'OK'
+        result = config.map_view(view, attr='index')
+        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_map_view_as_oldstyle_class_requestonly_attr_and_renderer(self):
+        config = self._makeOne()
+        self._registerRenderer(config)
+        class view:
+            def __init__(self, request):
+                pass
+            def index(self):
+                return {'a':'1'}
+        result = config.map_view(
+            view, attr='index',
+            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.assertEqual(view.__name__, result.__name__)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test_map_view_as_instance_context_and_request(self):
+        config = self._makeOne()
+        class View:
+            def __call__(self, context, request):
+                return 'OK'
+        view = View()
+        result = config.map_view(view)
+        self.failUnless(result is view)
+        self.assertEqual(result(None, None), 'OK')
+        
+    def test_map_view_as_instance_context_and_request_and_attr(self):
+        config = self._makeOne()
+        class View:
+            def index(self, context, request):
+                return 'OK'
+        view = View()
+        result = config.map_view(view, attr='index')
+        self.failIf(result is view)
+        self.assertEqual(result(None, None), 'OK')
+
+    def test_map_view_as_instance_context_and_request_attr_and_renderer(self):
+        config = self._makeOne()
+        self._registerRenderer(config)
+        class View:
+            def index(self, context, request):
+                return {'a':'1'}
+        view = View()
+        result = config.map_view(
+            view, attr='index',
+            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
+        self.failIf(result is view)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test_map_view_as_instance_requestonly(self):
+        config = self._makeOne()
+        class View:
+            def __call__(self, request):
+                return 'OK'
+        view = View()
+        result = config.map_view(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')
+
+    def test_map_view_as_instance_requestonly_with_attr(self):
+        config = self._makeOne()
+        class View:
+            def index(self, request):
+                return 'OK'
+        view = View()
+        result = config.map_view(view, attr='index')
+        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')
+
+    def test_map_view_as_instance_requestonly_with_attr_and_renderer(self):
+        config = self._makeOne()
+        self._registerRenderer(config)
+        class View:
+            def index(self, request):
+                return {'a':'1'}
+        view = View()
+        result = config.map_view(
+            view, attr='index',
+            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        self.failUnless('instance' in result.__name__)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test_map_view_rendereronly(self):
+        config = self._makeOne()
+        self._registerRenderer(config)
+        def view(context, request):
+            return {'a':'1'}
+        result = config.map_view(
+            view,
+            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def test_map_view_defaultrendereronly(self):
+        config = self._makeOne()
+        self._registerRenderer(config, name='')
+        def view(context, request):
+            return {'a':'1'}
+        result = config.map_view(view)
+        self.failIf(result is view)
+        self.assertEqual(view.__module__, result.__module__)
+        self.assertEqual(view.__doc__, result.__doc__)
+        request = DummyRequest()
+        self.assertEqual(result(None, request).body, 'Hello!')
+
+    def _callDefaultConfiguration(self, *arg, **kw):
+        inst = self._makeOne()
+        inst.default_configuration(*arg, **kw)
+        return inst.reg
+
+    def test_default_config_fixtureapp_default_filename_withpackage(self):
         manager = DummyRegistryManager()
         from repoze.bfg.tests import fixtureapp
         rootfactory = DummyRootFactory(None)
-        registry = self._callFUT(rootfactory, fixtureapp)
-        self.assertEqual(registry.__name__, 'repoze.bfg.tests.fixtureapp')
+        registry = self._callDefaultConfiguration(rootfactory, fixtureapp)
         from repoze.bfg.tests.fixtureapp.models import IFixture
         self.failUnless(registry.queryUtility(IFixture)) # only in c.zcml
 
-    def test_fixtureapp_explicit_filename(self):
+    def test_default_config_fixtureapp_explicit_filename(self):
         manager = DummyRegistryManager()
         from repoze.bfg.tests import fixtureapp
         rootfactory = DummyRootFactory(None)
-        registry = self._callFUT(
+        registry = self._callDefaultConfiguration(
             rootfactory, fixtureapp, filename='another.zcml',
             manager=manager)
-        self.assertEqual(registry.__name__, 'repoze.bfg.tests.fixtureapp')
         from repoze.bfg.tests.fixtureapp.models import IFixture
         self.failIf(registry.queryUtility(IFixture)) # only in c.zcml
 
-    def test_fixtureapp_explicit_filename_in_options(self):
+    def test_default_config_fixtureapp_explicit_filename_in_settings(self):
         import os
         manager = DummyRegistryManager()
         rootfactory = DummyRootFactory(None)
         from repoze.bfg.tests import fixtureapp
         zcmlfile = os.path.join(os.path.dirname(fixtureapp.__file__),
                                 'another.zcml')
-        registry = self._callFUT(
+        registry = self._callDefaultConfiguration(
             rootfactory, fixtureapp, filename='configure.zcml',
-            options={'configure_zcml':zcmlfile},
+            settings={'configure_zcml':zcmlfile},
             manager=manager)
-        self.assertEqual(registry.__name__, 'repoze.bfg.tests.fixtureapp')
         from repoze.bfg.tests.fixtureapp.models import IFixture
         self.failIf(registry.queryUtility(IFixture)) # only in c.zcml
 
-    def test_fixtureapp_explicit_specification_in_options(self):
+    def test_default_config_fixtureapp_explicit_specification_in_settings(self):
         manager = DummyRegistryManager()
         rootfactory = DummyRootFactory(None)
         from repoze.bfg.tests import fixtureapp
         zcmlfile = 'repoze.bfg.tests.fixtureapp.subpackage:yetanother.zcml'
-        registry = self._callFUT(
+        registry = self._callDefaultConfiguration(
             rootfactory, fixtureapp, filename='configure.zcml',
-            options={'configure_zcml':zcmlfile},
+            settings={'configure_zcml':zcmlfile},
             manager=manager)
-        self.assertEqual(registry.__name__,
-                         'repoze.bfg.tests.fixtureapp.subpackage')
         from repoze.bfg.tests.fixtureapp.models import IFixture
         self.failIf(registry.queryUtility(IFixture)) # only in c.zcml
 
-    def test_fixtureapp_filename_hascolon_isabs(self):
+    def test_default_config_fixtureapp_filename_hascolon_isabs(self):
         manager = DummyRegistryManager()
         rootfactory = DummyRootFactory(None)
         from repoze.bfg.tests import fixtureapp
@@ -72,35 +458,37 @@ class MakeRegistryTests(unittest.TestCase):
                 return True
         os = Dummy()
         os.path = Dummy()
-        self.assertRaises(IOError, self._callFUT,
+        self.assertRaises(IOError, self._callDefaultConfiguration,
                           rootfactory,
                           fixtureapp,
                           filename='configure.zcml',
-                          options={'configure_zcml':zcmlfile},
+                          settings={'configure_zcml':zcmlfile},
                           manager=manager,
                           os=os)
         
-    def test_custom_settings(self):
+    def test_default_config_custom_settings(self):
         manager = DummyRegistryManager()
-        options= {'mysetting':True}
+        settings = {'mysetting':True}
         from repoze.bfg.tests import fixtureapp
         rootfactory = DummyRootFactory(None)
-        registry = self._callFUT(rootfactory, fixtureapp, options=options,
-                                 manager=manager)
+        registry = self._callDefaultConfiguration(
+            rootfactory, fixtureapp, settings=settings,
+            manager=manager)
         from repoze.bfg.interfaces import ISettings
         settings = registry.getUtility(ISettings)
         self.assertEqual(settings.reload_templates, False)
         self.assertEqual(settings.debug_authorization, False)
         self.assertEqual(settings.mysetting, True)
 
-    def test_registrations(self):
+    def test_default_config_registrations(self):
         manager = DummyRegistryManager()
-        options= {'reload_templates':True,
-                  'debug_authorization':True}
+        settings = {'reload_templates':True,
+                    'debug_authorization':True}
         from repoze.bfg.tests import fixtureapp
         rootfactory = DummyRootFactory(None)
-        registry = self._callFUT(rootfactory, fixtureapp, options=options,
-                                 manager=manager)
+        registry = self._callDefaultConfiguration(
+            rootfactory, fixtureapp, settings=settings,
+            manager=manager)
         from repoze.bfg.interfaces import ISettings
         from repoze.bfg.interfaces import ILogger
         from repoze.bfg.interfaces import IRootFactory
@@ -113,110 +501,106 @@ class MakeRegistryTests(unittest.TestCase):
         self.assertEqual(rootfactory, rootfactory)
         self.failUnless(manager.pushed and manager.popped)
 
-    def test_routes_in_config_with_rootfactory(self):
-        options= {'reload_templates':True,
-                  'debug_authorization':True}
-        from repoze.bfg.urldispatch import RoutesRootFactory
-        from repoze.bfg.tests import routesapp
-        rootfactory = DummyRootFactory(None)
-        registry = self._callFUT(rootfactory, routesapp, options=options)
+    def test_default_config_routes_in_config(self):
         from repoze.bfg.interfaces import ISettings
         from repoze.bfg.interfaces import ILogger
         from repoze.bfg.interfaces import IRootFactory
-        settings = registry.getUtility(ISettings)
-        logger = registry.getUtility(ILogger, name='repoze.bfg.debug')
-        effective_rootfactory = 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(effective_rootfactory, RoutesRootFactory))
-        self.assertEqual(effective_rootfactory.default_root_factory,
-                         rootfactory)
-
-    def test_routes_in_config_no_rootfactory(self):
-        options= {'reload_templates':True,
-                  'debug_authorization':True}
-        from repoze.bfg.urldispatch import RoutesRootFactory
-        from repoze.bfg.router import DefaultRootFactory
+        from repoze.bfg.interfaces import IRoutesMapper
+        settings = {'reload_templates':True,
+                    'debug_authorization':True}
         from repoze.bfg.tests import routesapp
-        registry = self._callFUT(None, routesapp, options=options)
-        from repoze.bfg.interfaces import ISettings
-        from repoze.bfg.interfaces import ILogger
-        from repoze.bfg.interfaces import IRootFactory
+        rootfactory = DummyRootFactory(None)
+        registry = self._callDefaultConfiguration(
+            rootfactory, routesapp, settings=settings)
         settings = registry.getUtility(ISettings)
         logger = registry.getUtility(ILogger, name='repoze.bfg.debug')
-        rootfactory = 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.default_root_factory, DefaultRootFactory)
-        
-    def test_no_routes_in_config_no_rootfactory(self):
-        from repoze.bfg.router import DefaultRootFactory
-        from repoze.bfg.interfaces import IRootFactory
-        options= {'reload_templates':True,
-                  'debug_authorization':True}
-        from repoze.bfg.tests import fixtureapp
-        registry = self._callFUT(None, fixtureapp, options=options)
-        rootfactory = registry.getUtility(IRootFactory)
-        self.assertEqual(rootfactory, DefaultRootFactory)
+        self.assertEqual(registry.getUtility(IRootFactory), rootfactory)
+        self.failUnless(registry.getUtility(IRoutesMapper))
 
-    def test_authorization_policy_no_authentication_policy(self):
-        from repoze.bfg.interfaces import IAuthorizationPolicy
-        authzpolicy = DummyContext()
-        from repoze.bfg.tests import routesapp
-        logger = DummyLogger()
-        registry = self._callFUT(
-            None, routesapp, authorization_policy=authzpolicy,
-            debug_logger=logger)
-        self.failIf(registry.queryUtility(IAuthorizationPolicy))
-        self.assertEqual(logger.messages, [])
-        
-    def test_authentication_policy_no_authorization_policy(self):
-        from repoze.bfg.interfaces import IAuthorizationPolicy
-        from repoze.bfg.interfaces import IAuthenticationPolicy
-        from repoze.bfg.authorization import ACLAuthorizationPolicy
-        authnpolicy = DummyContext()
-        from repoze.bfg.tests import routesapp
-        logger = DummyLogger()
-        registry = self._callFUT(
-            None, routesapp, authentication_policy=authnpolicy,
-            debug_logger=logger)
-        self.assertEqual(registry.getUtility(IAuthenticationPolicy),
-                         authnpolicy)
-        self.assertEqual(
-            registry.getUtility(IAuthorizationPolicy).__class__,
-            ACLAuthorizationPolicy)
-        self.assertEqual(len(logger.messages), 1) # deprecation warning
-                        
-    def test_authentication_policy_and_authorization_policy(self):
-        from repoze.bfg.interfaces import IAuthorizationPolicy
-        from repoze.bfg.interfaces import IAuthenticationPolicy
-        authnpolicy = DummyContext()
-        authzpolicy = DummyContext()
-        from repoze.bfg.tests import routesapp
-        logger = DummyLogger()
-        registry = self._callFUT(
-           None, routesapp, authentication_policy=authnpolicy,
-           authorization_policy = authzpolicy,
-           debug_logger=logger)
-        self.assertEqual(registry.getUtility(IAuthenticationPolicy),
-                         authnpolicy)
-        self.assertEqual(registry.getUtility(IAuthorizationPolicy),
-                         authzpolicy)
-        self.assertEqual(len(logger.messages), 1) # deprecation warning
-
-    def test_lock_and_unlock(self):
+    def test_default_config_lock_and_unlock(self):
         from repoze.bfg.tests import fixtureapp
         rootfactory = DummyRootFactory(None)
         dummylock = DummyLock()
-        registry = self._callFUT(
+        registry = self._callDefaultConfiguration(
             rootfactory, fixtureapp, filename='configure.zcml',
             lock=dummylock)
         self.assertEqual(dummylock.acquired, True)
         self.assertEqual(dummylock.released, True)
 
+class TestBFGViewGrokker(unittest.TestCase):
+    def setUp(self):
+        cleanUp()
+
+    def tearDown(self):
+        cleanUp()
+
+    def _getTargetClass(self):
+        from repoze.bfg.configuration import BFGViewGrokker
+        return BFGViewGrokker
+
+    def _makeOne(self, *arg, **kw):
+        return self._getTargetClass()(*arg, **kw)
+
+    def test_grok_is_bfg_view(self):
+        from zope.component import getSiteManager
+        from repoze.bfg.interfaces import IRequest
+        from repoze.bfg.interfaces import IView
+        from zope.interface import Interface
+        from repoze.bfg.configuration import Configurator
+        grokker = self._makeOne()
+        class obj:
+            def __init__(self, context, request):
+                pass
+            def __call__(self):
+                return 'OK'
+        settings = dict(permission='foo', for_=Interface, name='foo.html',
+                        request_type=IRequest, route_name=None,
+                        request_method=None, request_param=None,
+                        containment=None, attr=None, renderer=None,
+                        wrapper=None, xhr=False, header=None,
+                        accept=None)
+        obj.__bfg_view_settings__ = [settings]
+        sm = getSiteManager()
+        config = Configurator(sm)
+        result = grokker.grok('name', obj, _info='', _configurator=config)
+        self.assertEqual(result, True)
+        wrapped = sm.adapters.lookup((Interface, IRequest), IView,
+                                     name='foo.html')
+        self.assertEqual(wrapped(None, None), 'OK')
+
+    def test_grok_is_not_bfg_view(self):
+        grokker = self._makeOne()
+        class obj:
+            pass
+        context = DummyContext()
+        result = grokker.grok('name', obj)
+        self.assertEqual(result, False)
+
+class TestDefaultRootFactory(unittest.TestCase):
+    def _getTargetClass(self):
+        from repoze.bfg.configuration import DefaultRootFactory
+        return DefaultRootFactory
+
+    def _makeOne(self, environ):
+        return self._getTargetClass()(environ)
+
+    def test_no_matchdict(self):
+        environ = {}
+        root = self._makeOne(environ)
+        self.assertEqual(root.__parent__, None)
+        self.assertEqual(root.__name__, None)
+
+    def test_matchdict(self):
+        class DummyRequest:
+            pass
+        request = DummyRequest()
+        request.matchdict = {'a':1, 'b':2}
+        root = self._makeOne(request)
+        self.assertEqual(root.a, 1)
+        self.assertEqual(root.b, 2)
+
+    
+
 class DummyRequest:
     pass
 
@@ -253,3 +637,15 @@ class DummyLock:
     def release(self):
         self.released = True
         
+class DummyPackage:
+    def __init__(self, name):
+        self.__name__ = name
+
+class DummyOverrides:
+    def __init__(self, package):
+        self.package = package
+        self.inserted = []
+
+    def insert(self, path, package, prefix):
+        self.inserted.append((path, package, prefix))
+
diff --git a/repoze/bfg/tests/test_integration.py b/repoze/bfg/tests/test_integration.py
index c1779cdb6..57d22c286 100644
--- a/repoze/bfg/tests/test_integration.py
+++ b/repoze/bfg/tests/test_integration.py
@@ -99,7 +99,6 @@ class TestGrokkedApp(unittest.TestCase):
         from repoze.bfg.view import render_view_to_response
         from zope.interface import directlyProvides
         from repoze.bfg.zcml import zcml_configure
-        from repoze.bfg.interfaces import IView
         from repoze.bfg.interfaces import IRequest
         import repoze.bfg.tests.grokkedapp as package
         
diff --git a/repoze/bfg/tests/test_registry.py b/repoze/bfg/tests/test_registry.py
index 11f5cbf3a..b652d2155 100644
--- a/repoze/bfg/tests/test_registry.py
+++ b/repoze/bfg/tests/test_registry.py
@@ -38,450 +38,6 @@ class TestRegistry(unittest.TestCase):
         registry.registerSubscriptionAdapter(EventHandler, [IFoo], Interface)
         self.assertEqual(registry.has_listeners, True)
 
-    def test__override_not_yet_registered(self):
-        from repoze.bfg.interfaces import IPackageOverrides
-        package = DummyPackage('package')
-        opackage = DummyPackage('opackage')
-        registry = self._makeOne()
-        registry._override(package, 'path', opackage, 'oprefix',
-                           PackageOverrides=DummyOverrides)
-        overrides = registry.queryUtility(IPackageOverrides, name='package')
-        self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')])
-        self.assertEqual(overrides.package, package)
-
-    def test__override_already_registered(self):
-        from repoze.bfg.interfaces import IPackageOverrides
-        package = DummyPackage('package')
-        opackage = DummyPackage('opackage')
-        overrides = DummyOverrides(package)
-        registry = self._makeOne()
-        registry.registerUtility(overrides, IPackageOverrides, name='package')
-        registry._override(package, 'path', opackage, 'oprefix',
-                           PackageOverrides=DummyOverrides)
-        self.assertEqual(overrides.inserted, [('path', 'opackage', 'oprefix')])
-        self.assertEqual(overrides.package, package)
-
-    def _registerRenderer(self, reg, name='.txt'):
-        from repoze.bfg.interfaces import IRendererFactory
-        from repoze.bfg.interfaces import ITemplateRenderer
-        from zope.interface import implements
-        class Renderer:
-            implements(ITemplateRenderer)
-            def __init__(self, path):
-                pass
-            def __call__(self, *arg):
-                return 'Hello!'
-        reg.registerUtility(Renderer, IRendererFactory, name=name)
-
-    def test_map_view_as_function_context_and_request(self):
-        def view(context, request):
-            return 'OK'
-        reg = self._makeOne()
-        result = reg.map_view(view)
-        self.failUnless(result is view)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_map_view_as_function_with_attr(self):
-        def view(context, request):
-            """ """
-        reg = self._makeOne()
-        result = reg.map_view(view, attr='__name__')
-        self.failIf(result is view)
-        self.assertRaises(TypeError, result, None, None)
-
-    def test_map_view_as_function_with_attr_and_renderer(self):
-        reg = self._makeOne()
-        self._registerRenderer(reg)
-        def view(context, request):
-            """ """
-        result = reg.map_view(view, attr='__name__',
-                              renderer_name='fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertRaises(TypeError, result, None, None)
-        
-    def test_map_view_as_function_requestonly(self):
-        reg = self._makeOne()
-        def view(request):
-            return 'OK'
-        result = reg.map_view(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_map_view_as_function_requestonly_with_attr(self):
-        reg = self._makeOne()
-        def view(request):
-            """ """
-        result = reg.map_view(view, attr='__name__')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        self.assertRaises(TypeError, result, None, None)
-
-    def test_map_view_as_newstyle_class_context_and_request(self):
-        reg = self._makeOne()
-        class view(object):
-            def __init__(self, context, request):
-                pass
-            def __call__(self):
-                return 'OK'
-        result = reg.map_view(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_map_view_as_newstyle_class_context_and_request_with_attr(self):
-        reg = self._makeOne()
-        class view(object):
-            def __init__(self, context, request):
-                pass
-            def index(self):
-                return 'OK'
-        result = reg.map_view(view, attr='index')
-        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_map_view_as_newstyle_class_context_and_request_attr_and_renderer(
-        self):
-        reg = self._makeOne()
-        self._registerRenderer(reg)
-        class view(object):
-            def __init__(self, context, request):
-                pass
-            def index(self):
-                return {'a':'1'}
-        result = reg.map_view(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-        
-    def test_map_view_as_newstyle_class_requestonly(self):
-        reg = self._makeOne()
-        class view(object):
-            def __init__(self, request):
-                pass
-            def __call__(self):
-                return 'OK'
-        result = reg.map_view(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_map_view_as_newstyle_class_requestonly_with_attr(self):
-        reg = self._makeOne()
-        class view(object):
-            def __init__(self, request):
-                pass
-            def index(self):
-                return 'OK'
-        result = reg.map_view(view, attr='index')
-        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_map_view_as_newstyle_class_requestonly_with_attr_and_renderer(self):
-        reg = self._makeOne()
-        self._registerRenderer(reg)
-        class view(object):
-            def __init__(self, request):
-                pass
-            def index(self):
-                return {'a':'1'}
-        result = reg.map_view(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test_map_view_as_oldstyle_class_context_and_request(self):
-        reg = self._makeOne()
-        class view:
-            def __init__(self, context, request):
-                pass
-            def __call__(self):
-                return 'OK'
-        result = reg.map_view(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_map_view_as_oldstyle_class_context_and_request_with_attr(self):
-        reg = self._makeOne()
-        class view:
-            def __init__(self, context, request):
-                pass
-            def index(self):
-                return 'OK'
-        result = reg.map_view(view, attr='index')
-        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_map_view_as_oldstyle_class_context_and_request_attr_and_renderer(
-        self):
-        reg = self._makeOne()
-        self._registerRenderer(reg)
-        class view:
-            def __init__(self, context, request):
-                pass
-            def index(self):
-                return {'a':'1'}
-        result = reg.map_view(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test_map_view_as_oldstyle_class_requestonly(self):
-        reg = self._makeOne()
-        class view:
-            def __init__(self, request):
-                pass
-            def __call__(self):
-                return 'OK'
-        result = reg.map_view(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_map_view_as_oldstyle_class_requestonly_with_attr(self):
-        reg = self._makeOne()
-        class view:
-            def __init__(self, request):
-                pass
-            def index(self):
-                return 'OK'
-        result = reg.map_view(view, attr='index')
-        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_map_view_as_oldstyle_class_requestonly_attr_and_renderer(self):
-        reg = self._makeOne()
-        self._registerRenderer(reg)
-        class view:
-            def __init__(self, request):
-                pass
-            def index(self):
-                return {'a':'1'}
-        result = reg.map_view(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.assertEqual(view.__name__, result.__name__)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test_map_view_as_instance_context_and_request(self):
-        reg = self._makeOne()
-        class View:
-            def __call__(self, context, request):
-                return 'OK'
-        view = View()
-        result = reg.map_view(view)
-        self.failUnless(result is view)
-        self.assertEqual(result(None, None), 'OK')
-        
-    def test_map_view_as_instance_context_and_request_and_attr(self):
-        reg = self._makeOne()
-        class View:
-            def index(self, context, request):
-                return 'OK'
-        view = View()
-        result = reg.map_view(view, attr='index')
-        self.failIf(result is view)
-        self.assertEqual(result(None, None), 'OK')
-
-    def test_map_view_as_instance_context_and_request_attr_and_renderer(self):
-        reg = self._makeOne()
-        self._registerRenderer(reg)
-        class View:
-            def index(self, context, request):
-                return {'a':'1'}
-        view = View()
-        result = reg.map_view(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test_map_view_as_instance_requestonly(self):
-        reg = self._makeOne()
-        class View:
-            def __call__(self, request):
-                return 'OK'
-        view = View()
-        result = reg.map_view(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')
-
-    def test_map_view_as_instance_requestonly_with_attr(self):
-        reg = self._makeOne()
-        class View:
-            def index(self, request):
-                return 'OK'
-        view = View()
-        result = reg.map_view(view, attr='index')
-        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')
-
-    def test_map_view_as_instance_requestonly_with_attr_and_renderer(self):
-        reg = self._makeOne()
-        self._registerRenderer(reg)
-        class View:
-            def index(self, request):
-                return {'a':'1'}
-        view = View()
-        result = reg.map_view(
-            view, attr='index',
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        self.failUnless('instance' in result.__name__)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test_map_view_rendereronly(self):
-        reg = self._makeOne()
-        self._registerRenderer(reg)
-        def view(context, request):
-            return {'a':'1'}
-        result = reg.map_view(
-            view,
-            renderer_name='repoze.bfg.tests:fixtures/minimal.txt')
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-    def test_map_view_defaultrendereronly(self):
-        reg = self._makeOne()
-        self._registerRenderer(reg, name='')
-        def view(context, request):
-            return {'a':'1'}
-        result = reg.map_view(view)
-        self.failIf(result is view)
-        self.assertEqual(view.__module__, result.__module__)
-        self.assertEqual(view.__doc__, result.__doc__)
-        request = DummyRequest()
-        self.assertEqual(result(None, request).body, 'Hello!')
-
-class TestBFGViewGrokker(unittest.TestCase):
-    def setUp(self):
-        cleanUp()
-
-    def tearDown(self):
-        cleanUp()
-
-    def _getTargetClass(self):
-        from repoze.bfg.registry import BFGViewGrokker
-        return BFGViewGrokker
-
-    def _makeOne(self, *arg, **kw):
-        return self._getTargetClass()(*arg, **kw)
-
-    def test_grok_is_bfg_view(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.interfaces import IView
-        from zope.interface import Interface
-        grokker = self._makeOne()
-        class obj:
-            def __init__(self, context, request):
-                pass
-            def __call__(self):
-                return 'OK'
-        settings = dict(permission='foo', for_=Interface, name='foo.html',
-                        request_type=IRequest, route_name=None,
-                        request_method=None, request_param=None,
-                        containment=None, attr=None, renderer=None,
-                        wrapper=None, xhr=False, header=None,
-                        accept=None)
-        obj.__bfg_view_settings__ = [settings]
-        sm = getSiteManager()
-        result = grokker.grok('name', obj, _info='', _registry=sm)
-        self.assertEqual(result, True)
-        wrapped = sm.adapters.lookup((Interface, IRequest), IView,
-                                     name='foo.html')
-        self.assertEqual(wrapped(None, None), 'OK')
-
-    def test_grok_is_not_bfg_view(self):
-        grokker = self._makeOne()
-        class obj:
-            pass
-        context = DummyContext()
-        result = grokker.grok('name', obj, context=context)
-        self.assertEqual(result, False)
-        actions = context.actions
-        self.assertEqual(len(actions), 0)
-
-class TestDefaultRootFactory(unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.registry import DefaultRootFactory
-        return DefaultRootFactory
-
-    def _makeOne(self, environ):
-        return self._getTargetClass()(environ)
-
-    def test_no_matchdict(self):
-        environ = {}
-        root = self._makeOne(environ)
-        self.assertEqual(root.__parent__, None)
-        self.assertEqual(root.__name__, None)
-
-    def test_matchdict(self):
-        class DummyRequest:
-            pass
-        request = DummyRequest()
-        request.matchdict = {'a':1, 'b':2}
-        root = self._makeOne(request)
-        self.assertEqual(root.a, 1)
-        self.assertEqual(root.b, 2)
-
 class DummyModule:
     __path__ = "foo"
     __name__ = "dummy"
@@ -494,18 +50,6 @@ class DummyContext:
         self.info = None
         self.resolved = resolved
 
-class DummyPackage:
-    def __init__(self, name):
-        self.__name__ = name
-
-class DummyOverrides:
-    def __init__(self, package):
-        self.package = package
-        self.inserted = []
-
-    def insert(self, path, package, prefix):
-        self.inserted.append((path, package, prefix))
-
 class DummyRequest:
     def __init__(self, environ=None):
         if environ is None:
diff --git a/repoze/bfg/tests/test_router.py b/repoze/bfg/tests/test_router.py
index 07c10adaa..3321af938 100644
--- a/repoze/bfg/tests/test_router.py
+++ b/repoze/bfg/tests/test_router.py
@@ -14,6 +14,27 @@ class TestRouter(unittest.TestCase):
         getSiteManager.reset()
         cleanUp()
 
+    def _registerRouteRequest(self, name):
+        from repoze.bfg.interfaces import IRouteRequest
+        from zope.interface import Interface
+        from zope.component import getSiteManager
+        class IRequest(Interface):
+            """ """
+        sm = getSiteManager()
+        sm.registerUtility(IRequest, IRouteRequest, name=name)
+        return IRequest
+
+    def _connectRoute(self, path, name, factory=None):
+        from repoze.bfg.interfaces import IRoutesMapper
+        from zope.component import getSiteManager
+        from repoze.bfg.urldispatch import RoutesMapper
+        sm = getSiteManager()
+        mapper = sm.queryUtility(IRoutesMapper)
+        if mapper is None:
+            mapper = RoutesMapper()
+            sm.registerUtility(mapper, IRoutesMapper)
+        mapper.connect(path, name, factory)
+
     def _registerLogger(self):
         from zope.component import getSiteManager
         gsm = getSiteManager()
@@ -420,6 +441,80 @@ class TestRouter(unittest.TestCase):
         self.assertEqual(len(router.threadlocal_manager.pushed), 1)
         self.assertEqual(len(router.threadlocal_manager.popped), 1)
 
+    def test_call_route_matches_and_has_factory(self):
+        req_iface = self._registerRouteRequest('foo')
+        root = object()
+        def factory(request):
+            return root
+        self._connectRoute('archives/:action/:article', 'foo', factory)
+        context = DummyContext()
+        self._registerTraverserFactory(context)
+        response = DummyResponse()
+        response.app_iter = ['Hello world']
+        view = DummyView(response)
+        environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
+        self._registerView(view, '', None, None)
+        rootfactory = self._registerRootFactory(context)
+        router = self._makeOne()
+        start_response = DummyStartResponse()
+        result = router(environ, start_response)
+        self.assertEqual(result, ['Hello world'])
+        self.assertEqual(start_response.headers, ())
+        self.assertEqual(start_response.status, '200 OK')
+        request = view.request
+        self.assertEqual(request.view_name, '')
+        self.assertEqual(request.subpath, [])
+        self.assertEqual(request.context, context)
+        self.assertEqual(request.root, root)
+        routing_args = environ['wsgiorg.routing_args'][1]
+        self.assertEqual(routing_args['action'], 'action1')
+        self.assertEqual(routing_args['article'], 'article1')
+        self.assertEqual(environ['bfg.routes.matchdict'], routing_args)
+        self.assertEqual(environ['bfg.routes.route'].name, 'foo')
+        self.assertEqual(request.matchdict, routing_args)
+        self.failUnless(req_iface.providedBy(request))
+
+    def test_call_route_matches_doesnt_overwrite_subscriber_iface(self):
+        from repoze.bfg.interfaces import INewRequest
+        from zope.interface import alsoProvides
+        from zope.interface import Interface
+        req_iface = self._registerRouteRequest('foo')
+        class IFoo(Interface):
+            pass
+        def listener(event):
+            alsoProvides(event.request, IFoo)
+        self.registry.registerHandler(listener, (INewRequest,))
+        root = object()
+        def factory(request):
+            return root
+        self._connectRoute('archives/:action/:article', 'foo', factory)
+        context = DummyContext()
+        self._registerTraverserFactory(context)
+        response = DummyResponse()
+        response.app_iter = ['Hello world']
+        view = DummyView(response)
+        environ = self._makeEnviron(PATH_INFO='/archives/action1/article1')
+        self._registerView(view, '', None, None)
+        rootfactory = self._registerRootFactory(context)
+        router = self._makeOne()
+        start_response = DummyStartResponse()
+        result = router(environ, start_response)
+        self.assertEqual(result, ['Hello world'])
+        self.assertEqual(start_response.headers, ())
+        self.assertEqual(start_response.status, '200 OK')
+        request = view.request
+        self.assertEqual(request.view_name, '')
+        self.assertEqual(request.subpath, [])
+        self.assertEqual(request.context, context)
+        self.assertEqual(request.root, root)
+        routing_args = environ['wsgiorg.routing_args'][1]
+        self.assertEqual(routing_args['action'], 'action1')
+        self.assertEqual(routing_args['article'], 'article1')
+        self.assertEqual(environ['bfg.routes.matchdict'], routing_args)
+        self.assertEqual(environ['bfg.routes.route'].name, 'foo')
+        self.assertEqual(request.matchdict, routing_args)
+        self.failUnless(req_iface.providedBy(request))
+        self.failUnless(IFoo.providedBy(request))
 
 class TestMakeApp(unittest.TestCase):
     def setUp(self):
@@ -430,42 +525,34 @@ class TestMakeApp(unittest.TestCase):
 
     def _callFUT(self, *arg, **kw):
         from repoze.bfg.router import make_app
-        return make_app(None, *arg, **kw)
-
-    def _get_make_registry(self, sm):
-        class DummyMakeRegistry(object):
-            def __call__(self, *arg):
-                self.arg = arg
-                return sm
-        return DummyMakeRegistry()
+        return make_app(*arg, **kw)
 
     def test_it(self):
         from repoze.bfg.interfaces import IWSGIApplicationCreatedEvent
         from repoze.bfg.tests import fixtureapp
         from zope.component import getSiteManager
         sm = getSiteManager()
-        dummy_make_registry = self._get_make_registry(sm)
         def subscriber(event):
             event.app.created = True        
         manager = DummyRegistryManager()
         sm.registerHandler(subscriber, (IWSGIApplicationCreatedEvent,))
         rootfactory = DummyRootFactory(None)
         settings = {'a':1}
-        app = self._callFUT(rootfactory, fixtureapp, manager=manager,
-                            settings=settings,
-                            make_registry=dummy_make_registry)
+        app = self._callFUT(rootfactory, fixtureapp, settings=settings,
+                            Configurator=DummyConfigurator, manager=manager)
         self.failUnless(app.created)
         self.failUnless(manager.pushed)
         self.failUnless(manager.popped)
-        self.assertEqual(len(dummy_make_registry.arg), 6)
-        self.assertEqual(dummy_make_registry.arg[-1], settings)
+        self.assertEqual(app.registry.root_factory, rootfactory)
+        self.assertEqual(app.registry.settings, settings)
+        self.assertEqual(app.registry.package, fixtureapp)
+        self.assertEqual(app.registry.filename, 'configure.zcml')
 
     def test_it_options_means_settings(self):
         from repoze.bfg.interfaces import IWSGIApplicationCreatedEvent
-        from zope.component import getSiteManager
         from repoze.bfg.tests import fixtureapp
+        from zope.component import getSiteManager
         sm = getSiteManager()
-        dummy_make_registry = self._get_make_registry(sm)
         def subscriber(event):
             event.app.created = True        
         manager = DummyRegistryManager()
@@ -473,13 +560,14 @@ class TestMakeApp(unittest.TestCase):
         rootfactory = DummyRootFactory(None)
         settings = {'a':1}
         app = self._callFUT(rootfactory, fixtureapp, options=settings,
-                            manager=manager,
-                            make_registry=dummy_make_registry)
+                            Configurator=DummyConfigurator, manager=manager)
         self.failUnless(app.created)
         self.failUnless(manager.pushed)
         self.failUnless(manager.popped)
-        self.assertEqual(len(dummy_make_registry.arg), 6)
-        self.assertEqual(dummy_make_registry.arg[-1], settings)
+        self.assertEqual(app.registry.root_factory, rootfactory)
+        self.assertEqual(app.registry.settings, settings)
+        self.assertEqual(app.registry.package, fixtureapp)
+        self.assertEqual(app.registry.filename, 'configure.zcml')
 
 class DummyContext:
     pass
@@ -551,3 +639,14 @@ class DummyRegistryManager:
     def pop(self):
         self.popped = True
 
+class DummyConfigurator(object):
+    def __init__(self, registry):
+        self.registry = registry
+        
+    def default_configuration(self, root_factory=None, package=None,
+                              filename=None, settings=None):
+        self.registry.root_factory = root_factory
+        self.registry.package = package
+        self.registry.filename = filename
+        self.registry.settings = settings
+                
diff --git a/repoze/bfg/tests/test_threadlocal.py b/repoze/bfg/tests/test_threadlocal.py
index 09a25debd..b277d6cb9 100644
--- a/repoze/bfg/tests/test_threadlocal.py
+++ b/repoze/bfg/tests/test_threadlocal.py
@@ -1,12 +1,12 @@
-from repoze.bfg.testing import cleanUp
+from repoze.bfg import testing
 import unittest
 
 class TestThreadLocalManager(unittest.TestCase):
     def setUp(self):
-        cleanUp()
+        testing.setUp()
 
     def tearDown(self):
-        cleanUp()
+        testing.tearDown()
 
     def _getTargetClass(self):
         from repoze.bfg.threadlocal import ThreadLocalManager
@@ -67,24 +67,29 @@ class TestGetCurrentRequest(unittest.TestCase):
 
 class GetCurrentRegistryTests(unittest.TestCase):
     def setUp(self):
-        cleanUp()
+        testing.setUp()
 
     def tearDown(self):
-        cleanUp()
+        testing.tearDown()
         
     def _callFUT(self):
         from repoze.bfg.threadlocal import get_current_registry
         return get_current_registry()
 
-    def test_local(self):
+    def test_it(self):
         from repoze.bfg.threadlocal import manager
         try:
             manager.push({'registry':123})
             self.assertEqual(self._callFUT(), 123)
         finally:
             manager.pop()
-    
-    def test_global(self):
+
+class GetCurrentRegistryWithoutTestingRegistry(unittest.TestCase):
+    def _callFUT(self):
+        from repoze.bfg.threadlocal import get_current_registry
+        return get_current_registry()
+
+    def test_it(self):
         from zope.component import getGlobalSiteManager
         self.assertEqual(self._callFUT(), getGlobalSiteManager())
     
diff --git a/repoze/bfg/tests/test_urldispatch.py b/repoze/bfg/tests/test_urldispatch.py
index ecc76fe04..18ebe3e98 100644
--- a/repoze/bfg/tests/test_urldispatch.py
+++ b/repoze/bfg/tests/test_urldispatch.py
@@ -35,7 +35,7 @@ class TestRoute(unittest.TestCase):
         route = self._makeOne(':path')
         self.assertEqual(route.generate({'path':'abc'}), '/abc')
 
-class RoutesRootFactoryTests(unittest.TestCase):
+class RoutesMapperTests(unittest.TestCase):
     def setUp(self):
         testing.setUp()
 
@@ -52,213 +52,92 @@ class RoutesRootFactoryTests(unittest.TestCase):
         request.registry = sm
         return request
 
-    def _registerRouteRequest(self, name):
-        from repoze.bfg.interfaces import IRouteRequest
-        from zope.interface import Interface
-        from zope.component import getSiteManager
-        class IRequest(Interface):
-            """ """
-        sm = getSiteManager()
-        sm.registerUtility(IRequest, IRouteRequest, name=name)
-        return IRequest
-
     def _getTargetClass(self):
-        from repoze.bfg.urldispatch import RoutesRootFactory
-        return RoutesRootFactory
+        from repoze.bfg.urldispatch import RoutesMapper
+        return RoutesMapper
 
-    def _makeOne(self, get_root):
+    def _makeOne(self):
         klass = self._getTargetClass()
-        return klass(get_root)
-
-    def test_init_default_root_factory(self):
-        mapper = self._makeOne(None)
-        self.assertEqual(mapper.default_root_factory, None)
+        return klass()
 
     def test_no_route_matches(self):
-        root_factory = DummyRootFactory(123)
-        mapper = self._makeOne(root_factory)
+        mapper = self._makeOne()
         request = self._getRequest(PATH_INFO='/')
         result = mapper(request)
-        self.assertEqual(result, 123)
-
-    def test_passed_environ_returns_default(self):
-        root_factory = DummyRootFactory(123)
-        mapper = self._makeOne(root_factory)
-        request = self._getRequest(PATH_INFO='/')
-        result = mapper(request.environ)
-        self.assertEqual(result, 123)
-        self.assertEqual(root_factory.request, request.environ)
+        self.assertEqual(result['match'], None)
+        self.assertEqual(result['route'], None)
 
     def test_route_matches(self):
-        root_factory = DummyRootFactory(123)
-        req_iface = self._registerRouteRequest('foo')
-        mapper = self._makeOne(root_factory)
-        mapper.connect('archives/:action/:article', 'foo')
-        request = self._getRequest(PATH_INFO='/archives/action1/article1')
-        result = mapper(request)
-        self.assertEqual(result, 123)
-        environ = request.environ
-        routing_args = environ['wsgiorg.routing_args'][1]
-        self.assertEqual(routing_args['action'], 'action1')
-        self.assertEqual(routing_args['article'], 'article1')
-        self.assertEqual(environ['bfg.routes.matchdict'], routing_args)
-        self.assertEqual(environ['bfg.routes.route'].name, 'foo')
-        self.assertEqual(request.matchdict, routing_args)
-        self.failUnless(req_iface.providedBy(request))
-
-    def test_route_matches_already_has_iface(self):
-        from zope.interface import Interface
-        from zope.interface import directlyProvides
-        root_factory = DummyRootFactory(123)
-        req_iface = self._registerRouteRequest('foo')
-        mapper = self._makeOne(root_factory)
+        mapper = self._makeOne()
         mapper.connect('archives/:action/:article', 'foo')
         request = self._getRequest(PATH_INFO='/archives/action1/article1')
-        class IFoo(Interface):
-            pass
-        directlyProvides(request, IFoo)
-        result = mapper(request)
-        self.assertEqual(result, 123)
-        environ = request.environ
-        routing_args = environ['wsgiorg.routing_args'][1]
-        self.assertEqual(routing_args['action'], 'action1')
-        self.assertEqual(routing_args['article'], 'article1')
-        self.assertEqual(environ['bfg.routes.matchdict'], routing_args)
-        self.assertEqual(environ['bfg.routes.route'].name, 'foo')
-        self.assertEqual(request.matchdict, routing_args)
-        self.failUnless(req_iface.providedBy(request))
-        self.failUnless(IFoo.providedBy(request))
-
-    def test_route_matches_and_has_factory(self):
-        root_factory = DummyRootFactory(123)
-        req_iface = self._registerRouteRequest('foo')
-        mapper = self._makeOne(root_factory)
-        factory = DummyRootFactory(456)
-        mapper.connect('archives/:action/:article', 'foo', factory)
-        request = self._getRequest(PATH_INFO='/archives/action1/article1')
         result = mapper(request)
-        self.assertEqual(result, 456)
-        self.assertEqual(factory.request, request)
-        environ = request.environ
-        routing_args = environ['wsgiorg.routing_args'][1]
-        self.assertEqual(routing_args['action'], 'action1')
-        self.assertEqual(routing_args['article'], 'article1')
-        self.assertEqual(environ['bfg.routes.matchdict'], routing_args)
-        self.assertEqual(environ['bfg.routes.route'].name, 'foo')
-        self.assertEqual(request.matchdict, routing_args)
-        self.failUnless(req_iface.providedBy(request))
+        self.assertEqual(result['route'], mapper.routes['foo'])
+        self.assertEqual(result['match']['action'], 'action1')
+        self.assertEqual(result['match']['article'], 'article1')
 
     def test_route_matches_with_predicates(self):
-        root_factory = DummyRootFactory(123)
-        req_iface = self._registerRouteRequest('foo')
-        mapper = self._makeOne(root_factory)
+        mapper = self._makeOne()
         mapper.connect('archives/:action/:article', 'foo',
                        predicates=[lambda *arg: True])
         request = self._getRequest(PATH_INFO='/archives/action1/article1')
         result = mapper(request)
-        self.assertEqual(result, 123)
-        environ = request.environ
-        routing_args = environ['wsgiorg.routing_args'][1]
-        self.assertEqual(routing_args['action'], 'action1')
-        self.assertEqual(routing_args['article'], 'article1')
-        self.assertEqual(environ['bfg.routes.matchdict'], routing_args)
-        self.assertEqual(environ['bfg.routes.route'].name, 'foo')
-        self.assertEqual(request.matchdict, routing_args)
-        self.failUnless(req_iface.providedBy(request))
+        self.assertEqual(result['route'], mapper.routes['foo'])
+        self.assertEqual(result['match']['action'], 'action1')
+        self.assertEqual(result['match']['article'], 'article1')
 
     def test_route_fails_to_match_with_predicates(self):
-        root_factory = DummyRootFactory(123)
-        foo_iface = self._registerRouteRequest('foo')
-        bar_iface = self._registerRouteRequest('bar')
-        mapper = self._makeOne(root_factory)
+        mapper = self._makeOne()
         mapper.connect('archives/:action/article1', 'foo',
                        predicates=[lambda *arg: True, lambda *arg: False])
         mapper.connect('archives/:action/:article', 'bar')
         request = self._getRequest(PATH_INFO='/archives/action1/article1')
         result = mapper(request)
-        self.assertEqual(result, 123)
-        environ = request.environ
-        routing_args = environ['wsgiorg.routing_args'][1]
-        self.assertEqual(routing_args['action'], 'action1')
-        self.assertEqual(routing_args['article'], 'article1')
-        self.assertEqual(environ['bfg.routes.matchdict'], routing_args)
-        self.assertEqual(environ['bfg.routes.route'].name, 'bar')
-        self.assertEqual(request.matchdict, routing_args)
-        self.failUnless(bar_iface.providedBy(request))
-        self.failIf(foo_iface.providedBy(request))
+        self.assertEqual(result['route'], mapper.routes['bar'])
+        self.assertEqual(result['match']['action'], 'action1')
+        self.assertEqual(result['match']['article'], 'article1')
 
     def test_root_route_matches(self):
-        root_factory = DummyRootFactory(123)
-        req_iface = self._registerRouteRequest('root')
-        mapper = self._makeOne(root_factory)
+        mapper = self._makeOne()
         mapper.connect('', 'root')
         request = self._getRequest(PATH_INFO='/')
         result = mapper(request)
-        environ = request.environ
-        self.assertEqual(result, 123)
-        self.assertEqual(environ['bfg.routes.route'].name, 'root')
-        self.assertEqual(environ['bfg.routes.matchdict'], {})
-        self.assertEqual(environ['wsgiorg.routing_args'], ((), {}))
-        self.assertEqual(request.matchdict, {})
-        self.failUnless(req_iface.providedBy(request))
+        self.assertEqual(result['route'], mapper.routes['root'])
+        self.assertEqual(result['match'], {})
 
     def test_root_route_matches2(self):
-        root_factory = DummyRootFactory(123)
-        req_iface = self._registerRouteRequest('root')
-        mapper = self._makeOne(root_factory)
+        mapper = self._makeOne()
         mapper.connect('/', 'root')
         request = self._getRequest(PATH_INFO='/')
         result = mapper(request)
-        environ = request.environ
-        self.assertEqual(result, 123)
-        self.assertEqual(environ['bfg.routes.route'].name, 'root')
-        self.assertEqual(environ['bfg.routes.matchdict'], {})
-        self.assertEqual(environ['wsgiorg.routing_args'], ((), {}))
-        self.assertEqual(request.matchdict, {})
-        self.failUnless(req_iface.providedBy(request))
+        self.assertEqual(result['route'], mapper.routes['root'])
+        self.assertEqual(result['match'], {})
 
     def test_root_route_when_path_info_empty(self):
-        root_factory = DummyRootFactory(123)
-        req_iface = self._registerRouteRequest('root')
-        mapper = self._makeOne(root_factory)
+        mapper = self._makeOne()
         mapper.connect('/', 'root')
         request = self._getRequest(PATH_INFO='')
         result = mapper(request)
-        environ = request.environ
-        self.assertEqual(result, 123)
-        self.assertEqual(environ['bfg.routes.route'].name, 'root')
-        self.assertEqual(environ['bfg.routes.matchdict'], {})
-        self.assertEqual(environ['wsgiorg.routing_args'], ((), {}))
-        self.assertEqual(request.matchdict, {})
-        self.failUnless(req_iface.providedBy(request))
-
-    def test_fallback_to_default_root_factory(self):
-        root_factory = DummyRootFactory(123)
-        mapper = self._makeOne(root_factory)
-        mapper.connect('wont/:be/:found', 'wont')
-        request = self._getRequest(PATH_INFO='/archives/action1/article1')
-        result = mapper(request)
-        self.assertEqual(result, 123)
-        self.assertEqual(root_factory.request, request)
+        self.assertEqual(result['route'], mapper.routes['root'])
+        self.assertEqual(result['match'], {})
 
     def test_no_path_info(self):
-        root_factory = DummyRootFactory(123)
-        mapper = self._makeOne(root_factory)
+        mapper = self._makeOne()
         mapper.connect('/', 'root')
         request = self._getRequest()
         result = mapper(request)
-        self.assertEqual(result, 123)
-        self.assertEqual(root_factory.request, request)
+        self.assertEqual(result['route'], mapper.routes['root'])
+        self.assertEqual(result['match'], {})
 
     def test_has_routes(self):
-        mapper = self._makeOne(None)
+        mapper = self._makeOne()
         self.assertEqual(mapper.has_routes(), False)
         mapper.connect('whatever', 'archives/:action/:article')
         self.assertEqual(mapper.has_routes(), True)
 
     def test_get_routes(self):
         from repoze.bfg.urldispatch import Route
-        mapper = self._makeOne(None)
+        mapper = self._makeOne()
         self.assertEqual(mapper.get_routes(), [])
         mapper.connect('whatever', 'archives/:action/:article')
         routes = mapper.get_routes()
@@ -266,7 +145,7 @@ class RoutesRootFactoryTests(unittest.TestCase):
         self.assertEqual(routes[0].__class__, Route)
 
     def test_generate(self):
-        mapper = self._makeOne(None)
+        mapper = self._makeOne()
         def generator(kw):
             return 123
         route = DummyRoute(generator)
diff --git a/repoze/bfg/tests/test_zcml.py b/repoze/bfg/tests/test_zcml.py
index 1a7275932..af2b64de6 100644
--- a/repoze/bfg/tests/test_zcml.py
+++ b/repoze/bfg/tests/test_zcml.py
@@ -2581,53 +2581,62 @@ class TestResourceDirective(unittest.TestCase):
 
     def test_no_colons(self):
         from zope.component import getSiteManager
+        from repoze.bfg.configuration import Configurator
         context = DummyContext()
         self._callFUT(context, 'a', 'b')
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
         sm = getSiteManager()
-        self.assertEqual(action['callable'], sm.resource)
+        self.assertEqual(action['callable'].im_func,
+                         Configurator.resource.im_func)
         self.assertEqual(action['discriminator'], None)
         self.assertEqual(action['args'], ('a', 'b', None))
 
     def test_with_colons(self):
         from zope.component import getSiteManager
+        from repoze.bfg.configuration import Configurator
         context = DummyContext()
         self._callFUT(context, 'a:foo.pt', 'b:foo.pt')
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
         sm = getSiteManager()
-        self.assertEqual(action['callable'], sm.resource)
+        self.assertEqual(action['callable'].im_func,
+                         Configurator.resource.im_func)
         self.assertEqual(action['discriminator'], None)
         self.assertEqual(action['args'], ('a:foo.pt', 'b:foo.pt', None))
 
     def test_override_module_with_directory(self):
         from zope.component import getSiteManager
+        from repoze.bfg.configuration import Configurator
         context = DummyContext()
         self._callFUT(context, 'a', 'b:foo/')
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
         sm = getSiteManager()
-        self.assertEqual(action['callable'], sm.resource)
+        self.assertEqual(action['callable'].im_func,
+                         Configurator.resource.im_func)
         self.assertEqual(action['discriminator'], None)
         self.assertEqual(action['args'], ('a', 'b:foo/', None))
 
     def test_override_directory_with_module(self):
         from zope.component import getSiteManager
+        from repoze.bfg.configuration import Configurator
         context = DummyContext()
         self._callFUT(context, 'a:foo/', 'b')
         actions = context.actions
         self.assertEqual(len(actions), 1)
         action = actions[0]
         sm = getSiteManager()
-        self.assertEqual(action['callable'], sm.resource)
+        self.assertEqual(action['callable'].im_func,
+                         Configurator.resource.im_func)
         self.assertEqual(action['discriminator'], None)
         self.assertEqual(action['args'], ('a:foo/', 'b', None))
 
     def test_override_module_with_module(self):
+        from repoze.bfg.configuration import Configurator
         from zope.component import getSiteManager
         context = DummyContext()
         self._callFUT(context, 'a', 'b')
@@ -2635,7 +2644,8 @@ class TestResourceDirective(unittest.TestCase):
         self.assertEqual(len(actions), 1)
         action = actions[0]
         sm = getSiteManager()
-        self.assertEqual(action['callable'], sm.resource)
+        self.assertEqual(action['callable'].im_func,
+                         Configurator.resource.im_func)
         self.assertEqual(action['discriminator'], None)
         self.assertEqual(action['args'], ('a', 'b', None))
 
@@ -2697,7 +2707,7 @@ class TestZCMLScanDirective(unittest.TestCase):
         return scan(context, package, martian)
 
     def test_it(self):
-        from repoze.bfg.registry import BFGMultiGrokker
+        from repoze.bfg.configuration import BFGMultiGrokker
         martian = DummyMartianModule()
         module_grokker = DummyModuleGrokker()
         dummy_module = DummyModule()
@@ -2720,11 +2730,11 @@ class DummyModuleGrokker:
         self.multi_grokker = grokker
         
 class DummyMartianModule:
-    def grok_dotted_name(self, name, grokker, _info, _registry,
+    def grok_dotted_name(self, name, grokker, _info, _configurator,
                          exclude_filter=None):
         self.name = name
         self.info = _info
-        self.registry = _registry
+        self.configurator = _configurator
         self.exclude_filter = exclude_filter
         return True