One test module per main module.

transaction/tests/test__manager.py

@@ -189,6 +189,26 @@ class TransactionManagerTests(unittest.TestCase):
         self.assertFalse(txn._committed)
         self.assertTrue(txn._aborted)
 
+    def test_savepoint_default(self):
+        class _Test(object):
+            _sp = None
+            def savepoint(self, optimistic):
+                self._sp = optimistic
+        tm = self._makeOne()
+        tm._txn = txn = _Test()
+        tm.savepoint()
+        self.assertFalse(txn._sp)
+
+    def test_savepoint_explicit(self):
+        class _Test(object):
+            _sp = None
+            def savepoint(self, optimistic):
+                self._sp = optimistic
+        tm = self._makeOne()
+        tm._txn = txn = _Test()
+        tm.savepoint(True)
+        self.assertTrue(txn._sp)
+
     # basic tests with two sub trans jars
     # really we only need one, so tests for
     # sub1 should identical to tests for sub2
@@ -334,6 +354,93 @@ class TransactionManagerTests(unittest.TestCase):
         assert nosub1._p_jar.ctpc_abort == 1
 
 
+class AttemptTests(unittest.TestCase):
+
+    def _makeOne(self, manager):
+        from transaction._manager import Attempt
+        return Attempt(manager)
+
+    def test___enter__(self):
+        manager = DummyManager()
+        inst = self._makeOne(manager)
+        inst.__enter__()
+        self.assertTrue(manager.entered)
+
+    def test___exit__no_exc_no_commit_exception(self):
+        manager = DummyManager()
+        inst = self._makeOne(manager)
+        result = inst.__exit__(None, None, None)
+        self.assertFalse(result)
+        self.assertTrue(manager.committed)
+
+    def test___exit__no_exc_nonretryable_commit_exception(self):
+        manager = DummyManager(raise_on_commit=ValueError)
+        inst = self._makeOne(manager)
+        self.assertRaises(ValueError, inst.__exit__, None, None, None)
+        self.assertTrue(manager.committed)
+        self.assertTrue(manager.aborted)
+
+    def test___exit__no_exc_abort_exception_after_nonretryable_commit_exc(self):
+        manager = DummyManager(raise_on_abort=ValueError, 
+                               raise_on_commit=KeyError)
+        inst = self._makeOne(manager)
+        self.assertRaises(ValueError, inst.__exit__, None, None, None)
+        self.assertTrue(manager.committed)
+        self.assertTrue(manager.aborted)
+        
+    def test___exit__no_exc_retryable_commit_exception(self):
+        from transaction.interfaces import TransientError
+        manager = DummyManager(raise_on_commit=TransientError)
+        inst = self._makeOne(manager)
+        result = inst.__exit__(None, None, None)
+        self.assertTrue(result)
+        self.assertTrue(manager.committed)
+        self.assertTrue(manager.aborted)
+
+    def test___exit__with_exception_value_retryable(self):
+        from transaction.interfaces import TransientError
+        manager = DummyManager()
+        inst = self._makeOne(manager)
+        result = inst.__exit__(TransientError, TransientError(), None)
+        self.assertTrue(result)
+        self.assertFalse(manager.committed)
+        self.assertTrue(manager.aborted)
+
+    def test___exit__with_exception_value_nonretryable(self):
+        manager = DummyManager()
+        inst = self._makeOne(manager)
+        self.assertRaises(KeyError, inst.__exit__, KeyError, KeyError(), None)
+        self.assertFalse(manager.committed)
+        self.assertTrue(manager.aborted)
+        
+
+class DummyManager(object):
+    entered = False
+    committed = False
+    aborted = False
+    
+    def __init__(self, raise_on_commit=None, raise_on_abort=None):
+        self.raise_on_commit = raise_on_commit
+        self.raise_on_abort = raise_on_abort
+
+    def _retryable(self, t, v):
+        from transaction._manager import TransientError
+        return issubclass(t, TransientError)
+        
+    def __enter__(self):
+        self.entered = True
+
+    def abort(self):
+        self.aborted = True
+        if self.raise_on_abort:
+            raise self.raise_on_abort
+        
+    def commit(self):
+        self.committed = True
+        if self.raise_on_commit:
+            raise self.raise_on_commit
+
+
 class DataObject:
 
     def __init__(self, transaction_manager, nost=0):
@@ -436,4 +543,5 @@ def positive_id(obj):
 def test_suite():
     return unittest.TestSuite((
         unittest.makeSuite(TransactionManagerTests),
+        unittest.makeSuite(AttemptTests),
     ))

transaction/tests/test_attempt.py

-##############################################################################
-#
-# Copyright (c) 2012 Zope Foundation and Contributors.
-# All Rights Reserved.
-#
-# This software is subject to the provisions of the Zope Public License,
-# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
-# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
-# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
-# FOR A PARTICULAR PURPOSE
-#
-##############################################################################
-import unittest
-
-
-class TestAttempt(unittest.TestCase):
-
-    def _makeOne(self, manager):
-        from transaction._manager import Attempt
-        return Attempt(manager)
-
-    def test___enter__(self):
-        manager = DummyManager()
-        inst = self._makeOne(manager)
-        inst.__enter__()
-        self.assertTrue(manager.entered)
-
-    def test___exit__no_exc_no_commit_exception(self):
-        manager = DummyManager()
-        inst = self._makeOne(manager)
-        result = inst.__exit__(None, None, None)
-        self.assertFalse(result)
-        self.assertTrue(manager.committed)
-
-    def test___exit__no_exc_nonretryable_commit_exception(self):
-        manager = DummyManager(raise_on_commit=ValueError)
-        inst = self._makeOne(manager)
-        self.assertRaises(ValueError, inst.__exit__, None, None, None)
-        self.assertTrue(manager.committed)
-        self.assertTrue(manager.aborted)
-
-    def test___exit__no_exc_abort_exception_after_nonretryable_commit_exc(self):
-        manager = DummyManager(raise_on_abort=ValueError, 
-                               raise_on_commit=KeyError)
-        inst = self._makeOne(manager)
-        self.assertRaises(ValueError, inst.__exit__, None, None, None)
-        self.assertTrue(manager.committed)
-        self.assertTrue(manager.aborted)
-        
-    def test___exit__no_exc_retryable_commit_exception(self):
-        from transaction.interfaces import TransientError
-        manager = DummyManager(raise_on_commit=TransientError)
-        inst = self._makeOne(manager)
-        result = inst.__exit__(None, None, None)
-        self.assertTrue(result)
-        self.assertTrue(manager.committed)
-        self.assertTrue(manager.aborted)
-
-    def test___exit__with_exception_value_retryable(self):
-        from transaction.interfaces import TransientError
-        manager = DummyManager()
-        inst = self._makeOne(manager)
-        result = inst.__exit__(TransientError, TransientError(), None)
-        self.assertTrue(result)
-        self.assertFalse(manager.committed)
-        self.assertTrue(manager.aborted)
-
-    def test___exit__with_exception_value_nonretryable(self):
-        manager = DummyManager()
-        inst = self._makeOne(manager)
-        self.assertRaises(KeyError, inst.__exit__, KeyError, KeyError(), None)
-        self.assertFalse(manager.committed)
-        self.assertTrue(manager.aborted)
-        
-class DummyManager(object):
-    entered = False
-    committed = False
-    aborted = False
-    
-    def __init__(self, raise_on_commit=None, raise_on_abort=None):
-        self.raise_on_commit = raise_on_commit
-        self.raise_on_abort = raise_on_abort
-
-    def _retryable(self, t, v):
-        from transaction._manager import TransientError
-        return issubclass(t, TransientError)
-        
-    def __enter__(self):
-        self.entered = True
-
-    def abort(self):
-        self.aborted = True
-        if self.raise_on_abort:
-            raise self.raise_on_abort
-        
-    def commit(self):
-        self.committed = True
-        if self.raise_on_commit:
-            raise self.raise_on_commit