no commit_on_exit

Author: timgraham

django_mongodb_backend/base.py

@@ -36,17 +36,6 @@ def __exit__(self, exception_type, exception_value, exception_traceback):
         pass
 
 
-def requires_transaction_support(func):
-    """Make a method a no-op if transactions aren't supported."""
-
-    def wrapper(self, *args, **kwargs):
-        if not self.features._supports_transactions:
-            return
-        func(self, *args, **kwargs)
-
-    return wrapper
-
-
 logger = logging.getLogger("django.db.backends.base")
 
 
@@ -171,9 +160,6 @@ def __init__(self, settings_dict, alias=DEFAULT_DB_ALIAS):
         self.nested_atomics = 0
         # Stack of active 'atomic' blocks.
         self.atomic_blocks_mongo = []
-        # Tracks if the outermost 'atomic' block should commit on exit,
-        # ie. if autocommit was active on entry.
-        self.commit_on_exit_mongo = True
         # Tracks if the transaction should be rolled back to the next
         # available savepoint because of an exception in an inner block.
         self.needs_rollback_mongo = False
@@ -268,7 +254,6 @@ def close_pool(self):
     def cursor(self):
         return Cursor()
 
-    @requires_transaction_support
     def validate_no_broken_transaction(self):
         if self.needs_rollback_mongo:
             raise TransactionManagementError(

django_mongodb_backend/transaction.py

@@ -39,14 +39,7 @@ def __enter__(self):
         connection = get_connection(self.using)
         if not connection.in_atomic_block_mongo:
             # Reset state when entering an outermost atomic block.
-            connection.commit_on_exit_mongo = True
             connection.needs_rollback_mongo = False
-            #            if not connection.get_autocommit():
-            # Pretend we're already in an atomic block to bypass the code
-            # that disables autocommit to enter a transaction, and make a
-            # note to deal with this case in __exit__.
-            # connection.in_atomic_block_mongo = True
-            # connection.commit_on_exit = False
 
         if connection.in_atomic_block_mongo:
             # We're already in a transaction. Increment the number of nested atomics.
@@ -102,14 +95,12 @@ def __exit__(self, exc_type, exc_value, traceback):
                         # went wrong with the connection. Drop it.
                         connection.close()
         finally:
-            # Outermost block exit when autocommit was enabled.
-            if not connection.in_atomic_block_mongo:
-                if connection.run_commit_hooks_on_set_autocommit_on:
-                    connection.run_and_clear_commit_hooks()
-            # connection.set_autocommit(True)
-            # Outermost block exit when autocommit was disabled.
-            elif not connection.commit_on_exit:
-                connection.in_atomic_block_mongo = False
+            # Outermost block exit
+            if (
+                not connection.in_atomic_block_mongo
+                and connection.run_commit_hooks_on_set_autocommit_on
+            ):
+                connection.run_and_clear_commit_hooks()
 
 
 def atomic(using=None):

tests/transaction_hooks_/tests.py

@@ -12,12 +12,7 @@ class ForcedError(Exception):
 
 @skipUnlessDBFeature("_supports_transactions")
 class TestConnectionOnCommit(TransactionTestCase):
-    """
-    Tests for transaction.on_commit().
-
-    Creation/checking of database objects in parallel with callback tracking is
-    to verify that the behavior of the two match in all tested cases.
-    """
+    """Largely copied from Django's test/transaction_hooks."""
 
     available_apps = ["transaction_hooks_"]
 

tests/transactions_/tests.py

@@ -1,6 +1,5 @@
-from unittest import expectedFailure
-
-from django.test import TransactionTestCase, skipUnlessDBFeature
+from django.db import DatabaseError
+from django.test import TransactionTestCase, skipIfDBFeature, skipUnlessDBFeature
 
 from django_mongodb_backend import transaction
 
@@ -9,16 +8,7 @@
 
 @skipUnlessDBFeature("_supports_transactions")
 class AtomicTests(TransactionTestCase):
-    """
-    Tests for the atomic decorator and context manager.
-
-    The tests make assertions on internal attributes because there isn't a
-    robust way to ask the database for its current transaction state.
-
-    Since the decorator syntax is converted into a context manager (see the
-    implementation), there are only a few basic tests with the decorator
-    syntax and the bulk of the tests use the context manager syntax.
-    """
+    """Largely copied from Django's test/transactions."""
 
     available_apps = ["transactions_"]
 
@@ -76,15 +66,6 @@ def test_nested_commit_commit(self):
                 reporter2 = Reporter.objects.create(first_name="Archibald", last_name="Haddock")
         self.assertSequenceEqual(Reporter.objects.all(), [reporter2, reporter1])
 
-    @expectedFailure
-    def test_nested_commit_rollback(self):
-        with transaction.atomic():
-            reporter = Reporter.objects.create(first_name="Tintin")
-            with self.assertRaisesMessage(Exception, "Oops"), transaction.atomic():
-                Reporter.objects.create(first_name="Haddock")
-                raise Exception("Oops, that's his last name")
-        self.assertSequenceEqual(Reporter.objects.all(), [reporter])
-
     def test_nested_rollback_commit(self):
         with self.assertRaisesMessage(Exception, "Oops"), transaction.atomic():
             Reporter.objects.create(last_name="Tintin")
@@ -111,16 +92,6 @@ def test_reuse_commit_commit(self):
                 reporter2 = Reporter.objects.create(first_name="Archibald", last_name="Haddock")
         self.assertSequenceEqual(Reporter.objects.all(), [reporter2, reporter1])
 
-    @expectedFailure
-    def test_reuse_commit_rollback(self):
-        atomic = transaction.atomic()
-        with atomic:
-            reporter = Reporter.objects.create(first_name="Tintin")
-            with self.assertRaisesMessage(Exception, "Oops"), atomic:
-                Reporter.objects.create(first_name="Haddock")
-                raise Exception("Oops, that's his last name")
-        self.assertSequenceEqual(Reporter.objects.all(), [reporter])
-
     def test_reuse_rollback_commit(self):
         atomic = transaction.atomic()
         with self.assertRaisesMessage(Exception, "Oops"), atomic:
@@ -141,16 +112,6 @@ def test_reuse_rollback_rollback(self):
             raise Exception("Oops, that's his first name")
         self.assertSequenceEqual(Reporter.objects.all(), [])
 
-    # class AtomicInsideTransactionTests(AtomicTests):
-    #    """All basic tests for atomic should also pass within an existing transaction."""
-
-    #    def setUp(self):
-    #        self.atomic = transaction.atomic()
-    #        self.atomic.__enter__()
-
-    #    def tearDown(self):
-    #        self.atomic.__exit__(*sys.exc_info())
-
     def test_wrap_callable_instance(self):
         """Atomic can wrap callable instances."""
 
@@ -160,3 +121,14 @@ def __call__(self):
 
         # Must not raise an exception
         transaction.atomic(Callable())
+
+
+@skipIfDBFeature("_supports_transactions")
+class AtomicNotSupportedTests(TransactionTestCase):
+    available_apps = ["transactions_"]
+
+    def test_not_supported(self):
+        # MongoDB error:
+        # "Transaction numbers are only allowed on a replica set member or mongos"
+        with self.assertRaises(DatabaseError), transaction.atomic():
+            Reporter.objects.create(first_name="Haddock")