Beispiel #1
0
    def pytest_runtest_setup(self, item):
        item_obj = self._get_item_obj(item)

        # Set the URLs if the py.test.urls() decorator has been applied
        if hasattr(item.obj, "urls"):
            self._old_urlconf = settings.ROOT_URLCONF
            settings.ROOT_URLCONF = item.obj.urls
            clear_url_caches()

        # This is a Django unittest TestCase
        if self._is_unittest(item_obj):
            # We have to run these here since py.test's unittest plugin skips
            # __call__()
            item_obj.client = Client()
            item_obj._pre_setup()
            item_obj.setUp()
            return

        if not settings.DATABASE_SUPPORTS_TRANSACTIONS:
            call_command("flush", verbosity=self.verbosity, interactive=not self.noinput)
        else:
            transaction.enter_transaction_management()
            transaction.managed(True)
            disable_transaction_methods()

            from django.contrib.sites.models import Site

            Site.objects.clear_cache()

        mail.outbox = []
Beispiel #2
0
    def _fixture_setup (self):
        print 'IN VIEWS TESTS BEFORE'
        from django.test.testcases import connections_support_transactions, transaction, disable_transaction_methods, call_command
        if not connections_support_transactions():
            return super(TestCase, self)._fixture_setup()

        assert not self.reset_sequences, 'reset_sequences cannot be used on TestCase instances'

        self.atomics = {}
        for db_name in self._databases_names():
            self.atomics[db_name] = transaction.atomic(using=db_name)
            self.atomics[db_name].__enter__()
        # Remove this when the legacy transaction management goes away.
        disable_transaction_methods()

        for db_name in self._databases_names(include_mirrors=False):
            if self.fixtures:
                try:
                    call_command('loaddata', *self.fixtures,
                                 **{
                                     'verbosity': 1,
                                     'commit': False,
                                     'database': db_name,
                                     'skip_checks': False,
                                 })
                except Exception, e:
                    print 'DBNAME', db_name
                    self._fixture_teardown()

                    if breakpoint:
                      from IPython import embed
                      embed()  # breaks into an ipython shell here!

                    raise
    def _pre_setup(self):
        if not connections_support_transactions():
            fixtures = [
                "sample_users", "sample_site", "sample_languages",
                "sample_data"
            ]
            if getattr(self, 'multi_db', False):
                databases = connections
            else:
                databases = [DEFAULT_DB_ALIAS]
            for db in databases:
                management.call_command('flush',
                                        verbosity=0,
                                        interactive=False,
                                        database=db)
                management.call_command('loaddata', *fixtures, **{
                    'verbosity': 0,
                    'database': db
                })

        else:
            if getattr(self, 'multi_db', False):
                databases = connections
            else:
                databases = [DEFAULT_DB_ALIAS]

            for db in databases:
                transaction.enter_transaction_management(using=db)
                transaction.managed(True, using=db)
            disable_transaction_methods()
        mail.outbox = []
Beispiel #4
0
    def _fixture_setup(self):
        if not connections_support_transactions():
            raise

        # If the test case has a multi_db=True flag, setup all databases.
        # Otherwise, just use default.
        if getattr(self, 'multi_db', False):
            databases = connections
        else:
            databases = [DEFAULT_DB_ALIAS]

        for db in databases:
            transaction.enter_transaction_management(using=db)
            transaction.managed(True, using=db)
        disable_transaction_methods()

        from django.contrib.sites.models import Site
        Site.objects.clear_cache()

        

        for db in databases:
            if hasattr(self, 'fixtures'):
                fixtures = [ __package__+'_'+fixture for fixture in self.fixtures]
                call_command('loaddata', *fixtures, **{
                                                            'verbosity': 1,
                                                            'commit': False,
                                                            'database': db
                                                            })
Beispiel #5
0
def start_django_transaction(scenario):
    transaction.enter_transaction_management()
    transaction.managed(True)
    call_command('loaddata', 'events/fixtures/event-types.json', **{
        'verbosity': 0,
        'commit': False,
    })
    disable_transaction_methods()
Beispiel #6
0
def start_django_transaction(scenario):
    transaction.enter_transaction_management()
    transaction.managed(True)
    call_command('loaddata', 'events/fixtures/event-types.json', **{
        'verbosity': 0,
        'commit': False,
    })
    disable_transaction_methods()
Beispiel #7
0
 def _start_test_transaction():
     if connections_support_transactions():
         transaction.enter_transaction_management(using='default')
         transaction.managed(True, using='default')
     else:
         call_command('flush', verbosity=0, interactive=False,
                      database='default')
     disable_transaction_methods()
Beispiel #8
0
 def _start_test_transaction():
     if connections_support_transactions():
         transaction.enter_transaction_management(using='default')
         transaction.managed(True, using='default')
     else:
         call_command('flush', verbosity=0, interactive=False,
                      database='default')
     disable_transaction_methods()
Beispiel #9
0
    def setUpClass(cls):
        super(OptimizedTestCase, cls).setUpClass()
        transaction.enter_transaction_management(using='default')
        transaction.managed(True, using='default')
        disable_transaction_methods()
        cls.client = Client()

        # Flush mail outbox after previous testcases.
        mail.outbox = []
    def _enable_transactions(*args, **kwargs):
        restore_transaction_methods()
        try:
            ret = func(*args, **kwargs)
        except:
            raise
        finally:
            disable_transaction_methods()

        return ret
    def _enable_transactions(*args, **kwargs):
        restore_transaction_methods()
        try:
            ret = func(*args, **kwargs)
        except:
            raise
        finally:
            disable_transaction_methods()

        return ret
Beispiel #12
0
        def fast_fixture_setup(instance):
            if not connections_support_transactions():
                return super(TestCase, instance)._fixture_setup()

            fixtures = getattr(instance, 'fixtures', [])

            loaddata = fixtures
            flush_db = True
            if len(self.currernt_fixtures) <= len(fixtures):
                if fixtures[:len(self.currernt_fixtures
                                 )] == self.currernt_fixtures:
                    # current fixtures are still OK
                    loaddata = fixtures[len(self.currernt_fixtures):]
                    self.fixtures_prevented += len(self.currernt_fixtures)
                    flush_db = False

            if flush_db:
                ContentType.objects.clear_cache()
                self.flushes += 1
                self.currernt_fixtures = []
                for db in connections:
                    call_command('flush',
                                 verbosity=0,
                                 interactive=False,
                                 database=db)

            if len(loaddata):
                self.fixtures += len(loaddata)
                self.fixtures_sets.append(self.currernt_fixtures + loaddata)
                for db in connections:
                    call_command(
                        'loaddata', *loaddata, **{
                            'verbosity': 0,
                            'commit': True,
                            'database': db
                        })
            self.currernt_fixtures = fixtures

            # If the test case has a multi_db=True flag, setup all databases.
            # Otherwise, just use default.
            if getattr(self, 'multi_db', False):
                databases = connections
            else:
                databases = [DEFAULT_DB_ALIAS]

            instance.atomics = {}

            for db in databases:
                instance.atomics[db] = transaction.atomic(using=db)
                instance.atomics[db].__enter__()
            disable_transaction_methods()

            from django.contrib.sites import get_site_model
            Site = get_site_model()
            Site.objects.clear_cache()
Beispiel #13
0
    def beforeTest(self, test):
        if not self._apply(test):
            return

        mail.outbox = []

        # Before each test, disable transaction support.
        transaction_support = self._has_transaction_support(test)
        if transaction_support:
            transaction.enter_transaction_management()
            transaction.managed(True)
            disable_transaction_methods()
Beispiel #14
0
    def __enter__(self):
        databases = connections

        for db in databases:
            transaction.enter_transaction_management(using=db)
            transaction.managed(True, using=db)

        disable_transaction_methods()

        if self.fixtures:
            for db in databases:
                if isinstance(connections[db], DatabaseProxy):
                    continue
                call_command('loaddata', *self.fixtures, **dict(verbosity=0, database=db, commit=False))
Beispiel #15
0
  def setup_database(self, transactions = True):
    if not transactions:
      transaction.enter_transaction_management()
      transaction.managed(True)
      disable_transaction_methods()
    else:
      restore_database()

    Site.objects.clear_cache()

    if hasattr(self, 'fixtures'):
      call_command('loaddata', *self.fixtures, **{
                                                   'verbosity': 0,
                                                   'commit': False
                                                 })
Beispiel #16
0
        def fast_fixture_setup(instance):
            if not connections_support_transactions():
                return super(TestCase, instance)._fixture_setup()

            fixtures = getattr(instance, "fixtures", [])

            loaddata = fixtures
            flush_db = True
            if len(self.currernt_fixtures) <= len(fixtures):
                if fixtures[: len(self.currernt_fixtures)] == self.currernt_fixtures:
                    # current fixtures are still OK
                    loaddata = fixtures[len(self.currernt_fixtures) :]
                    self.fixtures_prevented += len(self.currernt_fixtures)
                    flush_db = False

            if flush_db:
                ContentType.objects.clear_cache()
                self.flushes += 1
                self.currernt_fixtures = []
                for db in connections:
                    call_command("flush", verbosity=0, interactive=False, database=db)

            if len(loaddata):
                self.fixtures += len(loaddata)
                self.fixtures_sets.append(self.currernt_fixtures + loaddata)
                for db in connections:
                    call_command("loaddata", *loaddata, **{"verbosity": 0, "commit": True, "database": db})
            self.currernt_fixtures = fixtures

            # If the test case has a multi_db=True flag, setup all databases.
            # Otherwise, just use default.
            if getattr(self, "multi_db", False):
                databases = connections
            else:
                databases = [DEFAULT_DB_ALIAS]

            instance.atomics = {}

            for db in databases:
                instance.atomics[db] = transaction.atomic(using=db)
                instance.atomics[db].__enter__()
            disable_transaction_methods()

            from django.contrib.sites import get_site_model

            Site = get_site_model()
            Site.objects.clear_cache()
Beispiel #17
0
        def fast_fixture_setup(instance):
            if not connections_support_transactions():
                return super(TestCase, instance)._fixture_setup()

            fixtures = getattr(instance, 'fixtures', [])

            loaddata = fixtures
            flush_db = True
            if len(self.currernt_fixtures) <= len(fixtures):
                if fixtures[:len(self.currernt_fixtures)] == self.currernt_fixtures:
                    # current fixtures are still OK
                    loaddata = fixtures[len(self.currernt_fixtures):]
                    self.fixtures_prevented += len(self.currernt_fixtures)
                    flush_db = False

            if flush_db:
                ContentType.objects.clear_cache()
                self.flushes += 1
                self.currernt_fixtures = []
                for db in connections:
                    call_command('flush', verbosity=0, interactive=False, database=db)

            if len(loaddata):
                self.fixtures += len(loaddata)
                self.fixtures_sets.append(self.currernt_fixtures + loaddata)
                for db in connections:
                    call_command('loaddata', *loaddata, **{
                                                        'verbosity': 0,
                                                        'commit': True,
                                                        'database': db
                                                        })
            self.currernt_fixtures = fixtures

            # If the test case has a multi_db=True flag, setup all databases.
            # Otherwise, just use default.
            if getattr(self, 'multi_db', False):
                databases = connections
            else:
                databases = [DEFAULT_DB_ALIAS]

            for db in databases:
                transaction.enter_transaction_management(using=db)
                transaction.managed(True, using=db)
            disable_transaction_methods()

            from django.contrib.sites.models import Site
            Site.objects.clear_cache()
Beispiel #18
0
def pytest_runtest_setup(item):
    """
    Per-test setup.

    Start a transaction and disable transaction methods for the duration of the
    test. The transaction will be rolled back after the test. This prevents any
    database changes made to Django ORM models from persisting between tests,
    providing test isolation.

    Also clear the cache (by incrementing the key prefix).

    """
    from django.test.testcases import disable_transaction_methods
    from django.db import transaction

    transaction.enter_transaction_management()
    transaction.managed(True)
    disable_transaction_methods()

    increment_cache_key_prefix()
Beispiel #19
0
def pytest_runtest_setup(item):
    """
    Per-test setup.

    Start a transaction and disable transaction methods for the duration of the
    test. The transaction will be rolled back after the test. This prevents any
    database changes made to Django ORM models from persisting between tests,
    providing test isolation.

    Also clear the cache (by incrementing the key prefix).

    """
    from django.test.testcases import disable_transaction_methods
    from django.db import transaction

    transaction.enter_transaction_management()
    transaction.managed(True)
    disable_transaction_methods()

    increment_cache_key_prefix()
Beispiel #20
0
    def _fixture_setup(self):
        """Finds a list called :attr:`datasets` and loads them

        This is done in a transaction if possible.
        I'm not using the settings.DATABASE_SUPPORTS_TRANSACTIONS as I don't
        wnat to assume that :meth:`connection.create_test_db` might not have been
        called
        """
        if self._is_transaction_supported:
            transaction.enter_transaction_management()
            transaction.managed(True)
            testcases.disable_transaction_methods()

        from django.contrib.sites.models import Site
        Site.objects.clear_cache()

        if not hasattr(self, 'fixture'):
            self.fixture = DjangoFixture()
        if hasattr(self, 'datasets'):
            self.data = self.fixture.data(*self.datasets)
            self.data.setup()
    def _fixture_setup(self):
        """Finds a list called :attr:`datasets` and loads them

        This is done in a transaction if possible.
        I'm not using the settings.DATABASE_SUPPORTS_TRANSACTIONS as I don't
        wnat to assume that :meth:`connection.create_test_db` might not have been
        called
        """
        if check_supports_transactions(connection):
            transaction.enter_transaction_management()
            transaction.managed(True)
            testcases.disable_transaction_methods()
    
        from django.contrib.sites.models import Site
        Site.objects.clear_cache()
        
        if not hasattr(self, 'fixture'):
            self.fixture = DjangoFixture()
        if hasattr(self, 'datasets'):
            self.data = self.fixture.data(*self.datasets)
            self.data.setup()
Beispiel #22
0
    def _pre_setup(self):
        if not connections_support_transactions():
            fixtures = ["sample_users", "sample_site", "sample_languages", "sample_data"]
            if getattr(self, 'multi_db', False):
                databases = connections
            else:
                databases = [DEFAULT_DB_ALIAS]
            for db in databases:
                management.call_command('flush', verbosity=0,
                interactive=False, database=db)
                management.call_command('loaddata', *fixtures, **{
                    'verbosity': 0, 'database': db})

        else:
            if getattr(self, 'multi_db', False):
                databases = connections
            else:
                databases = [DEFAULT_DB_ALIAS]

            for db in databases:
                transaction.enter_transaction_management(using=db)
                transaction.managed(True, using=db)
            disable_transaction_methods()
        mail.outbox = []
Beispiel #23
0
 def setUpClass(cls):
     transaction.enter_transaction_management(using=DEFAULT_DB_ALIAS)
     transaction.managed(True, using=DEFAULT_DB_ALIAS)
     disable_transaction_methods()
     cls.fixtures_loaded = False
Beispiel #24
0
def start_django_transaction(scenario):
    transaction.enter_transaction_management()
    transaction.managed(True)
    call_command("loaddata", "events/fixtures/event-types.json", **{"verbosity": 0, "commit": False})
    disable_transaction_methods()
Beispiel #25
0
            try:
                calculate_and_get_json_for_api(self.request, self.user.username, self.sheet.id)
            except Exception, e:
                self.assertEquals(e, expected_exception)
            else:
                self.fail("No exception raised by calculate_and_get_json_for_api!")

        finally:
            # Because we committed the changes to the text fixture at the
            # start of the try/catch, we need to remove them as otherwise
            # the next test will break
            self.sheet.delete()
            self.user.delete()
            transaction.commit()
            disable_transaction_methods()


    @patch('sheet.views_api_0_1.get_object_or_404')
    def test_adds_access_control_header(
        self, mock_get_object
    ):
        calculation_result = Worksheet()
        calculation_result[1, 3].formula = '=string'
        calculation_result[1, 3].value = 'test value'
        calculation_result[2, 5].formula = '=int'
        calculation_result[2, 5].value = 6

        mock_sheet = mock_get_object.return_value
        mock_sheet.owner = self.user
        mock_sheet.unjsonify_worksheet.side_effect = lambda: calculation_result