- 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.

1 files changed, 48 insertions, 56 deletions

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
+
+