Coverage for Transaction.{__init__,isDoomed,doom}.

Note that we now raise ValueError from doom() if not in a doomable state,
rather than asserting.

CHANGES.txt

@@ -4,6 +4,9 @@ Changes
 1.3.1 (unreleased)
 ------------------
 
+- Raise ValueError from ``Transaction.doom`` if the transaction is in a
+  non-doomable state (rather than using ``assert``).
+
 - Raise ValueError from ``TransactionManager.attempts`` if passed a
   non-positive value (rather than using ``assert``).
 

docs/doom.rst

@@ -144,7 +144,7 @@ after it's been committed is probably a programming error:
     >>> txn.doom()
     Traceback (most recent call last):
         ...
-    AssertionError
+    ValueError: non-doomable
 
 A doomed transaction should act the same as an active transaction, so we should
 be able to join it:

transaction/_transaction.py

@@ -31,13 +31,13 @@ from transaction._compat import StringIO
 _marker = object()
 
 _TB_BUFFER = None #unittests may hook
-def _makeTracebackBuffer():
+def _makeTracebackBuffer(): #pragma NO COVER
     if _TB_BUFFER is not None:
         return _TB_BUFFER
     return StringIO()
 
 _LOGGER = None #unittests may hook
-def _makeLogger():
+def _makeLogger(): #pragma NO COVER
     if _LOGGER is not None:
         return _LOGGER
     return logging.getLogger("txn.%d" % get_thread_ident())
@@ -130,7 +130,7 @@ class Transaction(object):
             if self.status is not Status.ACTIVE:
                 # should not doom transactions in the middle,
                 # or after, a commit
-                raise AssertionError()
+                raise ValueError('non-doomable')
             self.status = Status.DOOMED
 
     # Raise TransactionFailedError, due to commit()/join()/register()

transaction/tests/test__transaction.py

@@ -48,6 +48,62 @@ class TransactionTests(unittest.TestCase):
     def _makeOne(self, synchronizers=None, manager=None):
         return self._getTargetClass()(synchronizers, manager)
 
+    def test_ctor_defaults(self):
+        from transaction.weakset import WeakSet
+        from transaction.tests.common import Monkey
+        from transaction import _transaction
+        logger = DummyLogger()
+        with Monkey(_transaction, _LOGGER=logger):
+            t = self._makeOne()
+        self.assertTrue(isinstance(t._synchronizers, WeakSet))
+        self.assertEqual(len(t._synchronizers), 0)
+        self.assertTrue(t._manager is None)
+        self.assertEqual(t._resources, [])
+        self.assertEqual(t._adapters, {})
+        self.assertEqual(t._voted, {})
+        self.assertEqual(t._extension, {})
+        self.assertTrue(t.log is logger)
+        self.assertEqual(len(logger._log), 1)
+        self.assertEqual(logger._log[0][0], 'DEBUG')
+        self.assertEqual(logger._log[0][1], 'new transaction')
+        self.assertTrue(t._failure_traceback is None)
+        self.assertEqual(t._before_commit, [])
+        self.assertEqual(t._after_commit, [])
+
+    def test_ctor_w_syncs(self):
+        from transaction.weakset import WeakSet
+        synchs = WeakSet()
+        t = self._makeOne(synchronizers=synchs)
+        self.assertTrue(t._synchronizers is synchs)
+
+    def test_isDoomed(self):
+        from transaction._transaction import Status
+        t = self._makeOne()
+        self.assertFalse(t.isDoomed())
+        t.status = Status.DOOMED
+        self.assertTrue(t.isDoomed())
+
+    def test_doom_active(self):
+        from transaction._transaction import Status
+        t = self._makeOne()
+        t.doom()
+        self.assertTrue(t.isDoomed())
+        self.assertEqual(t.status, Status.DOOMED)
+
+    def test_doom_invalid(self):
+        from transaction._transaction import Status
+        t = self._makeOne()
+        for status in Status.COMMITTING, Status.COMMITTED, Status.COMMITFAILED:
+            t.status = status
+            self.assertRaises(ValueError, t.doom)
+
+    def test_doom_already_doomed(self):
+        from transaction._transaction import Status
+        t = self._makeOne()
+        t.status = Status.DOOMED
+        self.assertTrue(t.isDoomed())
+        self.assertEqual(t.status, Status.DOOMED)
+
     def test_note(self):
         t = self._makeOne()
         try:
@@ -149,6 +205,19 @@ class MiscellaneousTests(unittest.TestCase):
         self.assertEqual(list(dm.keys()), ['a'])
 
 
+class DummyLogger(object):
+    def __init__(self):
+        self._log = []
+    def log(self, level, msg, *args, **kw):
+        if args:
+            self._log.append((level, msg % args))
+        elif kw:
+            self._log.append((level, msg % kw))
+        else:
+            self._log.append((level, msg))
+    def debug(self, msg, *args, **kw):
+        self.log('DEBUG', msg, *args, **kw)
+
 def test_suite():
     return unittest.TestSuite((
         unittest.makeSuite(TransactionTests),