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