[Repoze-dev] Repoze CVS: __init__.py tests.py

[Chris McDonough]

Update of /home/repoze/cvs/filters/repoze.tm/repoze/tm
In directory laguna.palladion.com:/tmp/cvs-serv18088/filters/repoze.tm/repoze/tm

Modified Files:
	__init__.py tests.py 
Log Message:
Provide a better API for registering callbacks that should be invoked
at transaction end.


Index: tests.py
===================================================================
RCS file: /home/repoze/cvs/filters/repoze.tm/repoze/tm/tests.py,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -d -r1.1.1.1 -r1.2
--- tests.py	10 Sep 2007 22:39:56 -0000	1.1.1.1
+++ tests.py	13 Sep 2007 15:33:26 -0000	1.2
@@ -7,51 +7,102 @@
         from repoze.tm import TM
         return TM
 
-    def _makeOne(self, *arg, **kw):
-        return self._getTargetClass()(*arg, **kw)
+    def _makeOne(self, app, endregistrations=None):
+        from repoze.tm import after_end
+        if endregistrations:
+            after_end.register(*endregistrations)
+        return self._getTargetClass()(app)
 
     def test_committed(self):
         resource = DummyResource()
         app = DummyApplication(resource)
         tm = self._makeOne(app)
-        cleanup = {1:1}
-        result = tm({'tm.cleanup':cleanup}, None)
+        result = tm({}, None)
         self.assertEqual(result, ['hello'])
         self.assertEqual(resource.committed, True)
         self.assertEqual(resource.aborted, False)
-        self.assertEqual(cleanup, {})
 
     def test_aborted_via_doom(self):
         resource = DummyResource()
         app = DummyApplication(resource, doom=True)
         tm = self._makeOne(app)
-        cleanup = {1:1}
-        result = tm({'tm.cleanup':cleanup}, None)
+        result = tm({}, None)
         self.assertEqual(result, ['hello'])
         self.assertEqual(transaction.isDoomed(), False)
         self.assertEqual(resource.committed, False)
         self.assertEqual(resource.aborted, True)
-        self.assertEqual(cleanup, {})
 
     def test_aborted_via_exception(self):
         resource = DummyResource()
         app = DummyApplication(resource, exception=True)
         tm = self._makeOne(app)
-        cleanup = {1:1}
-        self.assertRaises(ValueError, tm, {'tm.cleanup':cleanup}, None)
+        self.assertRaises(ValueError, tm, {}, None)
         self.assertEqual(resource.committed, False)
         self.assertEqual(resource.aborted, True)
-        self.assertEqual(cleanup, {})
         
     def test_aborted_via_exception_and_doom(self):
         resource = DummyResource()
         app = DummyApplication(resource, exception=True, doom=True)
         tm = self._makeOne(app)
-        cleanup = {1:1}
-        self.assertRaises(ValueError, tm, {'tm.cleanup':cleanup}, None)
+        self.assertRaises(ValueError, tm, {}, None)
         self.assertEqual(resource.committed, False)
         self.assertEqual(resource.aborted, True)
-        self.assertEqual(cleanup, {})
+
+    def test_cleanup_on_commit(self):
+        dummycalled = []
+        def dummy():
+            dummycalled.append(True)
+        env = {}
+        resource = DummyResource()
+        app = DummyApplication(resource, exception=False, doom=False)
+        tm = self._makeOne(app, (dummy, env))
+        tm(env, None)
+        self.assertEqual(resource.committed, True)
+        self.assertEqual(resource.aborted, False)
+        self.assertEqual(dummycalled, [True])
+        
+    def test_cleanup_on_abort(self):
+        dummycalled = []
+        def dummy():
+            dummycalled.append(True)
+        env = {}
+        resource = DummyResource()
+        app = DummyApplication(resource, exception=True, doom=False)
+        tm = self._makeOne(app, (dummy, env))
+        self.assertRaises(ValueError, tm, env, None)
+        self.assertEqual(resource.committed, False)
+        self.assertEqual(resource.aborted, True)
+        self.assertEqual(dummycalled, [True])
+
+class TestAfterEnd(unittest.TestCase):
+    def _getTargetClass(self):
+        from repoze.tm import AfterEnd
+        return AfterEnd
+
+    def _makeOne(self):
+        return self._getTargetClass()()
+
+    def test_register(self):
+        registry = self._makeOne()
+        func = lambda *x: None
+        environ = {}
+        registry.register(func, environ)
+        self.assertEqual(environ[registry.key], [func])
+
+    def test_unregister_exists(self):
+        registry = self._makeOne()
+        func = lambda *x: None
+        environ = {}
+        registry.register(func, environ)
+        registry.unregister(func, environ)
+        self.assertEqual(environ[registry.key], [])
+        
+    def test_unregister_notexists(self):
+        registry = self._makeOne()
+        func = lambda *x: None
+        environ = {registry.key:[None]}
+        registry.unregister(func, environ)
+        self.assertEqual(environ[registry.key], [None])
 
 class DummyApplication:
     def __init__(self, resource, doom=False, exception=False):

Index: __init__.py
===================================================================
RCS file: /home/repoze/cvs/filters/repoze.tm/repoze/tm/__init__.py,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -d -r1.1.1.1 -r1.2
--- __init__.py	10 Sep 2007 22:39:56 -0000	1.1.1.1
+++ __init__.py	13 Sep 2007 15:33:26 -0000	1.2
@@ -21,16 +21,36 @@
 
     def commit(self, environ):
         transaction.commit()
-        self.cleanup(environ)
+        after_end.cleanup(environ)
 
     def abort(self, environ):
         transaction.abort()
-        self.cleanup(environ)
+        after_end.cleanup(environ)
+
+# Callback registry API helper class
+class AfterEnd:
+    key = 'repoze.tm.afterend'
+    def register(self, func, environ):
+        cleanup = environ.setdefault(self.key, [])
+        cleanup.append(func)
+
+    def unregister(self, func, environ):
+        cleanup = environ.get(self.key, [])
+        new = []
+        for f in cleanup:
+            if f is func:
+                continue
+            new.append(f)
+        environ[self.key] = new
 
     def cleanup(self, environ):
-        cleanup = environ.get('tm.cleanup', None)
-        if cleanup is not None:
-            cleanup.clear()
+        for func in environ.setdefault(self.key, []):
+            func()
+        del environ[self.key]
 
+# singleton, importable by other modules
+after_end = AfterEnd()
+    
 def make_tm(app, global_conf):
     return TM(app)
+

_______________________________________________
Repoze-dev mailing list
Repoze-dev at lists.repoze.org
http://lists.repoze.org/mailman/listinfo/repoze-dev