Improved the Gaphor transaction unit tests.

gaphor/tests/test_transaction.py

@@ -1,6 +1,9 @@
+"""Unit tests for transactions in Gaphor."""
 
 from unittest import TestCase 
+
 from zope.component.globalregistry import base
+
 from gaphor.application import Application
 from gaphor.transaction import Transaction, transactional, TransactionError
 from gaphor.event import TransactionBegin, TransactionCommit, TransactionRollback
@@ -9,126 +12,152 @@
 commits = []
 rollbacks = []
 
-def handle_begins(ev):
-    begins.append(ev)
+def handle_begins(event):
+    """Store TransactionBegin events in begins."""
+    begins.append(event)
 
-def handle_commits(ev):
-    commits.append(ev)
-
-def handle_rollback(ev):
-    rollbacks.append(ev)
+def handle_commits(event):
+    """Store TransactionCommit events in commits."""
+    commits.append(event)
 
+def handle_rollback(event):
+    """Store TransactionRollback events in rollbacks."""
+    rollbacks.append(event)
 
 class TransactionTestCase(TestCase):
+    """Test case for transactions with the component registry 
+    enabled."""
 
     def setUp(self):
+        """Initialize Gaphor services and register transaction event
+        handlers."""
+
         Application.init(services=['component_registry'])
+
         component_registry = Application.get_service('component_registry')
+
         component_registry.register_handler(handle_begins, [TransactionBegin])
         component_registry.register_handler(handle_commits, [TransactionCommit])
         component_registry.register_handler(handle_rollback, [TransactionRollback])
+
         del begins[:]
         del commits[:]
         del rollbacks[:]
-        assert not begins
-        assert not commits
-        assert not rollbacks
-
-
+
     def tearDown(self):
+        """Finished with the test case.  Unregister event handlers that
+        store transaction events."""
+
         component_registry = Application.get_service('component_registry')
+
         component_registry.unregister_handler(handle_begins, [TransactionBegin])
         component_registry.unregister_handler(handle_commits, [TransactionCommit])
         component_registry.unregister_handler(handle_rollback, [TransactionRollback])
 
 
     def test_transaction_commit(self):
+        """Test committing a transaction."""
+
         tx = Transaction()
-        self.assertTrue(tx._stack)
-        self.assertEquals(1, len(begins))
-        self.assertEquals(0, len(commits))
-        self.assertEquals(0, len(rollbacks))
+
+        self.assertTrue(tx._stack, 'Transaction has no stack')
+        self.assertEquals(1, len(begins), 'Incorrect number of TrasactionBegin events')
+        self.assertEquals(0, len(commits), 'Incorrect number of TransactionCommit events')
+        self.assertEquals(0, len(rollbacks), 'Incorrect number of TransactionRollback events')
 
         tx.commit()
-        self.assertEquals(1, len(begins))
-        self.assertEquals(1, len(commits))
-        self.assertEquals(0, len(rollbacks))
-
-        self.assertFalse(tx._stack)
+
+        self.assertEquals(1, len(begins), 'Incorrect number of TrasactionBegin events')
+        self.assertEquals(1, len(commits), 'Incorrect number of TransactionCommit events')
+        self.assertEquals(0, len(rollbacks), 'Incorrect number of TransactionRollback events')
+        self.assertFalse(tx._stack, 'Transaction stack is not empty')
 
         try:
             tx.commit()
         except TransactionError:
-            pass # ok
+            pass
         else:
-            assert False, 'should not be reached'
+            self.fail('Commit should not have succeeded')
 
 
     def test_transaction_rollback(self):
+        """Test rolling back a transaction."""
+
         tx = Transaction()
-        self.assertTrue(tx._stack)
-        self.assertEquals(1, len(begins))
-        self.assertEquals(0, len(commits))
-        self.assertEquals(0, len(rollbacks))
+
+        self.assertTrue(tx._stack, 'Transaction has no stack')
+        self.assertEquals(1, len(begins), 'Incorrect number of TrasactionBegin events')
+        self.assertEquals(0, len(commits), 'Incorrect number of TransactionCommit events')
+        self.assertEquals(0, len(rollbacks), 'Incorrect number of TransactionRollback events')
 
         tx.rollback()
-        self.assertEquals(1, len(begins))
-        self.assertEquals(0, len(commits))
-        self.assertEquals(1, len(rollbacks))
+
+        self.assertEquals(1, len(begins), 'Incorrect number of TrasactionBegin events')
+        self.assertEquals(0, len(commits), 'Incorrect number of TransactionCommit events')
+        self.assertEquals(1, len(rollbacks), 'Incorrect number of TransactionRollback events')
 
-        self.assertFalse(tx._stack)
+        self.assertFalse(tx._stack, 'Transaction stack is not empty')
 
 
     def test_transaction_commit_after_rollback(self):
-        tx = Transaction()
+        """Test committing one transaction after rolling back another
+        transaction."""
+
+        tx1 = Transaction()
         tx2 = Transaction()
 
         tx2.rollback()
-
-        tx.commit()
-        self.assertEquals(1, len(begins))
-        self.assertEquals(0, len(commits))
-        self.assertEquals(1, len(rollbacks))
+        tx1.commit()
+
+        self.assertEquals(1, len(begins), 'Incorrect number of TrasactionBegin events')
+        self.assertEquals(0, len(commits), 'Incorrect number of TransactionCommit events')
+        self.assertEquals(1, len(rollbacks), 'Incorrect number of TransactionRollback events')
 
 
     def test_transaction_stack(self):
-        tx = Transaction()
+        """Test the transaction stack."""
+
+        tx1 = Transaction()
         tx2 = Transaction()
 
         try:
-            tx.commit()
+            tx1.commit()
         except TransactionError, e:
-            self.assertEquals('Transaction on stack is not the transaction being closed.', str(e))
+            pass
         else:
-            assert False, 'should not be reached'
+            self.fail('Commit should not have succeeded')
 
 
     def test_transaction_context(self):
+        """Test the transaction context manager."""
+
         with Transaction() as tx:
-            self.assertTrue(isinstance(tx, Transaction))
-            self.assertTrue(Transaction._stack)
-        self.assertFalse(Transaction._stack)
+
+            self.assertTrue(isinstance(tx, Transaction), 'Context is not a Transaction instance')
+            self.assertTrue(Transaction._stack, 'Transaction instance has no stack inside a context')
+
+        self.assertFalse(Transaction._stack, 'Transaction stack should be empty')
 
 
     def test_transaction_context_error(self):
+        """Test the transaction context manager with errors."""
+
         try:
             with Transaction():
-                self.assertTrue(Transaction._stack)
-                raise TypeError('some error')
+                raise TypeError('transaction error')
         except TypeError, e:
-            self.assertEquals('some error', str(e))
-            self.assertFalse(Transaction._stack)
+            self.assertEquals('transaction error', str(e), 'Transaction context manager did no raise correct exception')
         else:
-            self.assertFalse(Transaction._stack)
-            assert False, 'should not be reached'
-
+            self.fail('Transaction context manager did not raise exception when it should have')
+
 class TransactionWithoutComponentRegistryTestCase(TestCase):
+    """Test case for transactions with no component registry."""
 
     def test_transaction(self):
+        """Test basic transaction functionality."""
+
         tx = Transaction()
         tx.rollback()
 
         tx = Transaction()
         tx.commit()
-
-# vim:sw=4:et:ai