def _fixture_teardown(cls): """Empty (only) the tables we loaded fixtures into, then commit.""" if hasattr(cls, 'fixtures') and \ getattr(cls, '_fb_should_teardown_fixtures', True): # If the fixture-bundling test runner advises us that the next test # suite is going to reuse these fixtures, don't tear them down. for db in cls._databases(): tables = tables_used_by_fixtures(cls.fixtures, using=db) # TODO: Think about respecting _meta.db_tablespace, not just # db_table. if tables: connection = connections[db] cursor = connection.cursor() # TODO: Rather than assuming that anything added to by a # fixture can be emptied, remove only what the fixture # added. This would probably solve input.mozilla.com's # failures (since worked around) with Site objects; they # were loading additional Sites with a fixture, and then # the Django-provided example.com site was evaporating. if uses_mysql(connection): cursor.execute('SET FOREIGN_KEY_CHECKS=0') for table in tables: # Truncate implicitly commits. cursor.execute('TRUNCATE `%s`' % table) # TODO: necessary? cursor.execute('SET FOREIGN_KEY_CHECKS=1') else: for table in tables: cursor.execute('DELETE FROM %s' % table) transaction.commit(using=db)
def _fixture_teardown(cls): """Empty (only) the tables we loaded fixtures into, then commit.""" if hasattr(cls, 'fixtures') and \ getattr(cls, '_fb_should_teardown_fixtures', True): # If the fixture-bundling test runner advises us that the next test # suite is going to reuse these fixtures, don't tear them down. for db in cls._databases(): tables = tables_used_by_fixtures(cls.fixtures, using=db) # TODO: Think about respecting _meta.db_tablespace, not just # db_table. if tables: connection = connections[db] cursor = connection.cursor() # TODO: Rather than assuming that anything added to by a # fixture can be emptied, remove only what the fixture # added. This would probably solve input.mozilla.com's # failures (since worked around) with Site objects; they # were loading additional Sites with a fixture, and then # the Django-provided example.com site was evaporating. if uses_mysql(connection): cursor.execute('SET FOREIGN_KEY_CHECKS=0') for table in tables: # Truncate implicitly commits. cursor.execute('TRUNCATE `%s`' % table) # TODO: necessary? cursor.execute('SET FOREIGN_KEY_CHECKS=1') else: for table in tables: cursor.execute('DELETE FROM "%s"' % table) transaction.commit(using=db)
def setup_databases(self): for alias in connections: connection = connections[alias] creation = connection.creation test_db_name = connection.settings_dict['NAME'] #creation._get_test_db_name() orig_db_name = connection.settings_dict['NAME'] connection.settings_dict['NAME'] = test_db_name if _should_create_database(connection): connection.settings_dict['NAME'] = orig_db_name connection.close() else: cursor = connection.cursor() style = no_style() if uses_mysql(connection): reset_statements = _mysql_reset_sequences( style, connection) else: reset_statements = connection.ops.sequence_reset_sql( style, self._get_models_for_connection(connection)) for reset_statement in reset_statements: cursor.execute(reset_statement) # transaction.commit_unless_managed(using=connection.alias) # creation.create_test_db = MethodType( # _skip_create_test_db, creation, creation.__class__) Command.handle = _foreign_key_ignoring_handle # return super(NoseTestSuiteRunner, self).setup_databases() return self.setup_databases2(test_db_name)
def setup_databases(self): """Setup databases, skipping DB creation if requested and possible.""" for alias in connections: connection = connections[alias] creation = connection.creation test_db_name = creation._get_test_db_name() # Mess with the DB name so other things operate on a test DB # rather than the real one. This is done in create_test_db when # we don't monkeypatch it away with _skip_create_test_db. orig_db_name = connection.settings_dict['NAME'] connection.settings_dict['NAME'] = test_db_name if _should_create_database(connection): # We're not using _skip_create_test_db, so put the DB name # back: connection.settings_dict['NAME'] = orig_db_name # Since we replaced the connection with the test DB, closing # the connection will avoid pooling issues with SQLAlchemy. The # issue is trying to CREATE/DROP the test database using a # connection to a DB that was established with that test DB. # MySQLdb doesn't allow it, and SQLAlchemy attempts to reuse # the existing connection from its pool. connection.close() else: # Reset auto-increment sequences. Apparently, SUMO's tests are # horrid and coupled to certain numbers. cursor = connection.cursor() style = no_style() if uses_mysql(connection): reset_statements = _mysql_reset_sequences( style, connection) else: reset_statements = connection.ops.sequence_reset_sql( style, self._get_models_for_connection(connection)) if hasattr(transaction, "atomic"): with transaction.atomic(using=connection.alias): for reset_statement in reset_statements: cursor.execute(reset_statement) else: # Django < 1.6 for reset_statement in reset_statements: cursor.execute(reset_statement) transaction.commit_unless_managed(using=connection.alias) # Each connection has its own creation object, so this affects # only a single connection: creation.create_test_db = MethodType(_skip_create_test_db, creation) Command.handle = _foreign_key_ignoring_handle # With our class patch, does nothing but return some connection # objects: return super(NoseTestSuiteRunner, self).setup_databases()
def setup_databases(self): """Set up databases. Skip DB creation if requested and possible.""" for alias in connections: connection = connections[alias] creation = connection.creation test_db_name = creation._get_test_db_name() # Mess with the DB name so other things operate on a test DB # rather than the real one. This is done in create_test_db when # we don't monkeypatch it away with _skip_create_test_db. orig_db_name = connection.settings_dict['NAME'] connection.settings_dict['NAME'] = test_db_name if _should_create_database(connection): # We're not using _skip_create_test_db, so put the DB name # back: connection.settings_dict['NAME'] = orig_db_name # Since we replaced the connection with the test DB, closing # the connection will avoid pooling issues with SQLAlchemy. The # issue is trying to CREATE/DROP the test database using a # connection to a DB that was established with that test DB. # MySQLdb doesn't allow it, and SQLAlchemy attempts to reuse # the existing connection from its pool. connection.close() else: # Reset auto-increment sequences. Apparently, SUMO's tests are # horrid and coupled to certain numbers. cursor = connection.cursor() style = no_style() if uses_mysql(connection): reset_statements = _mysql_reset_sequences( style, connection) else: reset_statements = connection.ops.sequence_reset_sql( style, self._get_models_for_connection(connection)) if hasattr(transaction, "atomic"): with transaction.atomic(using=connection.alias): for reset_statement in reset_statements: cursor.execute(reset_statement) else: # Django < 1.6 for reset_statement in reset_statements: cursor.execute(reset_statement) transaction.commit_unless_managed(using=connection.alias) # Each connection has its own creation object, so this affects # only a single connection: creation.create_test_db = MethodType( _skip_create_test_db, creation) Command.handle = _foreign_key_ignoring_handle # With our class patch, does nothing but return some connection # objects: return super(NoseTestSuiteRunner, self).setup_databases()
def setup_databases(self): for alias in connections: connection = connections[alias] creation = connection.creation test_db_name = creation._get_test_db_name() # Mess with the DB name so other things operate on a test DB # rather than the real one. This is done in create_test_db when # we don't monkeypatch it away with _skip_create_test_db. orig_db_name = connection.settings_dict['NAME'] connection.settings_dict['NAME'] = test_db_name if _should_create_database(connection): # We're not using _skip_create_test_db, so put the DB name # back: connection.settings_dict['NAME'] = orig_db_name # Since we replaced the connection with the test DB, closing # the connection will avoid pooling issues with SQLAlchemy. The # issue is trying to CREATE/DROP the test database using a # connection to a DB that was established with that test DB. # MySQLdb doesn't allow it, and SQLAlchemy attempts to reuse # the existing connection from its pool. connection.close() else: connection.settings_dict['TEST_NAME'] = test_db_name # Reset auto-increment sequences. Apparently, SUMO's tests are # horrid and coupled to certain numbers. cursor = connection.cursor() style = no_style() if uses_mysql(connection): reset_statements = _mysql_reset_sequences( style, connection) else: reset_statements = connection.ops.sequence_reset_sql( style, self._get_models_for_connection(connection)) for reset_statement in reset_statements: cursor.execute(reset_statement) # Django v1.3 (https://code.djangoproject.com/ticket/9964) # starts using commit_unless_managed() for individual # connections. Backwards compatibility for Django 1.2 is to use # the generic transaction function. transaction.commit_unless_managed(using=connection.alias) # Each connection has its own creation object, so this affects # only a single connection: creation.create_test_db = new.instancemethod( _skip_create_test_db, creation, creation.__class__) Command.handle = _foreign_key_ignoring_handle # With our class patch, does nothing but return some connection # objects: return super(NoseTestSuiteRunner, self).setup_databases()
def setup_databases(self): for alias in connections: connection = connections[alias] creation = connection.creation test_db_name = creation._get_test_db_name() # Mess with the DB name so other things operate on a test DB # rather than the real one. This is done in create_test_db when # we don't monkeypatch it away with _skip_create_test_db. orig_db_name = connection.settings_dict['NAME'] connection.settings_dict['NAME'] = test_db_name if _should_create_database(connection): # We're not using _skip_create_test_db, so put the DB name # back: connection.settings_dict['NAME'] = orig_db_name # Since we replaced the connection with the test DB, closing # the connection will avoid pooling issues with SQLAlchemy. The # issue is trying to CREATE/DROP the test database using a # connection to a DB that was established with that test DB. # MySQLdb doesn't allow it, and SQLAlchemy attempts to reuse # the existing connection from its pool. connection.close() else: # Reset auto-increment sequences. Apparently, SUMO's tests are # horrid and coupled to certain numbers. cursor = connection.cursor() style = no_style() if uses_mysql(connection): reset_statements = _mysql_reset_sequences( style, connection) else: reset_statements = connection.ops.sequence_reset_sql( style, cache.get_models()) for reset_statement in reset_statements: cursor.execute(reset_statement) # Django v1.3 (https://code.djangoproject.com/ticket/9964) # starts using commit_unless_managed() for individual # connections. Backwards compatibility for Django 1.2 is to use # the generic transaction function. transaction.commit_unless_managed(using=connection.alias) # Each connection has its own creation object, so this affects # only a single connection: creation.create_test_db = new.instancemethod( _skip_create_test_db, creation, creation.__class__) Command.handle = _foreign_key_ignoring_handle # With our class patch, does nothing but return some connection # objects: return super(NoseTestSuiteRunner, self).setup_databases()
def _foreign_key_ignoring_handle(self, *fixture_labels, **options): """Wrap the the stock loaddata to ignore foreign key checks. This allows loading circular references from fixtures, and is monkeypatched into place in setup_databases(). """ using = options.get("database", DEFAULT_DB_ALIAS) connection = connections[using] # MySQL stinks at loading circular references: if uses_mysql(connection): cursor = connection.cursor() cursor.execute("SET foreign_key_checks = 0") _old_handle(self, *fixture_labels, **options) if uses_mysql(connection): cursor = connection.cursor() cursor.execute("SET foreign_key_checks = 1")
def _foreign_key_ignoring_handle(self, *fixture_labels, **options): """Wrap the the stock loaddata to ignore foreign key checks so we can load circular references from fixtures. This is monkeypatched into place in setup_databases(). """ using = options.get('database', DEFAULT_DB_ALIAS) commit = options.get('commit', True) connection = connections[using] # MySQL stinks at loading circular references: if uses_mysql(connection): cursor = connection.cursor() cursor.execute('SET foreign_key_checks = 0') _old_handle(self, *fixture_labels, **options) if uses_mysql(connection): cursor = connection.cursor() cursor.execute('SET foreign_key_checks = 1')