- The BFG router now emits an additional event unconditionally at the

  end of request processing:
  ``repoze.bfg.interfaces.IFinishedRequest``.  This event is meant to
  be used when it is necessary to perform unconditional cleanup after
  request processing.  See the ``repoze.bfg.events.FinishedRequest``
  class documentation for more information.

- The ``repoze.bfg.interfaces.IWSGIApplicationCreatedEvent`` event
  interface was renamed to
  ``repoze.bfg.interfaces.IApplicationCreated``.  Likewise, the
  ``repoze.bfg.events.WSGIApplicationCreatedEvent`` class was renamed
  to ``repoze.bfg.events.ApplicationCreated``.  The older aliases will
  continue to work indefinitely.

- The ``repoze.bfg.interfaces.IAfterTraversal`` event interface was
  renamed to ``repoze.bfg.interfaces.IContextFound``.  Likewise, the
  ``repoze.bfg.events.AfterTraveral`` class was renamed to
  ``repoze.bfg.events.ContextFound``.  The older aliases will continue
  to work indefinitely.

3 files changed, 67 insertions, 25 deletions

diff --git a/repoze/bfg/tests/test_configuration.py b/repoze/bfg/tests/test_configuration.py
index 943e6b832..b095c5c4c 100644
--- a/repoze/bfg/tests/test_configuration.py
+++ b/repoze/bfg/tests/test_configuration.py
@@ -563,11 +563,10 @@ class ConfiguratorTests(unittest.TestCase):
         
     def test_make_wsgi_app(self):
         from repoze.bfg.router import Router
-        from repoze.bfg.interfaces import IWSGIApplicationCreatedEvent
+        from repoze.bfg.interfaces import IApplicationCreated
         manager = DummyThreadLocalManager()
         config = self._makeOne()
-        subscriber = self._registerEventListener(config,
-                                                 IWSGIApplicationCreatedEvent)
+        subscriber = self._registerEventListener(config, IApplicationCreated)
         config.manager = manager
         app = config.make_wsgi_app()
         self.assertEqual(app.__class__, Router)
@@ -575,7 +574,7 @@ class ConfiguratorTests(unittest.TestCase):
         self.assertEqual(manager.pushed['request'], None)
         self.failUnless(manager.popped)
         self.assertEqual(len(subscriber), 1)
-        self.failUnless(IWSGIApplicationCreatedEvent.providedBy(subscriber[0]))
+        self.failUnless(IApplicationCreated.providedBy(subscriber[0]))
 
     def test_load_zcml_default(self):
         import repoze.bfg.tests.fixtureapp
diff --git a/repoze/bfg/tests/test_events.py b/repoze/bfg/tests/test_events.py
index c122f4744..d097ca0f4 100644
--- a/repoze/bfg/tests/test_events.py
+++ b/repoze/bfg/tests/test_events.py
@@ -55,45 +55,69 @@ class NewResponseEventTests(unittest.TestCase):
         self.assertEqual(inst.request, request)
         self.assertEqual(inst.response, response)
 
-class WSGIAppEventTests(unittest.TestCase):
-    def test_object_implements(self):
+class ApplicationCreatedEventTests(unittest.TestCase):
+    def test_alias_object_implements(self):
         from repoze.bfg.events import WSGIApplicationCreatedEvent
         event = WSGIApplicationCreatedEvent(object())
         from repoze.bfg.interfaces import IWSGIApplicationCreatedEvent
+        from repoze.bfg.interfaces import IApplicationCreated
         from zope.interface.verify import verifyObject
         verifyObject(IWSGIApplicationCreatedEvent, event)
+        verifyObject(IApplicationCreated, event)
 
-    def test_class_implements(self):
+    def test_alias_class_implements(self):
         from repoze.bfg.events import WSGIApplicationCreatedEvent
         from repoze.bfg.interfaces import IWSGIApplicationCreatedEvent
+        from repoze.bfg.interfaces import IApplicationCreated
         from zope.interface.verify import verifyClass
         verifyClass(IWSGIApplicationCreatedEvent, WSGIApplicationCreatedEvent)
+        verifyClass(IApplicationCreated, WSGIApplicationCreatedEvent)
 
-class AfterTraversalEventTests(unittest.TestCase):
-    def _getTargetClass(self):
-        from repoze.bfg.events import AfterTraversal
-        return AfterTraversal
-
-    def _makeOne(self, request):
-        return self._getTargetClass()(request)
+    def test_object_implements(self):
+        from repoze.bfg.events import ApplicationCreated
+        event = ApplicationCreated(object())
+        from repoze.bfg.interfaces import IApplicationCreated
+        from zope.interface.verify import verifyObject
+        verifyObject(IApplicationCreated, event)
 
     def test_class_implements(self):
-        from repoze.bfg.interfaces import IAfterTraversal
+        from repoze.bfg.events import ApplicationCreated
+        from repoze.bfg.interfaces import IApplicationCreated
         from zope.interface.verify import verifyClass
-        klass = self._getTargetClass()
-        verifyClass(IAfterTraversal, klass)
-        
-    def test_instance_implements(self):
+        verifyClass(IApplicationCreated, ApplicationCreated)
+
+class ContextFoundEventTests(unittest.TestCase):
+    def test_alias_class_implements(self):
+        from zope.interface.verify import verifyClass
+        from repoze.bfg.events import AfterTraversal
         from repoze.bfg.interfaces import IAfterTraversal
+        from repoze.bfg.interfaces import IContextFound
+        verifyClass(IAfterTraversal, AfterTraversal)
+        verifyClass(IContextFound, AfterTraversal)
+        
+    def test_alias_instance_implements(self):
         from zope.interface.verify import verifyObject
+        from repoze.bfg.events import AfterTraversal
+        from repoze.bfg.interfaces import IAfterTraversal
+        from repoze.bfg.interfaces import IContextFound
         request = DummyRequest()
-        inst = self._makeOne(request)
+        inst = AfterTraversal(request)
         verifyObject(IAfterTraversal, inst)
+        verifyObject(IContextFound, inst)
 
-    def test_ctor(self):
+    def test_class_implements(self):
+        from zope.interface.verify import verifyClass
+        from repoze.bfg.events import ContextFound
+        from repoze.bfg.interfaces import IContextFound
+        verifyClass(IContextFound, ContextFound)
+        
+    def test_instance_implements(self):
+        from zope.interface.verify import verifyObject
+        from repoze.bfg.events import ContextFound
+        from repoze.bfg.interfaces import IContextFound
         request = DummyRequest()
-        inst = self._makeOne(request)
-        self.assertEqual(inst.request, request)
+        inst = ContextFound(request)
+        verifyObject(IContextFound, inst)
 
 class TestSubscriber(unittest.TestCase):
     def setUp(self):
diff --git a/repoze/bfg/tests/test_router.py b/repoze/bfg/tests/test_router.py
index c243d739e..fafe88d4a 100644
--- a/repoze/bfg/tests/test_router.py
+++ b/repoze/bfg/tests/test_router.py
@@ -126,6 +126,21 @@ class TestRouter(unittest.TestCase):
         router = self._makeOne()
         self.assertEqual(router.request_factory, DummyRequestFactory)
 
+    def test_call_request_factory_raises_finished_request_catches(self):
+        from repoze.bfg.interfaces import IFinishedRequest
+        finished_events = self._registerEventListener(IFinishedRequest)
+        environ = self._makeEnviron()
+        logger = self._registerLogger()
+        router = self._makeOne()
+        def dummy_request_factory(environ):
+            raise NotImplementedError
+        router.request_factory = dummy_request_factory
+        start_response = DummyStartResponse()
+        exc_raised(NotImplementedError, router, environ, start_response)
+        self.assertEqual(len(logger.messages), 0)
+        self.assertEqual(len(finished_events), 1)
+        self.assertEqual(finished_events[0].request, None)
+
     def test_call_traverser_default(self):
         from repoze.bfg.exceptions import NotFound
         environ = self._makeEnviron()
@@ -399,7 +414,8 @@ class TestRouter(unittest.TestCase):
     def test_call_eventsends(self):
         from repoze.bfg.interfaces import INewRequest
         from repoze.bfg.interfaces import INewResponse
-        from repoze.bfg.interfaces import IAfterTraversal
+        from repoze.bfg.interfaces import IContextFound
+        from repoze.bfg.interfaces import IFinishedRequest
         from repoze.bfg.interfaces import IViewClassifier
         context = DummyContext()
         self._registerTraverserFactory(context)
@@ -409,8 +425,9 @@ class TestRouter(unittest.TestCase):
         environ = self._makeEnviron()
         self._registerView(view, '', IViewClassifier, None, None)
         request_events = self._registerEventListener(INewRequest)
-        aftertraversal_events = self._registerEventListener(IAfterTraversal)
+        aftertraversal_events = self._registerEventListener(IContextFound)
         response_events = self._registerEventListener(INewResponse)
+        finished_events = self._registerEventListener(IFinishedRequest)
         router = self._makeOne()
         start_response = DummyStartResponse()
         result = router(environ, start_response)
@@ -420,6 +437,8 @@ class TestRouter(unittest.TestCase):
         self.assertEqual(aftertraversal_events[0].request.environ, environ)
         self.assertEqual(len(response_events), 1)
         self.assertEqual(response_events[0].response, response)
+        self.assertEqual(len(finished_events), 1)
+        self.assertEqual(finished_events[0].request.environ, environ)
         self.assertEqual(result, response.app_iter)
 
     def test_call_pushes_and_pops_threadlocal_manager(self):