Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Migrated transactions doctests. Thanks to Eric Florenzano.

git-svn-id: http://code.djangoproject.com/svn/django/trunk@13826 bcc190cf-cafb-0310-a4f2-bffc1f526a37
  • Loading branch information...
commit 6948b280c77bea23df3d3471f454065b0d7be5ab 1 parent a60948c
@freakboy3742 freakboy3742 authored
View
136 tests/modeltests/transactions/models.py
@@ -18,138 +18,4 @@ class Meta:
ordering = ('first_name', 'last_name')
def __unicode__(self):
- return u"%s %s" % (self.first_name, self.last_name)
-
-__test__ = {'API_TESTS':"""
->>> from django.db import connection, transaction
-"""}
-
-from django.conf import settings
-
-building_docs = getattr(settings, 'BUILDING_DOCS', False)
-
-if building_docs or settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] != 'django.db.backends.mysql':
- __test__['API_TESTS'] += """
-# the default behavior is to autocommit after each save() action
->>> def create_a_reporter_then_fail(first, last):
-... a = Reporter(first_name=first, last_name=last)
-... a.save()
-... raise Exception("I meant to do that")
-...
->>> create_a_reporter_then_fail("Alice", "Smith")
-Traceback (most recent call last):
- ...
-Exception: I meant to do that
-
-# The object created before the exception still exists
->>> Reporter.objects.all()
-[<Reporter: Alice Smith>]
-
-# the autocommit decorator works exactly the same as the default behavior
->>> autocomitted_create_then_fail = transaction.autocommit(create_a_reporter_then_fail)
->>> autocomitted_create_then_fail("Ben", "Jones")
-Traceback (most recent call last):
- ...
-Exception: I meant to do that
-
-# Same behavior as before
->>> Reporter.objects.all()
-[<Reporter: Alice Smith>, <Reporter: Ben Jones>]
-
-# the autocommit decorator also works with a using argument
->>> using_autocomitted_create_then_fail = transaction.autocommit(using='default')(create_a_reporter_then_fail)
->>> using_autocomitted_create_then_fail("Carol", "Doe")
-Traceback (most recent call last):
- ...
-Exception: I meant to do that
-
-# Same behavior as before
->>> Reporter.objects.all()
-[<Reporter: Alice Smith>, <Reporter: Ben Jones>, <Reporter: Carol Doe>]
-
-# With the commit_on_success decorator, the transaction is only committed if the
-# function doesn't throw an exception
->>> committed_on_success = transaction.commit_on_success(create_a_reporter_then_fail)
->>> committed_on_success("Dirk", "Gently")
-Traceback (most recent call last):
- ...
-Exception: I meant to do that
-
-# This time the object never got saved
->>> Reporter.objects.all()
-[<Reporter: Alice Smith>, <Reporter: Ben Jones>, <Reporter: Carol Doe>]
-
-# commit_on_success decorator also works with a using argument
->>> using_committed_on_success = transaction.commit_on_success(using='default')(create_a_reporter_then_fail)
->>> using_committed_on_success("Dirk", "Gently")
-Traceback (most recent call last):
- ...
-Exception: I meant to do that
-
-# This time the object never got saved
->>> Reporter.objects.all()
-[<Reporter: Alice Smith>, <Reporter: Ben Jones>, <Reporter: Carol Doe>]
-
-# If there aren't any exceptions, the data will get saved
->>> def remove_a_reporter():
-... r = Reporter.objects.get(first_name="Alice")
-... r.delete()
-...
->>> remove_comitted_on_success = transaction.commit_on_success(remove_a_reporter)
->>> remove_comitted_on_success()
->>> Reporter.objects.all()
-[<Reporter: Ben Jones>, <Reporter: Carol Doe>]
-
-# You can manually manage transactions if you really want to, but you
-# have to remember to commit/rollback
->>> def manually_managed():
-... r = Reporter(first_name="Dirk", last_name="Gently")
-... r.save()
-... transaction.commit()
->>> manually_managed = transaction.commit_manually(manually_managed)
->>> manually_managed()
->>> Reporter.objects.all()
-[<Reporter: Ben Jones>, <Reporter: Carol Doe>, <Reporter: Dirk Gently>]
-
-# If you forget, you'll get bad errors
->>> def manually_managed_mistake():
-... r = Reporter(first_name="Edward", last_name="Woodward")
-... r.save()
-... # oops, I forgot to commit/rollback!
->>> manually_managed_mistake = transaction.commit_manually(manually_managed_mistake)
->>> manually_managed_mistake()
-Traceback (most recent call last):
- ...
-TransactionManagementError: Transaction managed block ended with pending COMMIT/ROLLBACK
-
-# commit_manually also works with a using argument
->>> using_manually_managed_mistake = transaction.commit_manually(using='default')(manually_managed_mistake)
->>> using_manually_managed_mistake()
-Traceback (most recent call last):
- ...
-TransactionManagementError: Transaction managed block ended with pending COMMIT/ROLLBACK
-
-"""
-
-# Regression for #11900: If a function wrapped by commit_on_success writes a
-# transaction that can't be committed, that transaction should be rolled back.
-# The bug is only visible using the psycopg2 backend, though
-# the fix is generally a good idea.
-pgsql_backends = ('django.db.backends.postgresql_psycopg2', 'postgresql_psycopg2',)
-if building_docs or settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] in pgsql_backends:
- __test__['API_TESTS'] += """
->>> def execute_bad_sql():
-... cursor = connection.cursor()
-... cursor.execute("INSERT INTO transactions_reporter (first_name, last_name) VALUES ('Douglas', 'Adams');")
-... transaction.set_dirty()
-...
->>> execute_bad_sql = transaction.commit_on_success(execute_bad_sql)
->>> execute_bad_sql()
-Traceback (most recent call last):
- ...
-IntegrityError: null value in column "email" violates not-null constraint
-<BLANKLINE>
-
->>> transaction.rollback()
-
-"""
+ return u"%s %s" % (self.first_name, self.last_name)
View
155 tests/modeltests/transactions/tests.py
@@ -0,0 +1,155 @@
+from django.test import TransactionTestCase
+from django.db import connection, transaction, IntegrityError, DEFAULT_DB_ALIAS
+from django.conf import settings
+
+from models import Reporter
+
+PGSQL = 'psycopg2' in settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE']
+MYSQL = 'mysql' in settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE']
+
+class TransactionTests(TransactionTestCase):
+
+ if not MYSQL:
+
+ def create_a_reporter_then_fail(self, first, last):
+ a = Reporter(first_name=first, last_name=last)
+ a.save()
+ raise Exception("I meant to do that")
+
+ def remove_a_reporter(self, first_name):
+ r = Reporter.objects.get(first_name="Alice")
+ r.delete()
+
+ def manually_managed(self):
+ r = Reporter(first_name="Dirk", last_name="Gently")
+ r.save()
+ transaction.commit()
+
+ def manually_managed_mistake(self):
+ r = Reporter(first_name="Edward", last_name="Woodward")
+ r.save()
+ # Oops, I forgot to commit/rollback!
+
+ def execute_bad_sql(self):
+ cursor = connection.cursor()
+ cursor.execute("INSERT INTO transactions_reporter (first_name, last_name) VALUES ('Douglas', 'Adams');")
+ transaction.set_dirty()
+
+ def test_autocommit(self):
+ """
+ The default behavior is to autocommit after each save() action.
+ """
+ self.assertRaises(Exception,
+ self.create_a_reporter_then_fail,
+ "Alice", "Smith"
+ )
+
+ # The object created before the exception still exists
+ self.assertEqual(Reporter.objects.count(), 1)
+
+ def test_autocommit_decorator(self):
+ """
+ The autocommit decorator works exactly the same as the default behavior.
+ """
+ autocomitted_create_then_fail = transaction.autocommit(
+ self.create_a_reporter_then_fail
+ )
+ self.assertRaises(Exception,
+ autocomitted_create_then_fail,
+ "Alice", "Smith"
+ )
+ # Again, the object created before the exception still exists
+ self.assertEqual(Reporter.objects.count(), 1)
+
+ def test_autocommit_decorator_with_using(self):
+ """
+ The autocommit decorator also works with a using argument.
+ """
+ autocomitted_create_then_fail = transaction.autocommit(using='default')(
+ self.create_a_reporter_then_fail
+ )
+ self.assertRaises(Exception,
+ autocomitted_create_then_fail,
+ "Alice", "Smith"
+ )
+ # Again, the object created before the exception still exists
+ self.assertEqual(Reporter.objects.count(), 1)
+
+ def test_commit_on_success(self):
+ """
+ With the commit_on_success decorator, the transaction is only committed
+ if the function doesn't throw an exception.
+ """
+ committed_on_success = transaction.commit_on_success(
+ self.create_a_reporter_then_fail)
+ self.assertRaises(Exception, committed_on_success, "Dirk", "Gently")
+ # This time the object never got saved
+ self.assertEqual(Reporter.objects.count(), 0)
+
+ def test_commit_on_success_with_using(self):
+ """
+ The commit_on_success decorator also works with a using argument.
+ """
+ using_committed_on_success = transaction.commit_on_success(using='default')(
+ self.create_a_reporter_then_fail
+ )
+ self.assertRaises(Exception,
+ using_committed_on_success,
+ "Dirk", "Gently"
+ )
+ # This time the object never got saved
+ self.assertEqual(Reporter.objects.count(), 0)
+
+ def test_commit_on_success_succeed(self):
+ """
+ If there aren't any exceptions, the data will get saved.
+ """
+ Reporter.objects.create(first_name="Alice", last_name="Smith")
+ remove_comitted_on_success = transaction.commit_on_success(
+ self.remove_a_reporter
+ )
+ remove_comitted_on_success("Alice")
+ self.assertEqual(list(Reporter.objects.all()), [])
+
+ def test_manually_managed(self):
+ """
+ You can manually manage transactions if you really want to, but you
+ have to remember to commit/rollback.
+ """
+ manually_managed = transaction.commit_manually(self.manually_managed)
+ manually_managed()
+ self.assertEqual(Reporter.objects.count(), 1)
+
+ def test_manually_managed_mistake(self):
+ """
+ If you forget, you'll get bad errors.
+ """
+ manually_managed_mistake = transaction.commit_manually(
+ self.manually_managed_mistake
+ )
+ self.assertRaises(transaction.TransactionManagementError,
+ manually_managed_mistake)
+
+ def test_manually_managed_with_using(self):
+ """
+ The commit_manually function also works with a using argument.
+ """
+ using_manually_managed_mistake = transaction.commit_manually(using='default')(
+ self.manually_managed_mistake
+ )
+ self.assertRaises(transaction.TransactionManagementError,
+ using_manually_managed_mistake
+ )
+
+ if PGSQL:
+
+ def test_bad_sql(self):
+ """
+ Regression for #11900: If a function wrapped by commit_on_success
+ writes a transaction that can't be committed, that transaction should
+ be rolled back. The bug is only visible using the psycopg2 backend,
+ though the fix is generally a good idea.
+ """
+ execute_bad_sql = transaction.commit_on_success(self.execute_bad_sql)
+ self.assertRaises(IntegrityError, execute_bad_sql)
+ transaction.rollback()

0 comments on commit 6948b28

Please sign in to comment.
Something went wrong with that request. Please try again.