Features

--------

- In previous versions of BFG, the "root factory" (the ``get_root``
  callable passed to ``make_app`` or a function pointed to by the
  ``factory`` attribute of a route) was called with a "bare" WSGI
  environment.  In this version, and going forward, it will be called
  with a ``request`` object.  The request object passed to the factory
  implements dictionary-like methods in such a way that existing root
  factory code which expects to be passed an environ will continue to
  work.

Internal
--------

- The request implements dictionary-like methods that mutate and query
  the WSGI environ.  This is only for the purpose of backwards
  compatibility with root factories which expect an ``environ`` rather
  than a request.

- The ``repoze.bfg.request.create_route_request_factory`` function,
  which returned a request factory was removed in favor of a
  ``repoze.bfg.request.route_request_interface`` function, which
  returns an interface.

- The ``repoze.bfg.request.Request`` class, which is a subclass of
  ``webob.Request`` now defines its own ``__setattr__``,
  ``__getattr__`` and ``__delattr__`` methods, which override the
  default WebOb behavior.  The default WebOb behavior stores
  attributes of the request in ``self.environ['webob.adhoc_attrs']``,
  and retrieves them from that dictionary during a ``__getattr__``.
  This behavior was undesirable for speed and "expectation" reasons.
  Now attributes of the ``request`` are stored in ``request.__dict__``
  (as you otherwise might expect from an object that did not override
  these methods).

- Reverse the order in which the router calls the request factory and
  the root factory.  The request factory is now called first; the
  resulting request is passed to the root factory.

- The ``repoze.bfg.request.request_factory`` function has been
  removed.  Its functionality is no longer required.

- The "routes root factory" that wraps the default root factory when
  there are routes mentioned in the configuration now attaches an
  interface to the request via ``zope.interface.directlyProvides``.
  This replaces logic in the (now-gone)
  ``repoze.bfg.request.request_factory`` function.

- The ``route`` and ``view`` ZCML directives now register an interface
  as a named utility (retrieved from
  ``repoze.bfg.request.route_request_interface``) rather than a
  request factory (the previous return value of the now-missing 
  ``repoze.bfg.request.create_route_request_factory``.

1 files changed, 109 insertions, 59 deletions

diff --git a/repoze/bfg/tests/test_request.py b/repoze/bfg/tests/test_request.py
index 8c868fcf5..2ecb060cc 100644
--- a/repoze/bfg/tests/test_request.py
+++ b/repoze/bfg/tests/test_request.py
@@ -1,5 +1,4 @@
 import unittest
-from repoze.bfg.testing import cleanUp
 
 class TestMakeRequestASCII(unittest.TestCase):
     def _callFUT(self, event):
@@ -12,10 +11,14 @@ class TestMakeRequestASCII(unittest.TestCase):
         self._callFUT(event)
         self.assertEqual(request.charset, None)
 
-class RequestTestBase(object):
+class TestRequest(unittest.TestCase):
     def _makeOne(self, environ):
-        request = self._getTargetClass()(environ)
-        return request
+        return self._getTargetClass()(environ)
+
+    def _getTargetClass(self):
+        from repoze.bfg.request import Request
+        return Request
+        
 
     def test_params_decoded_from_utf_8_by_default(self):
         environ = {
@@ -44,64 +47,114 @@ class RequestTestBase(object):
         inst = self._makeOne({})
         self.assertTrue(IRequest.providedBy(inst))
 
-class TestRequest(unittest.TestCase, RequestTestBase):
-        def _getTargetClass(self):
-            from repoze.bfg.request import Request
-            return Request
-    
-class TestRouteRequest(unittest.TestCase, RequestTestBase):
-        def _getTargetClass(self):
-            from repoze.bfg.request import create_route_request_factory
-            return create_route_request_factory('abc')
-
-class TestRequestFactory(unittest.TestCase):
-    def setUp(self):
-        cleanUp()
-
-    def tearDown(self):
-        cleanUp()
+    def test___contains__(self):
+        environ ={'zooma':1}
+        inst = self._makeOne(environ)
+        self.failUnless('zooma' in inst)
+
+    def test___delitem__(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        del inst['zooma']
+        self.failIf('zooma' in environ)
+
+    def test___getitem__(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(inst['zooma'], 1)
+
+    def test___iter__(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        iterator = iter(inst)
+        self.assertEqual(list(iterator), list(iter(environ)))
+
+    def test___setitem__(self):
+        environ = {}
+        inst = self._makeOne(environ)
+        inst['zooma'] = 1
+        self.assertEqual(environ, {'zooma':1})
+
+    def test_get(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(inst.get('zooma'), 1)
         
-    def _callFUT(self, environ):
-        from repoze.bfg.request import request_factory
-        return request_factory(environ)
-
-    def test_it_no_route(self):
-        from repoze.bfg.interfaces import IRequest
-        from repoze.bfg.request import Request
-        result = self._callFUT({})
-        self.assertEqual(result.__class__, Request)
-        self.failUnless(IRequest.providedBy(result))
-
-    def test_it_with_route_found(self):
-        from zope.component import getSiteManager
-        from repoze.bfg.interfaces import IRouteRequest
-        sm = getSiteManager()
-        sm.registerUtility(DummyRequest, IRouteRequest, 'routename')
-        route = DummyRoute('routename')
-        result = self._callFUT({'bfg.routes.route':route,
-                                'bfg.routes.matchdict':{'match':'1'}})
-        self.assertEqual(result.__class__, DummyRequest)
-        self.assertEqual(result.matchdict, {'match':'1'})
-
-    def test_it_with_route_notfound(self):
-        from repoze.bfg.request import Request
-        route = DummyRoute('routename')
-        result = self._callFUT({'bfg.routes.route':route,
-                                'bfg.routes.matchdict':{'match':'1'}})
-        self.assertEqual(result.__class__, Request)
-        self.failIf(getattr(result, 'matchdict', None) is not None)
-
-class Test_create_route_request_factory(unittest.TestCase):
+    def test_has_key(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(inst.has_key('zooma'), True)
+
+    def test_items(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(inst.items(), environ.items())
+
+    def test_iteritems(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(list(inst.iteritems()), list(environ.iteritems()))
+
+    def test_iterkeys(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(list(inst.iterkeys()), list(environ.iterkeys()))
+
+    def test_itervalues(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(list(inst.itervalues()), list(environ.itervalues()))
+
+    def test_keys(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        self.assertEqual(inst.keys(), environ.keys())
+
+    def test_pop(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        popped = inst.pop('zooma')
+        self.assertEqual(environ, {})
+        self.assertEqual(popped, 1)
+
+    def test_popitem(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        popped = inst.popitem()
+        self.assertEqual(environ, {})
+        self.assertEqual(popped, ('zooma', 1))
+
+    def test_setdefault(self):
+        environ = {}
+        inst = self._makeOne(environ)
+        marker = []
+        result = inst.setdefault('a', marker)
+        self.assertEqual(environ, {'a':marker})
+        self.assertEqual(result, marker)
+
+    def test_update(self):
+        environ = {}
+        inst = self._makeOne(environ)
+        inst.update({'a':1}, b=2)
+        self.assertEqual(environ, {'a':1, 'b':2})
+
+    def test_values(self):
+        environ = {'zooma':1}
+        inst = self._makeOne(environ)
+        result = inst.values()
+        self.assertEqual(result, environ.values())
+
+class Test_route_request_iface(unittest.TestCase):
     def _callFUT(self, name):
-        from repoze.bfg.request import create_route_request_factory
-        return create_route_request_factory(name)
+        from repoze.bfg.request import route_request_iface
+        return route_request_iface(name)
 
     def test_it(self):
         from repoze.bfg.interfaces import IRouteRequest
         from repoze.bfg.interfaces import IRequest
-        factory = self._callFUT('routename')
-        self.failUnless(IRouteRequest.implementedBy(factory))
-        self.failUnless(IRequest.implementedBy(factory))
+        iface = self._callFUT('routename')
+        self.failUnless(iface.extends(IRouteRequest))
+        self.failUnless(iface.extends(IRequest))
 
 class Test_add_global_response_headers(unittest.TestCase):
     def _callFUT(self, request, headerlist):
@@ -115,9 +168,6 @@ class Test_add_global_response_headers(unittest.TestCase):
         self._callFUT(request, [('c', 1)])
         self.assertEqual(request.global_response_headers, headers + [('c', 1)])
 
-class DummyRoute:
-    def __init__(self, name):
-        self.name = name
 class DummyRequest:
     def __init__(self, environ=None):
         if environ is None: