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()