def test_own_alias_dependency(self):
raw = [("s1", ("s1_db", ["alpha", "bravo"]))]
dependencies = {"alpha": ["bravo"]}
with self.assertRaises(ImproperlyConfigured):
simple.dependency_ordered(raw, dependencies=dependencies)
# reordering aliases shouldn't matter
raw = [("s1", ("s1_db", ["bravo", "alpha"]))]
with self.assertRaises(ImproperlyConfigured):
simple.dependency_ordered(raw, dependencies=dependencies)
def test_own_alias_dependency(self):
raw = [('s1', ('s1_db', ['alpha', 'bravo']))]
dependencies = {'alpha': ['bravo']}
with self.assertRaises(ImproperlyConfigured):
simple.dependency_ordered(raw, dependencies=dependencies)
# reordering aliases shouldn't matter
raw = [('s1', ('s1_db', ['bravo', 'alpha']))]
with self.assertRaises(ImproperlyConfigured):
simple.dependency_ordered(raw, dependencies=dependencies)
def test_multiple_dependencies(self):
raw = [
('s1', ('s1_db', ['alpha'])),
('s2', ('s2_db', ['bravo'])),
('s3', ('s3_db', ['charlie'])),
('s4', ('s4_db', ['delta'])),
]
dependencies = {
'alpha': ['bravo', 'delta'],
'bravo': ['charlie'],
'delta': ['charlie'],
}
ordered = simple.dependency_ordered(raw, dependencies=dependencies)
ordered_sigs = [sig for sig, aliases in ordered]
self.assertIn('s1', ordered_sigs)
self.assertIn('s2', ordered_sigs)
self.assertIn('s3', ordered_sigs)
self.assertIn('s4', ordered_sigs)
# Explicit dependencies
self.assertLess(ordered_sigs.index('s2'), ordered_sigs.index('s1'))
self.assertLess(ordered_sigs.index('s4'), ordered_sigs.index('s1'))
self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s2'))
self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s4'))
# Implicit dependencies
self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s1'))
def test_multiple_dependencies(self):
raw = [
("s1", ("s1_db", ["alpha"])),
("s2", ("s2_db", ["bravo"])),
("s3", ("s3_db", ["charlie"])),
("s4", ("s4_db", ["delta"])),
]
dependencies = {"alpha": ["bravo", "delta"], "bravo": ["charlie"], "delta": ["charlie"]}
ordered = simple.dependency_ordered(raw, dependencies=dependencies)
ordered_sigs = [sig for sig, aliases in ordered]
self.assertIn("s1", ordered_sigs)
self.assertIn("s2", ordered_sigs)
self.assertIn("s3", ordered_sigs)
self.assertIn("s4", ordered_sigs)
# Explicit dependencies
self.assertLess(ordered_sigs.index("s2"), ordered_sigs.index("s1"))
self.assertLess(ordered_sigs.index("s4"), ordered_sigs.index("s1"))
self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s2"))
self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s4"))
# Implicit dependencies
self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s1"))
def test_multiple_dependencies(self):
raw = [
('s1', ('s1_db', ['alpha'])),
('s2', ('s2_db', ['bravo'])),
('s3', ('s3_db', ['charlie'])),
('s4', ('s4_db', ['delta'])),
]
dependencies = {
'alpha': ['bravo','delta'],
'bravo': ['charlie'],
'delta': ['charlie'],
}
ordered = simple.dependency_ordered(raw, dependencies=dependencies)
ordered_sigs = [sig for sig,aliases in ordered]
self.assertIn('s1', ordered_sigs)
self.assertIn('s2', ordered_sigs)
self.assertIn('s3', ordered_sigs)
self.assertIn('s4', ordered_sigs)
# Explicit dependencies
self.assertLess(ordered_sigs.index('s2'), ordered_sigs.index('s1'))
self.assertLess(ordered_sigs.index('s4'), ordered_sigs.index('s1'))
self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s2'))
self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s4'))
# Implicit dependencies
self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s1'))
def setup_databases(self, **kwargs):
'''
Copied from Django 1.2.4 django.test.simple.DjangoTestSuiteRunner
'''
from django.db import connections, DEFAULT_DB_ALIAS
# First pass -- work out which databases actually need to be created,
# and which ones are test mirrors or duplicate entries in DATABASES
mirrored_aliases = {}
test_databases = {}
dependencies = {}
for alias in connections:
connection = connections[alias]
if connection.settings_dict['TEST_MIRROR']:
# If the database is marked as a test mirror, save
# the alias.
mirrored_aliases[alias] = connection.settings_dict['TEST_MIRROR']
else:
# Store the (engine, name) pair. If we have two aliases
# with the same pair, we only need to create the test database
# once.
test_databases.setdefault((
connection.settings_dict['HOST'],
connection.settings_dict['PORT'],
connection.settings_dict['ENGINE'],
connection.settings_dict['NAME'],
), []).append(alias)
if 'TEST_DEPENDENCIES' in connection.settings_dict:
dependencies[alias] = connection.settings_dict['TEST_DEPENDENCIES']
else:
if alias != 'default':
dependencies[alias] = connection.settings_dict.get('TEST_DEPENDENCIES', ['default'])
# Second pass -- actually create the databases.
old_names = []
mirrors = []
for (host, port, engine, db_name), aliases in dependency_ordered(test_databases.items(), dependencies):
# Actually create the database for the first connection
self.connection = connection = connections[aliases[0]]
old_names.append((connection, db_name, True))
test_db_name = self.create_test_db(self.verbosity, autoclobber=not self.interactive)
for alias in aliases[1:]:
connection = connections[alias]
if db_name:
old_names.append((connection, db_name, False))
connection.settings_dict['NAME'] = test_db_name
else:
# If settings_dict['NAME'] isn't defined, we have a backend where
# the name isn't important -- e.g., SQLite, which uses :memory:.
# Force create the database instead of assuming it's a duplicate.
old_names.append((connection, db_name, True))
self.create_test_db(self.verbosity, autoclobber=not self.interactive)
for alias, mirror_alias in mirrored_aliases.items():
mirrors.append((alias, connections[alias].settings_dict['NAME']))
connections[alias].settings_dict['NAME'] = connections[mirror_alias].settings_dict['NAME']
return old_names, mirrors
def setup_databases(self, **kwargs):
from django.db import connections, DEFAULT_DB_ALIAS
# First pass -- work out which databases actually need to be created,
# and which ones are test mirrors or duplicate entries in DATABASES
mirrored_aliases = {}
test_databases = {}
dependencies = {}
for alias in connections:
connection = connections[alias]
if connection.settings_dict['TEST_MIRROR']:
# If the database is marked as a test mirror, save
# the alias.
mirrored_aliases[alias] = connection.settings_dict['TEST_MIRROR']
else:
# Store a tuple with DB parameters that uniquely identify it.
# If we have two aliases with the same values for that tuple,
# we only need to create the test database once.
item = test_databases.setdefault(
connection.creation.test_db_signature(),
(connection.settings_dict['NAME'], [])
)
item[1].append(alias)
if 'TEST_DEPENDENCIES' in connection.settings_dict:
dependencies[alias] = connection.settings_dict['TEST_DEPENDENCIES']
else:
if alias != DEFAULT_DB_ALIAS:
dependencies[alias] = connection.settings_dict.get('TEST_DEPENDENCIES', [DEFAULT_DB_ALIAS])
# Second pass -- actually create the databases.
old_names = []
mirrors = []
for signature, (db_name, aliases) in dependency_ordered(test_databases.items(), dependencies):
# Actually create the database for the first connection
connection = connections[aliases[0]]
if connection.settings_dict.get("USE_LIVE_FOR_TESTS"):
continue
old_names.append((connection, db_name, True))
test_db_name = connection.creation.create_test_db(self.verbosity, autoclobber=not self.interactive)
for alias in aliases[1:]:
connection = connections[alias]
if db_name:
old_names.append((connection, db_name, False))
connection.settings_dict['NAME'] = test_db_name
else:
# If settings_dict['NAME'] isn't defined, we have a backend where
# the name isn't important -- e.g., SQLite, which uses :memory:.
# Force create the database instead of assuming it's a duplicate.
old_names.append((connection, db_name, True))
connection.creation.create_test_db(self.verbosity, autoclobber=not self.interactive)
for alias, mirror_alias in mirrored_aliases.items():
mirrors.append((alias, connections[alias].settings_dict['NAME']))
connections[alias].settings_dict['NAME'] = connections[mirror_alias].settings_dict['NAME']
return old_names, mirrors
def test_own_alias_dependency(self):
raw = [
('s1', ('s1_db', ['alpha', 'bravo']))
]
dependencies = {
'alpha': ['bravo']
}
with self.assertRaises(ImproperlyConfigured):
simple.dependency_ordered(raw, dependencies=dependencies)
# reordering aliases shouldn't matter
raw = [
('s1', ('s1_db', ['bravo', 'alpha']))
]
with self.assertRaises(ImproperlyConfigured):
simple.dependency_ordered(raw, dependencies=dependencies)
def setup_databases(self):
"""
Reimplement setup_databases but install our ``DatabaseProxy`` on anything
that uses TEST_MIRROR.
"""
# First pass -- work out which databases actually need to be created,
# and which ones are test mirrors or duplicate entries in DATABASES
mirrored_aliases = {}
test_databases = {}
dependencies = {}
for alias in connections:
connection = connections[alias]
if connection.settings_dict['TEST_MIRROR']:
# If the database is marked as a test mirror, save
# the alias.
mirror_alias = connection.settings_dict['TEST_MIRROR']
mirrored_aliases[alias] = mirror_alias
connections._connections[alias] = DatabaseProxy(connections[mirror_alias], alias)
else:
# Store a tuple with DB parameters that uniquely identify it.
# If we have two aliases with the same values for that tuple,
# we only need to create the test database once.
item = test_databases.setdefault(
connection.creation.test_db_signature(),
(connection.settings_dict['NAME'], [])
)
item[1].append(alias)
if 'TEST_DEPENDENCIES' in connection.settings_dict:
dependencies[alias] = connection.settings_dict['TEST_DEPENDENCIES']
else:
if alias != DEFAULT_DB_ALIAS:
dependencies[alias] = connection.settings_dict.get('TEST_DEPENDENCIES', [DEFAULT_DB_ALIAS])
if self.has_nashvegas():
# Monkey patch the ``flush()`` command so we can backup migrations before it's run
flush.Command.handle_noargs = save_migrations_and_flush(flush.Command.handle_noargs)
# Second pass -- actually create the databases.
for signature, (db_name, aliases) in dependency_ordered(test_databases.items(), dependencies):
alias = aliases[0]
# Actually create the database for the first connection
connection = connections[alias]
test_db_name = self._setup_db(connection, alias)
# Handle child databases (which may just be proxies)
for alias in aliases[1:]:
connection = connections[alias]
connection.settings_dict['NAME'] = test_db_name
for alias, mirror_alias in mirrored_aliases.items():
connections[alias].settings_dict['NAME'] = connections[mirror_alias].settings_dict['NAME']
def test_simple_dependencies(self):
raw = [("s1", ("s1_db", ["alpha"])), ("s2", ("s2_db", ["bravo"])), ("s3", ("s3_db", ["charlie"]))]
dependencies = {"alpha": ["charlie"], "bravo": ["charlie"]}
ordered = simple.dependency_ordered(raw, dependencies=dependencies)
ordered_sigs = [sig for sig, value in ordered]
self.assertIn("s1", ordered_sigs)
self.assertIn("s2", ordered_sigs)
self.assertIn("s3", ordered_sigs)
self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s1"))
self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s2"))
def setup_databases(self, **kwargs):
from django.db import connections, DEFAULT_DB_ALIAS
# First pass -- work out which databases actually need to be created,
# and which ones are test mirrors or duplicate entries in DATABASES
mirrored_aliases = {}
test_databases = {}
dependencies = {}
for alias in connections:
connection = connections[alias]
if connection.settings_dict['TEST_MIRROR']:
# If the database is marked as a test mirror, save
# the alias.
mirrored_aliases[alias] = connection.settings_dict[
'TEST_MIRROR']
else:
# Store a tuple with DB parameters that uniquely identify it.
# If we have two aliases with the same values for that tuple,
# we only need to create the test database once.
item = test_databases.setdefault(
connection.creation.test_db_signature(),
(connection.settings_dict['NAME'], []))
item[1].append(alias)
if 'TEST_DEPENDENCIES' in connection.settings_dict:
dependencies[alias] = connection.settings_dict[
'TEST_DEPENDENCIES']
else:
if alias != DEFAULT_DB_ALIAS:
dependencies[alias] = connection.settings_dict.get(
'TEST_DEPENDENCIES', [DEFAULT_DB_ALIAS])
# Second pass -- actually create the databases.
old_names = []
mirrors = []
for signature, (db_name,
aliases) in dependency_ordered(test_databases.items(),
dependencies):
# Actually create the database for the first connection
self.connection = connections[aliases[0]]
old_names.append((self.connection, db_name, True))
""" Mod by Michael Price - use original database as template when creating new one """
# test_db_name = connection.creation.create_test_db(self.verbosity, autoclobber=not self.interactive)
test_db_name = self.create_test_db(
self.verbosity, autoclobber=not self.interactive)
for alias, mirror_alias in mirrored_aliases.items():
mirrors.append((alias, connections[alias].settings_dict['NAME']))
connections[alias].settings_dict['NAME'] = connections[
mirror_alias].settings_dict['NAME']
return old_names, mirrors
def setup_databases_13(self, **kwargs):
# Taken from django.test.simple
from django.test.simple import dependency_ordered
mirrored_aliases = {}
test_databases = {}
dependencies = {}
worker_index = kwargs.get('worker_index', None)
for alias in connections:
connection = connections[alias]
database_name = 'test_%d_%s' % (worker_index,
connection.settings_dict['NAME'])
connection.settings_dict['TEST_NAME'] = database_name
item = test_databases.setdefault(
connection.creation.test_db_signature(),
(connection.settings_dict['NAME'], []))
item[1].append(alias)
if alias != DEFAULT_DB_ALIAS:
dependencies[alias] = connection.settings_dict.get(
'TEST_DEPENDENCIES', [DEFAULT_DB_ALIAS])
old_names = []
mirrors = []
for signature, (db_name,
aliases) in dependency_ordered(test_databases.items(),
dependencies):
connection = connections[aliases[0]]
old_names.append((connection, db_name, True))
test_db_name = connection.creation.create_test_db(
verbosity=0, autoclobber=not self.interactive)
for alias in aliases[1:]:
connection = connections[alias]
if db_name:
old_names.append((connection, db_name, False))
connection.settings_dict['NAME'] = test_db_name
else:
old_names.append((connection, db_name, True))
connection.creation.create_test_db(
verbosity=0, autoclobber=not self.interactive)
for alias, mirror_alias in mirrored_aliases.items():
mirrors.append((alias, connections[alias].settings_dict['NAME']))
connections[alias].settings_dict['NAME'] = connections[
mirror_alias].settings_dict['NAME']
return old_names, mirrors
def test_simple_dependencies(self):
raw = [
('s1', ('s1_db', ['alpha'])),
('s2', ('s2_db', ['bravo'])),
('s3', ('s3_db', ['charlie'])),
]
dependencies = {
'alpha': ['charlie'],
'bravo': ['charlie'],
}
ordered = simple.dependency_ordered(raw, dependencies=dependencies)
ordered_sigs = [sig for sig,value in ordered]
self.assertIn('s1', ordered_sigs)
self.assertIn('s2', ordered_sigs)
self.assertIn('s3', ordered_sigs)
self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s1'))
self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s2'))
def test_simple_dependencies(self):
raw = [
('s1', ('s1_db', ['alpha'])),
('s2', ('s2_db', ['bravo'])),
('s3', ('s3_db', ['charlie'])),
]
dependencies = {
'alpha': ['charlie'],
'bravo': ['charlie'],
}
ordered = simple.dependency_ordered(raw, dependencies=dependencies)
ordered_sigs = [sig for sig, value in ordered]
self.assertIn('s1', ordered_sigs)
self.assertIn('s2', ordered_sigs)
self.assertIn('s3', ordered_sigs)
self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s1'))
self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s2'))
def test_simple_dependencies(self):
raw = [
('s1', ['alpha']),
('s2', ['bravo']),
('s3', ['charlie']),
]
dependencies = {
'alpha': ['charlie'],
'bravo': ['charlie'],
}
ordered = simple.dependency_ordered(raw, dependencies=dependencies)
ordered_sigs = [sig for sig,aliases in ordered]
self.assertTrue('s1' in ordered_sigs)
self.assertTrue('s2' in ordered_sigs)
self.assertTrue('s3' in ordered_sigs)
self.assertTrue(ordered_sigs.index('s3') < ordered_sigs.index('s1'))
self.assertTrue(ordered_sigs.index('s3') < ordered_sigs.index('s2'))
def setup_databases_13(self, **kwargs):
# Taken from django.test.simple
from django.test.simple import dependency_ordered
mirrored_aliases = {}
test_databases = {}
dependencies = {}
worker_index = kwargs.get('worker_index', None)
for alias in connections:
connection = connections[alias]
database_name = 'test_%d_%s' % (worker_index, connection.settings_dict['NAME'])
connection.settings_dict['TEST_NAME'] = database_name
item = test_databases.setdefault(
connection.creation.test_db_signature(),
(connection.settings_dict['NAME'], [])
)
item[1].append(alias)
if alias != DEFAULT_DB_ALIAS:
dependencies[alias] = connection.settings_dict.get('TEST_DEPENDENCIES', [DEFAULT_DB_ALIAS])
old_names = []
mirrors = []
for signature, (db_name, aliases) in dependency_ordered(test_databases.items(), dependencies):
connection = connections[aliases[0]]
old_names.append((connection, db_name, True))
test_db_name = connection.creation.create_test_db(verbosity=0, autoclobber=not self.interactive)
for alias in aliases[1:]:
connection = connections[alias]
if db_name:
old_names.append((connection, db_name, False))
connection.settings_dict['NAME'] = test_db_name
else:
old_names.append((connection, db_name, True))
connection.creation.create_test_db(verbosity=0, autoclobber=not self.interactive)
for alias, mirror_alias in mirrored_aliases.items():
mirrors.append((alias, connections[alias].settings_dict['NAME']))
connections[alias].settings_dict['NAME'] = connections[mirror_alias].settings_dict['NAME']
return old_names, mirrors
def test_chained_dependencies(self):
raw = [
('s1', ('s1_db', ['alpha'])),
('s2', ('s2_db', ['bravo'])),
('s3', ('s3_db', ['charlie'])),
]
dependencies = {
'alpha': ['bravo'],
'bravo': ['charlie'],
}
ordered = simple.dependency_ordered(raw, dependencies=dependencies)
ordered_sigs = [sig for sig, value in ordered]
self.assertTrue('s1' in ordered_sigs)
self.assertTrue('s2' in ordered_sigs)
self.assertTrue('s3' in ordered_sigs)
# Explicit dependencies
self.assertTrue(ordered_sigs.index('s2') < ordered_sigs.index('s1'))
self.assertTrue(ordered_sigs.index('s3') < ordered_sigs.index('s2'))
# Implied dependencies
self.assertTrue(ordered_sigs.index('s3') < ordered_sigs.index('s1'))
def test_chained_dependencies(self):
raw = [
('s1', ('s1_db', ['alpha'])),
('s2', ('s2_db', ['bravo'])),
('s3', ('s3_db', ['charlie'])),
]
dependencies = {
'alpha': ['bravo'],
'bravo': ['charlie'],
}
ordered = simple.dependency_ordered(raw, dependencies=dependencies)
ordered_sigs = [sig for sig,value in ordered]
self.assertTrue('s1' in ordered_sigs)
self.assertTrue('s2' in ordered_sigs)
self.assertTrue('s3' in ordered_sigs)
# Explicit dependencies
self.assertTrue(ordered_sigs.index('s2') < ordered_sigs.index('s1'))
self.assertTrue(ordered_sigs.index('s3') < ordered_sigs.index('s2'))
# Implied dependencies
self.assertTrue(ordered_sigs.index('s3') < ordered_sigs.index('s1'))
def use_test_databases():
"""
Adapted from DjangoTestSuiteRunner.setup_databases
"""
# First pass -- work out which databases connections need to be switched
# and which ones are test mirrors or duplicate entries in DATABASES
mirrored_aliases = {}
test_databases = {}
dependencies = {}
for alias in connections:
connection = connections[alias]
test_mirror = connection.settings_dict.get('TEST_MIRROR')
if test_mirror:
# If the database is marked as a test mirror, save
# the alias.
mirrored_aliases[alias] = test_mirror
else:
# Store a tuple with DB parameters that uniquely identify it.
# If we have two aliases with the same values for that tuple,
# they will have the same test db name.
item = test_databases.setdefault(
connection.creation.test_db_signature(),
(connection.settings_dict['NAME'], []))
item[1].append(alias)
if 'TEST_DEPENDENCIES' in connection.settings_dict:
dependencies[alias] = (
connection.settings_dict['TEST_DEPENDENCIES'])
else:
if alias != DEFAULT_DB_ALIAS:
dependencies[alias] = connection.settings_dict.get(
'TEST_DEPENDENCIES', [DEFAULT_DB_ALIAS])
# Second pass -- switch the databases to use test db settings.
for signature, (db_name,
aliases) in dependency_ordered(test_databases.items(),
dependencies):
# get test db name from the first connection
connection = connections[aliases[0]]
for alias in aliases:
connection = connections[alias]
test_db_name = connection.creation._get_test_db_name()
# NOTE: if using sqlite for tests, be sure to specify a
# TEST_NAME / TEST:NAME with a real filename to avoid using
# in-memory db
if test_db_name == ':memory:':
# Django converts all sqlite test dbs to :memory: ...but
# they can't be shared between concurrent processes...
# in this case it also means our parent test run used an
# in-memory db that we can't share
warnings.warn(
"In-memory databases can't be shared between concurrent "
"test processes. "
"{parent} -> {test}".format(parent=db_name,
test=test_db_name))
# we are running late in Django life-cycle so it has already
# opened connections to default db, need to close and re-open
# against test db:
connection.close()
connection.settings_dict['NAME'] = test_db_name
connection.cursor()
for alias, mirror_alias in mirrored_aliases.items():
# we are running late in Django life-cycle so it has already
# opened connections to default db, need to close and re-open
# against test mirror db:
connection = connections[alias]
connection.close()
connection.settings_dict['NAME'] = (
connections[mirror_alias].settings_dict['NAME'])
connection.features = connections[mirror_alias].features
connection.cursor()
def setup_databases(self, **kwargs):
from django.db import connections, DEFAULT_DB_ALIAS
# First pass -- work out which databases actually need to be created,
# and which ones are test mirrors or duplicate entries in DATABASES
mirrored_aliases = {}
test_databases = {}
dependencies = {}
for alias in connections:
connection = connections[alias]
if connection.settings_dict['TEST_MIRROR']:
# If the database is marked as a test mirror, save
# the alias.
mirrored_aliases[alias] = connection.settings_dict[
'TEST_MIRROR']
else:
# Store the (engine, name) pair. If we have two aliases
# with the same pair, we only need to create the test database
# once.
test_databases.setdefault((
connection.settings_dict['HOST'],
connection.settings_dict['PORT'],
connection.settings_dict['ENGINE'],
connection.settings_dict['NAME'],
), []).append(alias)
if 'TEST_DEPENDENCIES' in connection.settings_dict:
dependencies[alias] = connection.settings_dict[
'TEST_DEPENDENCIES']
else:
if alias != 'default':
dependencies[alias] = connection.settings_dict.get(
'TEST_DEPENDENCIES', ['default'])
# Second pass -- actually create the databases.
old_names = []
mirrors = []
db_schemas = settings.DATABASE_CREATE_SCHEMAS
for (host, port, engine,
db_name), aliases in dependency_ordered(test_databases.items(),
dependencies):
# Actually create the database for the first connection
connection = connections[aliases[0]]
old_names.append((connection, db_name, True))
#test_db_name = connection.creation._create_test_db(self.verbosity, autoclobber=not self.interactive)
test_db_name = create_test_db(connection, self.verbosity,
not self.interactive)
#Create Tables Via Schema File
try:
schema_file = db_schemas[aliases[0]]
schema_string = ""
with open(schema_file) as fh:
schema_string = fh.read()
print "Building Tables For %s from %s" % (test_db_name,
schema_file)
cursor = connection.cursor()
connection.autocommit = True
cursor.execute(schema_string)
cursor.close()
except Exception, e:
sys.stderr.write(
"Got an loading the schema file database: %s\n" % e)
print "Tests Canceled"
sys.exit(1)
for alias in aliases[1:]:
connection = connections[alias]
if db_name:
old_names.append((connection, db_name, False))
connection.settings_dict['NAME'] = test_db_name
else:
# If settings_dict['NAME'] isn't defined, we have a backend where
# the name isn't important -- e.g., SQLite, which uses :memory:.
# Force create the database instead of assuming it's a duplicate.
old_names.append((connection, db_name, True))
connection.creation.create_test_db(
self.verbosity, autoclobber=not self.interactive)
def setup_databases(self, **kwargs):
from django.db import connections, DEFAULT_DB_ALIAS
# First pass -- work out which databases actually need to be created,
# and which ones are test mirrors or duplicate entries in DATABASES
mirrored_aliases = {}
test_databases = {}
dependencies = {}
for alias in connections:
connection = connections[alias]
if connection.settings_dict['TEST_MIRROR']:
# If the database is marked as a test mirror, save
# the alias.
mirrored_aliases[alias] = connection.settings_dict['TEST_MIRROR']
else:
# Store the (engine, name) pair. If we have two aliases
# with the same pair, we only need to create the test database
# once.
test_databases.setdefault((
connection.settings_dict['HOST'],
connection.settings_dict['PORT'],
connection.settings_dict['ENGINE'],
connection.settings_dict['NAME'],
), []).append(alias)
if 'TEST_DEPENDENCIES' in connection.settings_dict:
dependencies[alias] = connection.settings_dict['TEST_DEPENDENCIES']
else:
if alias != 'default':
dependencies[alias] = connection.settings_dict.get('TEST_DEPENDENCIES', ['default'])
# Second pass -- actually create the databases.
old_names = []
mirrors = []
db_schemas = settings.DATABASE_CREATE_SCHEMAS
for (host, port, engine, db_name), aliases in dependency_ordered(test_databases.items(), dependencies):
# Actually create the database for the first connection
connection = connections[aliases[0]]
old_names.append((connection, db_name, True))
#test_db_name = connection.creation._create_test_db(self.verbosity, autoclobber=not self.interactive)
test_db_name = create_test_db(connection, self.verbosity, not self.interactive)
#Create Tables Via Schema File
try:
schema_file = db_schemas[aliases[0]]
schema_string = ""
with open(schema_file) as fh:
schema_string = fh.read()
print "Building Tables For %s from %s" % (test_db_name, schema_file)
cursor = connection.cursor()
connection.autocommit = True
cursor.execute(schema_string)
cursor.close()
except Exception, e:
sys.stderr.write("Got an loading the schema file database: %s\n" % e)
print "Tests Canceled"
sys.exit(1)
for alias in aliases[1:]:
connection = connections[alias]
if db_name:
old_names.append((connection, db_name, False))
connection.settings_dict['NAME'] = test_db_name
else:
# If settings_dict['NAME'] isn't defined, we have a backend where
# the name isn't important -- e.g., SQLite, which uses :memory:.
# Force create the database instead of assuming it's a duplicate.
old_names.append((connection, db_name, True))
connection.creation.create_test_db(self.verbosity, autoclobber=not self.interactive)
def use_test_databases():
"""
Adapted from DjangoTestSuiteRunner.setup_databases
"""
# First pass -- work out which databases connections need to be switched
# and which ones are test mirrors or duplicate entries in DATABASES
mirrored_aliases = {}
test_databases = {}
dependencies = {}
for alias in connections:
connection = connections[alias]
test_mirror = connection.settings_dict.get('TEST_MIRROR')
if test_mirror:
# If the database is marked as a test mirror, save
# the alias.
mirrored_aliases[alias] = test_mirror
else:
# Store a tuple with DB parameters that uniquely identify it.
# If we have two aliases with the same values for that tuple,
# they will have the same test db name.
item = test_databases.setdefault(
connection.creation.test_db_signature(),
(connection.settings_dict['NAME'], [])
)
item[1].append(alias)
if 'TEST_DEPENDENCIES' in connection.settings_dict:
dependencies[alias] = (
connection.settings_dict['TEST_DEPENDENCIES'])
else:
if alias != DEFAULT_DB_ALIAS:
dependencies[alias] = connection.settings_dict.get(
'TEST_DEPENDENCIES', [DEFAULT_DB_ALIAS])
# Second pass -- switch the databases to use test db settings.
for signature, (db_name, aliases) in dependency_ordered(
test_databases.items(), dependencies):
# get test db name from the first connection
connection = connections[aliases[0]]
for alias in aliases:
connection = connections[alias]
test_db_name = connection.creation._get_test_db_name()
# NOTE: if using sqlite for tests, be sure to specify a
# TEST_NAME / TEST:NAME with a real filename to avoid using
# in-memory db
if test_db_name == ':memory:':
# Django converts all sqlite test dbs to :memory: ...but
# they can't be shared between concurrent processes...
# in this case it also means our parent test run used an
# in-memory db that we can't share
warnings.warn(
"In-memory databases can't be shared between concurrent "
"test processes. "
"{parent} -> {test}".format(parent=db_name, test=test_db_name)
)
# we are running late in Django life-cycle so it has already
# opened connections to default db, need to close and re-open
# against test db:
connection.close()
connection.settings_dict['NAME'] = test_db_name
connection.cursor()
for alias, mirror_alias in mirrored_aliases.items():
# we are running late in Django life-cycle so it has already
# opened connections to default db, need to close and re-open
# against test mirror db:
connection = connections[alias]
connection.close()
connection.settings_dict['NAME'] = (
connections[mirror_alias].settings_dict['NAME'])
connection.features = connections[mirror_alias].features
connection.cursor()
