Move configuration methods into Configurator.

1 files changed, 0 insertions, 456 deletions

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: