Move configuration methods into Configurator.

1 files changed, 515 insertions, 119 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))
+