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