- The ``repoze.bfg.scripting.get_root`` API now uses a 'real' WebOb

  request rather than a FakeRequest when it sets up the request as a
  threadlocal.

- The ``repoze.bfg.traversal.traverse`` API now uses a 'real' WebOb
  request rather than a FakeRequest when it calls the traverser.

- The ``repoze.bfg.request.FakeRequest`` class has been removed.


  ``repoze.bfg.url.route_url``

  ``repoze.bfg.url.model_url``

  ``repoze.bfg.url.static_url``

  ``repoze.bfg.traversal.virtual_root``

   Each of these functions now expects to be called with a request
   object that has a ``registry`` attribute which represents the
   current ZCA registry.  

Get rid of extraneous uses of ZCA threadlocal API.

5 files changed, 102 insertions, 116 deletions

diff --git a/repoze/bfg/tests/test_paster.py b/repoze/bfg/tests/test_paster.py
index d9cbefb5e..6091aec44 100644
--- a/repoze/bfg/tests/test_paster.py
+++ b/repoze/bfg/tests/test_paster.py
@@ -27,7 +27,7 @@ class TestBFGShellCommand(unittest.TestCase):
         self.assertEqual(len(app.threadlocal_manager.pushed), 1)
         pushed = app.threadlocal_manager.pushed[0]
         self.assertEqual(pushed['registry'], dummy_registry)
-        self.assertEqual(pushed['request'].environ, {})
+        self.assertEqual(pushed['request'].registry, dummy_registry)
         self.assertEqual(interact.local, {'root':dummy_root})
         self.failUnless(interact.banner)
         self.assertEqual(len(app.threadlocal_manager.popped), 1)
@@ -51,7 +51,7 @@ class TestBFGShellCommand(unittest.TestCase):
         self.assertEqual(len(app.threadlocal_manager.pushed), 1)
         pushed = app.threadlocal_manager.pushed[0]
         self.assertEqual(pushed['registry'], dummy_registry)
-        self.assertEqual(pushed['request'].environ, {})
+        self.assertEqual(pushed['request'].registry, dummy_registry)
         self.assertEqual(dummy_shell_factory.shell.local_ns,{'root':dummy_root})
         self.assertEqual(dummy_shell_factory.shell.global_ns, {})
         self.failUnless('\n\n' in dummy_shell_factory.shell.IP.BANNER)
diff --git a/repoze/bfg/tests/test_request.py b/repoze/bfg/tests/test_request.py
index a10ba1a75..6dd05a1ec 100644
--- a/repoze/bfg/tests/test_request.py
+++ b/repoze/bfg/tests/test_request.py
@@ -165,24 +165,6 @@ class Test_add_global_response_headers(unittest.TestCase):
         self._callFUT(request, [('c', 1)])
         self.assertEqual(request.global_response_headers, headers + [('c', 1)])
 
-class TestFakeRequest(unittest.TestCase):
-    def _makeOne(self, environ):
-        from repoze.bfg.request import FakeRequest
-        return FakeRequest(environ)
-
-    def test_environ(self):
-        environ = {'a':1, 'b':2}
-        request = self._makeOne(environ)
-        self.assertEqual(request.environ['a'], 1)
-        self.assertEqual(request.environ['b'], 2)
-        
-    def test_asdict(self):
-        environ = {'a':1, 'b':2}
-        request = self._makeOne(environ)
-        self.assertEqual(request['a'], 1)
-        self.assertEqual(request['b'], 2)
-
-
 class DummyRequest:
     def __init__(self, environ=None):
         if environ is None:
diff --git a/repoze/bfg/tests/test_scripting.py b/repoze/bfg/tests/test_scripting.py
index 41542f457..4d45a6456 100644
--- a/repoze/bfg/tests/test_scripting.py
+++ b/repoze/bfg/tests/test_scripting.py
@@ -11,7 +11,7 @@ class TestGetRoot(unittest.TestCase):
         self.assertEqual(len(app.threadlocal_manager.pushed), 1)
         pushed = app.threadlocal_manager.pushed[0]
         self.assertEqual(pushed['registry'], dummy_registry)
-        self.assertEqual(pushed['request'].environ, {})
+        self.assertEqual(pushed['request'].registry, app.registry)
         self.assertEqual(len(app.threadlocal_manager.popped), 0)
         closer()
         self.assertEqual(len(app.threadlocal_manager.popped), 1)
diff --git a/repoze/bfg/tests/test_traversal.py b/repoze/bfg/tests/test_traversal.py
index a15716d4c..be62939e5 100644
--- a/repoze/bfg/tests/test_traversal.py
+++ b/repoze/bfg/tests/test_traversal.py
@@ -390,11 +390,11 @@ class FindModelTests(unittest.TestCase):
         return find_model(context, name)
 
     def _registerTraverser(self, traverser):
-        import zope.component
-        sm = zope.component.getSiteManager()
+        from repoze.bfg.threadlocal import get_current_registry
+        reg = get_current_registry()
         from repoze.bfg.interfaces import ITraverser
         from zope.interface import Interface
-        sm.registerAdapter(traverser, (Interface,), ITraverser)
+        reg.registerAdapter(traverser, (Interface,), ITraverser)
 
     def test_list(self):
         model = DummyContext()
@@ -402,7 +402,7 @@ class FindModelTests(unittest.TestCase):
         self._registerTraverser(traverser)
         result = self._callFUT(model, [''])
         self.assertEqual(result, model)
-        self.assertEqual(model.environ['PATH_INFO'], '/')
+        self.assertEqual(model.request.environ['PATH_INFO'], '/')
 
     def test_generator(self):
         model = DummyContext()
@@ -412,7 +412,7 @@ class FindModelTests(unittest.TestCase):
             yield ''
         result = self._callFUT(model, foo())
         self.assertEqual(result, model)
-        self.assertEqual(model.environ['PATH_INFO'], '/')
+        self.assertEqual(model.request.environ['PATH_INFO'], '/')
 
     def test_self_string_found(self):
         model = DummyContext()
@@ -420,7 +420,7 @@ class FindModelTests(unittest.TestCase):
         self._registerTraverser(traverser)
         result = self._callFUT(model, '')
         self.assertEqual(result, model)
-        self.assertEqual(model.environ['PATH_INFO'], '')
+        self.assertEqual(model.request.environ['PATH_INFO'], '')
 
     def test_self_tuple_found(self):
         model = DummyContext()
@@ -428,7 +428,7 @@ class FindModelTests(unittest.TestCase):
         self._registerTraverser(traverser)
         result = self._callFUT(model, ())
         self.assertEqual(result, model)
-        self.assertEqual(model.environ['PATH_INFO'], '')
+        self.assertEqual(model.request.environ['PATH_INFO'], '')
 
     def test_relative_string_found(self):
         model = DummyContext()
@@ -437,7 +437,7 @@ class FindModelTests(unittest.TestCase):
         self._registerTraverser(traverser)
         result = self._callFUT(model, 'baz')
         self.assertEqual(result, baz)
-        self.assertEqual(model.environ['PATH_INFO'], 'baz')
+        self.assertEqual(model.request.environ['PATH_INFO'], 'baz')
 
     def test_relative_tuple_found(self):
         model = DummyContext()
@@ -446,7 +446,7 @@ class FindModelTests(unittest.TestCase):
         self._registerTraverser(traverser)
         result = self._callFUT(model, ('baz',))
         self.assertEqual(result, baz)
-        self.assertEqual(model.environ['PATH_INFO'], 'baz')
+        self.assertEqual(model.request.environ['PATH_INFO'], 'baz')
 
     def test_relative_string_notfound(self):
         model = DummyContext()
@@ -454,7 +454,7 @@ class FindModelTests(unittest.TestCase):
         traverser = make_traverser({'context':baz, 'view_name':'bar'})
         self._registerTraverser(traverser)
         self.assertRaises(KeyError, self._callFUT, model, 'baz')
-        self.assertEqual(model.environ['PATH_INFO'], 'baz')
+        self.assertEqual(model.request.environ['PATH_INFO'], 'baz')
 
     def test_relative_tuple_notfound(self):
         model = DummyContext()
@@ -462,7 +462,7 @@ class FindModelTests(unittest.TestCase):
         traverser = make_traverser({'context':baz, 'view_name':'bar'})
         self._registerTraverser(traverser)
         self.assertRaises(KeyError, self._callFUT, model, ('baz',))
-        self.assertEqual(model.environ['PATH_INFO'], 'baz')
+        self.assertEqual(model.request.environ['PATH_INFO'], 'baz')
 
     def test_absolute_string_found(self):
         root = DummyContext()
@@ -474,7 +474,7 @@ class FindModelTests(unittest.TestCase):
         result = self._callFUT(model, '/')
         self.assertEqual(result, root)
         self.assertEqual(root.wascontext, True)
-        self.assertEqual(root.environ['PATH_INFO'], '/')
+        self.assertEqual(root.request.environ['PATH_INFO'], '/')
 
     def test_absolute_tuple_found(self):
         root = DummyContext()
@@ -486,7 +486,7 @@ class FindModelTests(unittest.TestCase):
         result = self._callFUT(model, ('',))
         self.assertEqual(result, root)
         self.assertEqual(root.wascontext, True)
-        self.assertEqual(root.environ['PATH_INFO'], '/')
+        self.assertEqual(root.request.environ['PATH_INFO'], '/')
 
     def test_absolute_string_notfound(self):
         root = DummyContext()
@@ -497,7 +497,7 @@ class FindModelTests(unittest.TestCase):
         self._registerTraverser(traverser)
         self.assertRaises(KeyError, self._callFUT, model, '/')
         self.assertEqual(root.wascontext, True)
-        self.assertEqual(root.environ['PATH_INFO'], '/')
+        self.assertEqual(root.request.environ['PATH_INFO'], '/')
 
     def test_absolute_tuple_notfound(self):
         root = DummyContext()
@@ -508,7 +508,7 @@ class FindModelTests(unittest.TestCase):
         self._registerTraverser(traverser)
         self.assertRaises(KeyError, self._callFUT, model, ('',))
         self.assertEqual(root.wascontext, True)
-        self.assertEqual(root.environ['PATH_INFO'], '/')
+        self.assertEqual(root.request.environ['PATH_INFO'], '/')
 
 
 class ModelPathTests(unittest.TestCase):
@@ -662,11 +662,11 @@ class TraversalContextURLTests(unittest.TestCase):
         return TraversalContextURL
 
     def _registerTraverser(self, traverser):
-        import zope.component
-        sm = zope.component.getSiteManager()
+        from repoze.bfg.threadlocal import get_current_registry
+        reg = get_current_registry()
         from repoze.bfg.interfaces import ITraverser
         from zope.interface import Interface
-        sm.registerAdapter(traverser, (Interface,), ITraverser)
+        reg.registerAdapter(traverser, (Interface,), ITraverser)
 
     def test_class_conforms_to_IContextURL(self):
         from zope.interface.verify import verifyClass
@@ -774,7 +774,7 @@ class TraversalContextURLTests(unittest.TestCase):
         self._registerTraverser(traverser)
         context_url = self._makeOne(context, request)
         self.assertEqual(context_url.virtual_root(), traversed_to)
-        self.assertEqual(context.environ['PATH_INFO'], '/one')
+        self.assertEqual(context.request.environ['PATH_INFO'], '/one')
 
     def test_empty_names_not_ignored(self):
         bar = DummyContext()
@@ -849,20 +849,18 @@ class TestVirtualRoot(unittest.TestCase):
         return virtual_root(model, request)
 
     def test_registered(self):
-        from zope.component import getSiteManager
         from repoze.bfg.interfaces import IContextURL
         from zope.interface import Interface
-        sm = getSiteManager()
-        sm.registerAdapter(DummyContextURL, (Interface,Interface),
-                           IContextURL)
+        request = _makeRequest()
+        request.registry.registerAdapter(DummyContextURL, (Interface,Interface),
+                                         IContextURL)
         context = DummyContext()
-        request = DummyRequest()
         result = self._callFUT(context, request)
         self.assertEqual(result, '123')
 
     def test_default(self):
         context = DummyContext()
-        request = DummyRequest()
+        request = _makeRequest()
         request.environ['PATH_INFO'] = '/'
         result = self._callFUT(context, request)
         self.assertEqual(result, context)
@@ -879,18 +877,26 @@ class TraverseTests(unittest.TestCase):
         return traverse(context, name)
 
     def _registerTraverser(self, traverser):
-        import zope.component
-        sm = zope.component.getSiteManager()
+        from repoze.bfg.threadlocal import get_current_registry
+        reg = get_current_registry()
         from repoze.bfg.interfaces import ITraverser
         from zope.interface import Interface
-        sm.registerAdapter(traverser, (Interface,), ITraverser)
+        reg.registerAdapter(traverser, (Interface,), ITraverser)
+
+    def test_request_has_registry(self):
+        from repoze.bfg.threadlocal import get_current_registry
+        model = DummyContext()
+        traverser = make_traverser({'context':model, 'view_name':''})
+        self._registerTraverser(traverser)
+        self._callFUT(model, [''])
+        self.assertEqual(model.request.registry, get_current_registry())
 
     def test_list(self):
         model = DummyContext()
         traverser = make_traverser({'context':model, 'view_name':''})
         self._registerTraverser(traverser)
         self._callFUT(model, [''])
-        self.assertEqual(model.environ['PATH_INFO'], '/')
+        self.assertEqual(model.request.environ['PATH_INFO'], '/')
 
     def test_generator(self):
         model = DummyContext()
@@ -899,21 +905,21 @@ class TraverseTests(unittest.TestCase):
         def foo():
             yield ''
         self._callFUT(model, foo())
-        self.assertEqual(model.environ['PATH_INFO'], '/')
+        self.assertEqual(model.request.environ['PATH_INFO'], '/')
 
     def test_self_string_found(self):
         model = DummyContext()
         traverser = make_traverser({'context':model, 'view_name':''})
         self._registerTraverser(traverser)
         self._callFUT(model, '')
-        self.assertEqual(model.environ['PATH_INFO'], '')
+        self.assertEqual(model.request.environ['PATH_INFO'], '')
 
     def test_self_tuple_found(self):
         model = DummyContext()
         traverser = make_traverser({'context':model, 'view_name':''})
         self._registerTraverser(traverser)
         self._callFUT(model, ())
-        self.assertEqual(model.environ['PATH_INFO'], '')
+        self.assertEqual(model.request.environ['PATH_INFO'], '')
 
     def test_relative_string_found(self):
         model = DummyContext()
@@ -921,7 +927,7 @@ class TraverseTests(unittest.TestCase):
         traverser = make_traverser({'context':baz, 'view_name':''})
         self._registerTraverser(traverser)
         self._callFUT(model, 'baz')
-        self.assertEqual(model.environ['PATH_INFO'], 'baz')
+        self.assertEqual(model.request.environ['PATH_INFO'], 'baz')
 
     def test_relative_tuple_found(self):
         model = DummyContext()
@@ -929,7 +935,7 @@ class TraverseTests(unittest.TestCase):
         traverser = make_traverser({'context':baz, 'view_name':''})
         self._registerTraverser(traverser)
         self._callFUT(model, ('baz',))
-        self.assertEqual(model.environ['PATH_INFO'], 'baz')
+        self.assertEqual(model.request.environ['PATH_INFO'], 'baz')
 
     def test_absolute_string_found(self):
         root = DummyContext()
@@ -940,7 +946,7 @@ class TraverseTests(unittest.TestCase):
         self._registerTraverser(traverser)
         self._callFUT(model, '/')
         self.assertEqual(root.wascontext, True)
-        self.assertEqual(root.environ['PATH_INFO'], '/')
+        self.assertEqual(root.request.environ['PATH_INFO'], '/')
 
     def test_absolute_tuple_found(self):
         root = DummyContext()
@@ -951,7 +957,7 @@ class TraverseTests(unittest.TestCase):
         self._registerTraverser(traverser)
         self._callFUT(model, ('',))
         self.assertEqual(root.wascontext, True)
-        self.assertEqual(root.environ['PATH_INFO'], '/')
+        self.assertEqual(root.request.environ['PATH_INFO'], '/')
 
     def test_empty_sequence(self):
         root = DummyContext()
@@ -962,7 +968,7 @@ class TraverseTests(unittest.TestCase):
         self._registerTraverser(traverser)
         self._callFUT(model, [])
         self.assertEqual(model.wascontext, True)
-        self.assertEqual(model.environ['PATH_INFO'], '')
+        self.assertEqual(model.request.environ['PATH_INFO'], '')
 
     def test_default_traverser(self):
         model = DummyContext()
@@ -999,8 +1005,8 @@ def make_traverser(result):
         def __init__(self, context):
             self.context = context
             context.wascontext = True
-        def __call__(self, environ):
-            self.context.environ = environ
+        def __call__(self, request):
+            self.context.request = request
             return result
     return DummyTraverser
         
@@ -1040,3 +1046,9 @@ class DummyRoute:
         if self.raise_exc:
             raise self.raise_exc
         return self.result
+
+def _makeRequest(environ=None):
+    from repoze.bfg.registry import Registry
+    request = DummyRequest()
+    request.registry = Registry()
+    return request
diff --git a/repoze/bfg/tests/test_url.py b/repoze/bfg/tests/test_url.py
index 6754f6f34..a27fb96fd 100644
--- a/repoze/bfg/tests/test_url.py
+++ b/repoze/bfg/tests/test_url.py
@@ -13,64 +13,62 @@ class ModelURLTests(unittest.TestCase):
         from repoze.bfg.url import model_url
         return model_url(model, request, *elements, **kw)
 
-    def _registerContextURL(self):
+    def _registerContextURL(self, reg):
         from repoze.bfg.interfaces import IContextURL
         from zope.interface import Interface
-        from zope.component import getSiteManager
         class DummyContextURL(object):
             def __init__(self, context, request):
                 pass
             def __call__(self):
                 return 'http://example.com/context/'
-        sm = getSiteManager()
-        sm.registerAdapter(DummyContextURL, (Interface, Interface),
-                           IContextURL)
+        reg.registerAdapter(DummyContextURL, (Interface, Interface),
+                            IContextURL)
 
     def test_root_default(self):
-        self._registerContextURL()
+        request = _makeRequest()
+        self._registerContextURL(request.registry)
         root = DummyContext()
-        request = DummyRequest()
         result = self._callFUT(root, request)
         self.assertEqual(result, 'http://example.com/context/')
 
     def test_extra_args(self):
-        self._registerContextURL()
+        request = _makeRequest()
+        self._registerContextURL(request.registry)
         context = DummyContext()
-        request = DummyRequest()
         result = self._callFUT(context, request, 'this/theotherthing', 'that')
         self.assertEqual(
             result,
             'http://example.com/context/this%2Ftheotherthing/that')
 
     def test_unicode_in_element_names(self):
-        self._registerContextURL()
+        request = _makeRequest()
+        self._registerContextURL(request.registry)
         uc = unicode('La Pe\xc3\xb1a', 'utf-8')
         context = DummyContext()
-        request = DummyRequest()
         result = self._callFUT(context, request, uc)
         self.assertEqual(result,
                      'http://example.com/context/La%20Pe%C3%B1a')
 
     def test_element_names_url_quoted(self):
-        self._registerContextURL()
+        request = _makeRequest()
+        self._registerContextURL(request.registry)
         context = DummyContext()
-        request = DummyRequest()
         result = self._callFUT(context, request, 'a b c')
         self.assertEqual(result, 'http://example.com/context/a%20b%20c')
 
     def test_with_query_dict(self):
-        self._registerContextURL()
+        request = _makeRequest()
+        self._registerContextURL(request.registry)
         context = DummyContext()
-        request = DummyRequest()
         uc = unicode('La Pe\xc3\xb1a', 'utf-8')
         result = self._callFUT(context, request, 'a', query={'a':uc})
         self.assertEqual(result,
                          'http://example.com/context/a?a=La+Pe%C3%B1a')
 
     def test_with_query_seq(self):
-        self._registerContextURL()
+        request = _makeRequest()
+        self._registerContextURL(request.registry)
         context = DummyContext()
-        request = DummyRequest()
         uc = unicode('La Pe\xc3\xb1a', 'utf-8')
         result = self._callFUT(context, request, 'a', query=[('a', 'hi there'),
                                                              ('b', uc)])
@@ -78,43 +76,43 @@ class ModelURLTests(unittest.TestCase):
                      'http://example.com/context/a?a=hi+there&b=La+Pe%C3%B1a')
 
     def test_anchor_is_after_root_when_no_elements(self):
-        self._registerContextURL()
+        request = _makeRequest()
+        self._registerContextURL(request.registry)
         context = DummyContext()
-        request = DummyRequest()
         result = self._callFUT(context, request, anchor='a')
         self.assertEqual(result,
                          'http://example.com/context/#a')
 
     def test_anchor_is_after_elements_when_no_qs(self):
-        self._registerContextURL()
+        request = _makeRequest()
+        self._registerContextURL(request.registry)
         context = DummyContext()
-        request = DummyRequest()
         result = self._callFUT(context, request, 'a', anchor='b')
         self.assertEqual(result,
                          'http://example.com/context/a#b')
 
     def test_anchor_is_after_qs_when_qs_is_present(self):
-        self._registerContextURL()
+        request = _makeRequest()
+        self._registerContextURL(request.registry)
         context = DummyContext()
-        request = DummyRequest()
         result = self._callFUT(context, request, 'a', 
                                 query={'b':'c'}, anchor='d')
         self.assertEqual(result,
                          'http://example.com/context/a?b=c#d')
 
     def test_anchor_is_encoded_utf8_if_unicode(self):
-        self._registerContextURL()
+        request = _makeRequest()
+        self._registerContextURL(request.registry)
         context = DummyContext()
-        request = DummyRequest()
         uc = unicode('La Pe\xc3\xb1a', 'utf-8') 
         result = self._callFUT(context, request, anchor=uc)
         self.assertEqual(result,
                          'http://example.com/context/#La Pe\xc3\xb1a')
 
     def test_anchor_is_not_urlencoded(self):
-        self._registerContextURL()
+        request = _makeRequest()
+        self._registerContextURL(request.registry)
         context = DummyContext()
-        request = DummyRequest()
         result = self._callFUT(context, request, anchor=' /#')
         self.assertEqual(result,
                          'http://example.com/context/# /#')
@@ -124,7 +122,7 @@ class ModelURLTests(unittest.TestCase):
         root = DummyContext()
         root.__name__ = ''
         root.__parent__ = None
-        request = DummyRequest()
+        request = _makeRequest()
         request.environ = {}
         result = self._callFUT(root, request)
         self.assertEqual(result, 'http://example.com:5432/')
@@ -142,11 +140,9 @@ class TestRouteUrl(unittest.TestCase):
 
     def test_with_elements(self):
         from repoze.bfg.interfaces import IRoutesMapper
+        request = _makeRequest()
         mapper = DummyRoutesMapper(result='/1/2/3')
-        from zope.component import getSiteManager
-        sm = getSiteManager()
-        sm.registerUtility(mapper, IRoutesMapper)
-        request = DummyRequest()
+        request.registry.registerUtility(mapper, IRoutesMapper)
         result = self._callFUT('flub', request, 'extra1', 'extra2',
                                a=1, b=2, c=3, _query={'a':1},
                                _anchor=u"foo")
@@ -155,11 +151,9 @@ class TestRouteUrl(unittest.TestCase):
 
     def test_no_elements(self):
         from repoze.bfg.interfaces import IRoutesMapper
+        request = _makeRequest()
         mapper = DummyRoutesMapper(result='/1/2/3')
-        from zope.component import getSiteManager
-        sm = getSiteManager()
-        sm.registerUtility(mapper, IRoutesMapper)
-        request = DummyRequest()
+        request.registry.registerUtility(mapper, IRoutesMapper)
         result = self._callFUT('flub', request, a=1, b=2, c=3, _query={'a':1},
                                _anchor=u"foo")
         self.assertEqual(result,
@@ -167,12 +161,10 @@ class TestRouteUrl(unittest.TestCase):
 
     def test_it_generation_error(self):
         from repoze.bfg.interfaces import IRoutesMapper
+        request = _makeRequest()
         mapper = DummyRoutesMapper(raise_exc=KeyError)
-        from zope.component import getSiteManager
-        sm = getSiteManager()
-        sm.registerUtility(mapper, IRoutesMapper)
+        request.registry.registerUtility(mapper, IRoutesMapper)
         mapper.raise_exc = KeyError
-        request = DummyRequest()
         self.assertRaises(KeyError, self._callFUT, 'flub', request, a=1)
 
 class TestStaticUrl(unittest.TestCase):
@@ -188,45 +180,37 @@ class TestStaticUrl(unittest.TestCase):
 
     def test_notfound(self):
         from repoze.bfg.interfaces import IRoutesMapper
-        from zope.component import getSiteManager
+        request = _makeRequest()
         mapper = DummyRoutesMapper(result='/1/2/3')
-        sm = getSiteManager()
-        sm.registerUtility(mapper, IRoutesMapper)
-        request = DummyRequest()
+        request.registry.registerUtility(mapper, IRoutesMapper)
         self.assertRaises(ValueError, self._callFUT, 'static/foo.css', request)
 
     def test_abspath(self):
         from repoze.bfg.interfaces import IRoutesMapper
-        from zope.component import getSiteManager
+        request = _makeRequest()
         mapper = DummyRoutesMapper(result='/1/2/3')
-        sm = getSiteManager()
-        sm.registerUtility(mapper, IRoutesMapper)
-        request = DummyRequest()
+        request.registry.registerUtility(mapper, IRoutesMapper)
         self.assertRaises(ValueError, self._callFUT, '/static/foo.css', request)
 
     def test_found_rel(self):
         from repoze.bfg.interfaces import IRoutesMapper
         from repoze.bfg.static import StaticRootFactory
-        from zope.component import getSiteManager
+        request = _makeRequest()
         factory = StaticRootFactory('repoze.bfg.tests:fixtures')
         routes = [DummyRoute('name', factory=factory)]
         mapper = DummyRoutesMapper(result='/1/2/3', routes = routes)
-        sm = getSiteManager()
-        sm.registerUtility(mapper, IRoutesMapper)
-        request = DummyRequest()
+        request.registry.registerUtility(mapper, IRoutesMapper)
         url = self._callFUT('fixtures/minimal.pt', request)
         self.assertEqual(url, 'http://example.com:5432/1/2/3')
 
     def test_found_abs(self):
         from repoze.bfg.interfaces import IRoutesMapper
         from repoze.bfg.static import StaticRootFactory
-        from zope.component import getSiteManager
+        request = _makeRequest()
         factory = StaticRootFactory('repoze.bfg.tests:fixtures')
         routes = [DummyRoute('name', factory=factory)]
         mapper = DummyRoutesMapper(result='/1/2/3', routes = routes)
-        sm = getSiteManager()
-        sm.registerUtility(mapper, IRoutesMapper)
-        request = DummyRequest()
+        request.registry.registerUtility(mapper, IRoutesMapper)
         url = self._callFUT('repoze.bfg.tests:fixtures/minimal.pt', request)
         self.assertEqual(url, 'http://example.com:5432/1/2/3')
 
@@ -259,3 +243,11 @@ class DummyRoute:
     def __init__(self, name, factory=None):
         self.name = name
         self.factory = factory
+
+def _makeRequest(environ=None):
+    from repoze.bfg.registry import Registry
+    request = DummyRequest(environ)
+    request.registry = Registry()
+    return request
+
+