def test_empty_default_database(self):
"""
Test that an empty default database in settings does not raise an ImproperlyConfigured
error when running a unit test that does not use a database.
"""
testcases.connections = db.ConnectionHandler({"default": {}})
connection = testcases.connections[db.utils.DEFAULT_DB_ALIAS]
self.assertEqual(connection.settings_dict["ENGINE"], "django.db.backends.dummy")
connections_support_transactions()
def test_empty_default_database(self):
"""
An empty default database in settings does not raise an ImproperlyConfigured
error when running a unit test that does not use a database.
"""
testcases.connections = db.ConnectionHandler({'default': {}})
connection = testcases.connections[db.utils.DEFAULT_DB_ALIAS]
self.assertEqual(connection.settings_dict['ENGINE'], 'django.db.backends.dummy')
connections_support_transactions()
def test_empty_default_database(self):
"""
An empty default database in settings does not raise an ImproperlyConfigured
error when running a unit test that does not use a database.
"""
tested_connections = db.ConnectionHandler({"default": {}})
with mock.patch("django.db.connections", new=tested_connections):
connection = tested_connections[db.utils.DEFAULT_DB_ALIAS]
self.assertEqual(connection.settings_dict["ENGINE"],
"django.db.backends.dummy")
connections_support_transactions()
def test_empty_default_database(self):
"""
Test that an empty default database in settings does not raise an ImproperlyConfigured
error when running a unit test that does not use a database.
"""
testcases.connections = db.ConnectionHandler({'default': {}})
connection = testcases.connections[db.utils.DEFAULT_DB_ALIAS]
self.assertEqual(connection.settings_dict['ENGINE'], 'django.db.backends.dummy')
try:
connections_support_transactions()
except Exception as e:
self.fail("connections_support_transactions() unexpectedly raised an error: %s" % e)
def test_transaction_support(self):
# Assert connections mocking is appropriately applied by preventing
# any attempts at calling create_test_db on the global connection
# objects.
for connection in db.connections.all():
create_test_db = mock.patch.object(
connection.creation,
'create_test_db',
side_effect=AssertionError("Global connection object shouldn't be manipulated.")
)
create_test_db.start()
self.addCleanup(create_test_db.stop)
for option_key, option_value in (
('NAME', ':memory:'), ('TEST', {'NAME': ':memory:'})):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.sqlite3',
option_key: option_value,
},
'other': {
'ENGINE': 'django.db.backends.sqlite3',
option_key: option_value,
},
})
with mock.patch('django.test.utils.connections', new=tested_connections):
other = tested_connections['other']
DiscoverRunner(verbosity=0).setup_databases()
msg = (
"DATABASES setting '%s' option set to sqlite3's ':memory:' value "
"shouldn't interfere with transaction support detection." % option_key
)
# Transaction support is properly initialized for the 'other' DB.
self.assertTrue(other.features.supports_transactions, msg)
# And all the DBs report that they support transactions.
self.assertTrue(connections_support_transactions(), msg)
def test_mydb(self, mydb):
if not connections_support_transactions():
pytest.skip("transactions required for this test")
# Check the fixture had access to the db
item = Item.objects.get(name="spam")
assert item
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 _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
})
def test_transaction_support(self):
"""Ticket #16329: sqlite3 in-memory test databases"""
old_db_connections = db.connections
for option_key, option_value in (
('NAME', ':memory:'), ('TEST', {'NAME': ':memory:'})):
try:
db.connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.sqlite3',
option_key: option_value,
},
'other': {
'ENGINE': 'django.db.backends.sqlite3',
option_key: option_value,
},
})
other = db.connections['other']
DiscoverRunner(verbosity=0).setup_databases()
msg = "DATABASES setting '%s' option set to sqlite3's ':memory:' value shouldn't interfere with transaction support detection." % option_key
# Transaction support should be properly initialized for the 'other' DB
self.assertTrue(other.features.supports_transactions, msg)
# And all the DBs should report that they support transactions
self.assertTrue(connections_support_transactions(), msg)
finally:
db.connections = old_db_connections
def test_transaction_support(self):
for option_key, option_value in (('NAME', ':memory:'), ('TEST', {
'NAME':
':memory:'
})):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.sqlite3',
option_key: option_value,
},
'other': {
'ENGINE': 'django.db.backends.sqlite3',
option_key: option_value,
},
})
with mock.patch('django.db.connections', new=tested_connections):
with mock.patch('django.test.testcases.connections',
new=tested_connections):
other = tested_connections['other']
DiscoverRunner(verbosity=0).setup_databases()
msg = (
"DATABASES setting '%s' option set to sqlite3's ':memory:' value "
"shouldn't interfere with transaction support detection."
% option_key)
# Transaction support should be properly initialized for the 'other' DB
self.assertTrue(other.features.supports_transactions, msg)
# And all the DBs should report that they support transactions
self.assertTrue(connections_support_transactions(), msg)
def test_transaction_support(self):
# Assert connections mocking is appropriately applied by preventing
# any attempts at calling create_test_db on the global connection
# objects.
for connection in db.connections.all():
create_test_db = mock.patch.object(
connection.creation,
'create_test_db',
side_effect=AssertionError("Global connection object shouldn't be manipulated.")
)
create_test_db.start()
self.addCleanup(create_test_db.stop)
for option_key, option_value in (
('NAME', ':memory:'), ('TEST', {'NAME': ':memory:'})):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.sqlite3',
option_key: option_value,
},
'other': {
'ENGINE': 'django.db.backends.sqlite3',
option_key: option_value,
},
})
with mock.patch('django.test.utils.connections', new=tested_connections):
other = tested_connections['other']
DiscoverRunner(verbosity=0).setup_databases()
msg = (
"DATABASES setting '%s' option set to sqlite3's ':memory:' value "
"shouldn't interfere with transaction support detection." % option_key
)
# Transaction support is properly initialized for the 'other' DB.
self.assertTrue(other.features.supports_transactions, msg)
# And all the DBs report that they support transactions.
self.assertTrue(connections_support_transactions(), msg)
def test_mydb(self, mydb):
if not connections_support_transactions():
pytest.skip("transactions required for this test")
# Check the fixture had access to the db
item = Item.objects.get(name="spam")
assert item
def test_transaction_support(self):
"""Ticket #16329: sqlite3 in-memory test databases"""
old_db_connections = db.connections
for option_key, option_value in (('NAME', ':memory:'), ('TEST', {
'NAME':
':memory:'
})):
try:
db.connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.sqlite3',
option_key: option_value,
},
'other': {
'ENGINE': 'django.db.backends.sqlite3',
option_key: option_value,
},
})
other = db.connections['other']
DiscoverRunner(verbosity=0).setup_databases()
msg = "DATABASES setting '%s' option set to sqlite3's ':memory:' value shouldn't interfere with transaction support detection." % option_key
# Transaction support should be properly initialized for the 'other' DB
self.assertTrue(other.features.supports_transactions, msg)
# And all the DBs should report that they support transactions
self.assertTrue(connections_support_transactions(), msg)
finally:
db.connections = old_db_connections
def _fixture_setup(self):
global loaded_fixtures
if not connections_support_transactions():
if hasattr(self, 'perma_fixtures'):
if not hasattr(self, 'fixtures'):
self.fixtures = self.perma_fixtures
else:
self.fixtures += self.perma_fixtures
return super(TestCase, self)._fixture_setup()
# 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:
if hasattr(self, 'perma_fixtures'):
fixtures = [ fixture for fixture in self.perma_fixtures if not fixture in loaded_fixtures ]
if fixtures:
call_command('loaddata', *fixtures, **{
'verbosity': 0,
'commit': False,
'database': db
})
loaded_fixtures += fixtures
super(TestCase, self)._fixture_setup()
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 = []
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()
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()
def test_transactions_enabled_via_reset_seq(
self,
django_db_reset_sequences: None,
) -> None:
if not connections_support_transactions():
pytest.skip("transactions required for this test")
assert not connection.in_atomic_block
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()
def _post_teardown(self):
if connections_support_transactions():
# If the test case has a multi_db=True flag, teardown all databases.
# Otherwise, just teardown default.
if getattr(self, 'multi_db', False):
databases = connections
else:
databases = [DEFAULT_DB_ALIAS]
restore_transaction_methods()
for db in databases:
transaction.rollback(using=db)
transaction.leave_transaction_management(using=db)
for connection in connections.all():
connection.close()
def _post_teardown(self):
if connections_support_transactions():
# If the test case has a multi_db=True flag, teardown all databases.
# Otherwise, just teardown default.
if getattr(self, 'multi_db', False):
databases = connections
else:
databases = [DEFAULT_DB_ALIAS]
restore_transaction_methods()
for db in databases:
transaction.rollback(using=db)
transaction.leave_transaction_management(using=db)
for connection in connections.all():
connection.close()
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()
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()
def test_transaction_support(self):
"""Ticket #16329: sqlite3 in-memory test databases"""
for option_key, option_value in (("NAME", ":memory:"), ("TEST", {"NAME": ":memory:"})):
tested_connections = db.ConnectionHandler(
{
"default": {"ENGINE": "django.db.backends.sqlite3", option_key: option_value},
"other": {"ENGINE": "django.db.backends.sqlite3", option_key: option_value},
}
)
with mock.patch("django.db.connections", new=tested_connections):
with mock.patch("django.test.testcases.connections", new=tested_connections):
other = tested_connections["other"]
DiscoverRunner(verbosity=0).setup_databases()
msg = (
"DATABASES setting '%s' option set to sqlite3's ':memory:' value "
"shouldn't interfere with transaction support detection." % option_key
)
# Transaction support should be properly initialized for the 'other' DB
self.assertTrue(other.features.supports_transactions, msg)
# And all the DBs should report that they support transactions
self.assertTrue(connections_support_transactions(), msg)
def setUpClass(cls):
super(TestCase, cls).setUpClass()
if not connections_support_transactions():
return
cls.cls_atomics = cls._enter_atomics()
if cls.fixtures:
for db_name in cls._databases_names(include_mirrors=False):
try:
call_command('loaddatabulk', *cls.fixtures, **{
'verbosity': 0,
'commit': False,
'database': db_name,
})
except Exception:
cls._rollback_atomics(cls.cls_atomics)
raise
try:
cls.setUpTestData()
except Exception:
cls._rollback_atomics(cls.cls_atomics)
raise
def test_transaction_support(self):
"""Ticket #16329: sqlite3 in-memory test databases"""
old_db_connections = db.connections
for option in ("NAME", "TEST_NAME"):
try:
db.connections = db.ConnectionHandler(
{
"default": {"ENGINE": "django.db.backends.sqlite3", option: ":memory:"},
"other": {"ENGINE": "django.db.backends.sqlite3", option: ":memory:"},
}
)
other = db.connections["other"]
DjangoTestSuiteRunner(verbosity=0).setup_databases()
msg = (
"DATABASES setting '%s' option set to sqlite3's ':memory:' value shouldn't interfere with transaction support detection."
% option
)
# Transaction support should be properly initialised for the 'other' DB
self.assertTrue(other.features.supports_transactions, msg)
# And all the DBs should report that they support transactions
self.assertTrue(connections_support_transactions(), msg)
finally:
db.connections = old_db_connections
def setUpClass(cls):
super(TestCase, cls).setUpClass()
if not connections_support_transactions():
return
cls.cls_atomics = cls._enter_atomics()
if cls.fixtures:
for db_name in cls._databases_names(include_mirrors=False):
try:
call_command(
'loaddatabulk', *cls.fixtures, **{
'verbosity': 0,
'commit': False,
'database': db_name,
})
except Exception:
cls._rollback_atomics(cls.cls_atomics)
raise
try:
cls.setUpTestData()
except Exception:
cls._rollback_atomics(cls.cls_atomics)
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 = []
def test_transactions_disabled_explicit(self):
if not connections_support_transactions():
pytest.skip('transactions required for this test')
assert noop_transactions()
def _end_test_transaction():
restore_transaction_methods()
if connections_support_transactions():
transaction.rollback(using='default')
transaction.leave_transaction_management(using='default')
def test_transactions_enabled_via_reset_seq(
self, django_db_reset_sequences):
if not connections_support_transactions():
pytest.skip('transactions required for this test')
assert not connection.in_atomic_block
def test_transactions_disabled(self, db):
if not connections_support_transactions():
pytest.skip('transactions required for this test')
assert noop_transactions()
def test_transactions_disabled_explicit(self):
if not connections_support_transactions():
pytest.skip('transactions required for this test')
assert connection.in_atomic_block
def test_transactions_enabled(self, transactional_db):
if not connections_support_transactions():
pytest.skip('transactions required for this test')
assert not connection.in_atomic_block
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
"""
worsk exactly as per normal test
but only creates the test_db if it doesn't yet exist
and does not destroy it when done
tables are flushed and fixtures loaded between tests as per usual
but if your schema has not changed then this saves significant amounts of time
and speeds up the test cycle
Run the unit tests for all the test labels in the provided list.
Labels must be of the form:
- app.TestClass.test_method
Run a single specific test method
- app.TestClass
Run all the test methods in a given class
- app
Search for doctests and unittests in the named application.
When looking for tests, the test runner will look in the models and
tests modules for the application.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
setup_test_environment()
settings.DEBUG = False
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = apps.get_app(label)
suite.addTest(build_suite(app))
else:
for app in apps.get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
suite = reorder_suite(suite, (TestCase, ))
old_name = settings.DATABASES['default']['NAME']
# Everything up to here is from django.test.simple
from django.db.backends import creation
from django.db import connection, DatabaseError
if settings.DATABASES['default']['TEST_NAME']:
settings.DATABASES['default']['NAME'] = settings.DATABASES['default'][
'TEST_NAME']
else:
settings.DATABASES['default'][
'NAME'] = creation.TEST_DATABASE_PREFIX + settings.DATABASES[
'default']['NAME']
connection.settings_dict["DATABASE_NAME"] = settings.DATABASES['default'][
'NAME']
# does test db exist already ?
try:
if settings.DATABASES['default']['ENGINE'] == 'sqlite3':
if not os.path.exists(settings.DATABASES['default']['NAME']):
raise DatabaseError
cursor = connection.cursor()
except Exception:
# db does not exist
# juggling ! create_test_db switches the DATABASE_NAME to the TEST_DATABASE_NAME
settings.DATABASES['default']['NAME'] = old_name
connection.settings_dict["DATABASE_NAME"] = old_name
connection.creation.create_test_db(verbosity, autoclobber=True)
else:
connection.close()
settings.DATABASES['default'][
'SUPPORTS_TRANSACTIONS'] = connections_support_transactions()
result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
# Since we don't call destory_test_db, we need to set the db name back.
settings.DATABASES['default']['NAME'] = old_name
connection.settings_dict["DATABASE_NAME"] = old_name
teardown_test_environment()
return len(result.failures) + len(result.errors)
def test_transactions(self, live_server):
if not connections_support_transactions():
pytest.skip('transactions required for this test')
assert not noop_transactions()
def _end_test_transaction():
restore_transaction_methods()
if connections_support_transactions():
transaction.rollback(using='default')
transaction.leave_transaction_management(using='default')
def test_transactions_disabled_explicit(self):
if not connections_support_transactions():
pytest.skip("transactions required for this test")
assert connection.in_atomic_block
def test_transactions_enabled(self, transactional_db):
if not connections_support_transactions():
pytest.skip("transactions required for this test")
assert not noop_transactions()
def test_transactions_disabled_explicit(self):
if not connections_support_transactions():
pytest.skip("transactions required for this test")
assert noop_transactions()
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
"""
worsk exactly as per normal test
but only creates the test_db if it doesn't yet exist
and does not destroy it when done
tables are flushed and fixtures loaded between tests as per usual
but if your schema has not changed then this saves significant amounts of time
and speeds up the test cycle
Run the unit tests for all the test labels in the provided list.
Labels must be of the form:
- app.TestClass.test_method
Run a single specific test method
- app.TestClass
Run all the test methods in a given class
- app
Search for doctests and unittests in the named application.
When looking for tests, the test runner will look in the models and
tests modules for the application.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
setup_test_environment()
settings.DEBUG = False
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
suite = reorder_suite(suite, (TestCase,))
old_name = settings.DATABASES['default']['NAME']
###Everything up to here is from django.test.simple
from django.db.backends import creation
from django.db import connection, DatabaseError
if settings.DATABASES['default']['TEST_NAME']:
settings.DATABASES['default']['NAME'] = settings.DATABASES['default']['TEST_NAME']
else:
settings.DATABASES['default']['NAME'] = creation.TEST_DATABASE_PREFIX + settings.DATABASES['default']['NAME']
connection.settings_dict["DATABASE_NAME"] = settings.DATABASES['default']['NAME']
# does test db exist already ?
try:
if settings.DATABASES['default']['ENGINE'] == 'sqlite3':
if not os.path.exists(settings.DATABASES['default']['NAME']):
raise DatabaseError
cursor = connection.cursor()
except Exception:
# db does not exist
# juggling ! create_test_db switches the DATABASE_NAME to the TEST_DATABASE_NAME
settings.DATABASES['default']['NAME'] = old_name
connection.settings_dict["DATABASE_NAME"] = old_name
connection.creation.create_test_db(verbosity, autoclobber=True)
else:
connection.close()
settings.DATABASES['default']['SUPPORTS_TRANSACTIONS'] = connections_support_transactions()
result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
#Since we don't call destory_test_db, we need to set the db name back.
settings.DATABASES['default']['NAME'] = old_name
connection.settings_dict["DATABASE_NAME"] = old_name
teardown_test_environment()
return len(result.failures) + len(result.errors)
def test_transactions_disabled(self, db: None) -> None:
if not connections_support_transactions():
pytest.skip("transactions required for this test")
assert connection.in_atomic_block
def test_transactions(self, live_server):
if not connections_support_transactions():
pytest.skip('transactions required for this test')
assert not noop_transactions()
def test_transactions_enabled(self, transactional_db):
if not connections_support_transactions():
pytest.skip("transactions required for this test")
assert not connection.in_atomic_block
def test_transactions_enabled(self, transactional_db):
if not connections_support_transactions():
pytest.skip('transactions required for this test')
assert not noop_transactions()
def test_transactions_disabled(self, db):
if not connections_support_transactions():
pytest.skip('transactions required for this test')
assert connection.in_atomic_block
def test_transactions(self, live_server):
if not connections_support_transactions():
pytest.skip("transactions required for this test")
assert not connection.in_atomic_block
