def handle(self, *args, **options):
from django.test.runner import DiscoverRunner as TestRunner
test_runner = TestRunner(interactive=False)
test_runner.setup_databases()
test_runner.setup_test_environment()
if is_clickhouse_enabled():
from infi.clickhouse_orm import Database # type: ignore
from posthog.settings import (
CLICKHOUSE_DATABASE,
CLICKHOUSE_HTTP_URL,
CLICKHOUSE_PASSWORD,
CLICKHOUSE_REPLICATION,
CLICKHOUSE_USER,
CLICKHOUSE_VERIFY,
)
database = Database(
CLICKHOUSE_DATABASE,
db_url=CLICKHOUSE_HTTP_URL,
username=CLICKHOUSE_USER,
password=CLICKHOUSE_PASSWORD,
verify_ssl_cert=CLICKHOUSE_VERIFY,
)
try:
database.create_database()
except:
pass
database.migrate("ee.clickhouse.migrations",
replicated=CLICKHOUSE_REPLICATION)
def setup():
global test_runner
global old_config
try:
# DjangoTestSuiteRunner was deprecated in django 1.8:
# https://docs.djangoproject.com/en/1.8/internals/deprecation/#deprecation-removed-in-1-8
from django.test.runner import DiscoverRunner as TestSuiteRunner
except ImportError:
from django.test.simple import DjangoTestSuiteRunner as TestSuiteRunner
test_runner = TestSuiteRunner()
test_runner.setup_test_environment()
test_runner.setup_databases()
def setup():
global test_runner
global old_config
test_runner = DiscoverRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
class DjangoAutoTestSuite(unittest.TestSuite):
"""
This test suite configures django settings (which should be in test_settings.py), and starts a test runner.
It allows us to run the django tests with setup.py test.
"""
def __init__(self, *args, **kwargs):
self._configure()
self.test_runner = DiscoverRunner()
tests = self.test_runner.build_suite()
super(DjangoAutoTestSuite, self).__init__(tests=tests, *args, **kwargs)
self.test_runner.setup_test_environment()
self.test_dbs = self.test_runner.setup_databases()
def _configure(self):
test_settings = importlib.import_module("test_settings")
setting_attrs = {
attr: getattr(test_settings, attr)
for attr in dir(test_settings)
if "__" not in attr
}
if not django.conf.settings.configured:
django.conf.settings.configure(**setting_attrs)
django.setup()
def run(self, result_obj, *args, **kwargs):
result = super(DjangoAutoTestSuite, self).run(result_obj, *args, **kwargs)
self.test_runner.teardown_databases(self.test_dbs)
self.test_runner.teardown_test_environment()
return result
class SetupDatabasesTests(unittest.TestCase):
def setUp(self):
self.runner_instance = DiscoverRunner(verbosity=0)
def test_setup_aliased_databases(self):
tested_connections = db.ConnectionHandler(
{
"default": {"ENGINE": "django.db.backends.dummy", "NAME": "dbname"},
"other": {"ENGINE": "django.db.backends.dummy", "NAME": "dbname"},
}
)
with mock.patch("django.db.backends.dummy.base.DatabaseWrapper.creation_class") as mocked_db_creation:
with mock.patch("django.test.utils.connections", new=tested_connections):
old_config = self.runner_instance.setup_databases()
self.runner_instance.teardown_databases(old_config)
mocked_db_creation.return_value.destroy_test_db.assert_called_once_with("dbname", 0, False)
def test_destroy_test_db_restores_db_name(self):
tested_connections = db.ConnectionHandler(
{"default": {"ENGINE": settings.DATABASES[db.DEFAULT_DB_ALIAS]["ENGINE"], "NAME": "xxx_test_database"}}
)
# Using the real current name as old_name to not mess with the test suite.
old_name = settings.DATABASES[db.DEFAULT_DB_ALIAS]["NAME"]
with mock.patch("django.db.connections", new=tested_connections):
tested_connections["default"].creation.destroy_test_db(old_name, verbosity=0, keepdb=True)
self.assertEqual(tested_connections["default"].settings_dict["NAME"], old_name)
def test_serialization(self):
tested_connections = db.ConnectionHandler({"default": {"ENGINE": "django.db.backends.dummy"}})
with mock.patch("django.db.backends.dummy.base.DatabaseWrapper.creation_class") as mocked_db_creation:
with mock.patch("django.test.utils.connections", new=tested_connections):
self.runner_instance.setup_databases()
mocked_db_creation.return_value.create_test_db.assert_called_once_with(
verbosity=0, autoclobber=False, serialize=True, keepdb=False
)
def test_serialized_off(self):
tested_connections = db.ConnectionHandler(
{"default": {"ENGINE": "django.db.backends.dummy", "TEST": {"SERIALIZE": False}}}
)
with mock.patch("django.db.backends.dummy.base.DatabaseWrapper.creation_class") as mocked_db_creation:
with mock.patch("django.test.utils.connections", new=tested_connections):
self.runner_instance.setup_databases()
mocked_db_creation.return_value.create_test_db.assert_called_once_with(
verbosity=0, autoclobber=False, serialize=False, keepdb=False
)
def setUpModule():
django_test_utils.setup_test_environment()
runner = DjangoTestSuiteRunner()
runner_state = runner.setup_databases()
test_state.update({
'runner': runner,
'runner_state': runner_state,
})
def setUpModule():
django_test_utils.setup_test_environment()
runner = DjangoTestSuiteRunner()
runner_state = runner.setup_databases()
test_state.update({
'runner': runner,
'runner_state': runner_state,
})
def setUpModule():
if django is None:
raise unittest.SkipTest(SKIPTEST_TEXT)
setup_test_environment()
global DJANGO_RUNNER
global DJANGO_RUNNER_STATE
DJANGO_RUNNER = DiscoverRunner()
DJANGO_RUNNER_STATE = DJANGO_RUNNER.setup_databases()
def setup():
from django.test.runner import DiscoverRunner
global test_runner
global old_config
test_runner = DiscoverRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def setup():
from django.test.runner import DiscoverRunner
global test_runner
global old_config
test_runner = DiscoverRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def test_setup_databases(self):
"""
Test that setup_databases() doesn't fail with dummy database backend.
"""
tested_connections = db.ConnectionHandler({})
with mock.patch("django.test.utils.connections", new=tested_connections):
runner_instance = DiscoverRunner(verbosity=0)
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
def test_setup_databases(self):
"""
setup_databases() doesn't fail with dummy database backend.
"""
tested_connections = db.ConnectionHandler({})
with mock.patch('django.test.utils.connections', new=tested_connections):
runner_instance = DiscoverRunner(verbosity=0)
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
def test_setup_aliased_default_database(self):
"""
Test that setup_datebases() doesn't fail when 'default' is aliased
"""
tested_connections = db.ConnectionHandler({"default": {"NAME": "dummy"}, "aliased": {"NAME": "dummy"}})
with mock.patch("django.test.utils.connections", new=tested_connections):
runner_instance = DiscoverRunner(verbosity=0)
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
def create_database(server):
"""
:param server:
:return:
"""
# assert_test_database()
world.test_runner = DiscoverRunner(interactive=False)
DiscoverRunner.setup_test_environment(world.test_runner)
world.create_db = DiscoverRunner.setup_databases(world.test_runner)
def setUpModule():
if django is None: # pragma: no cover
raise unittest.SkipTest("Django not installed")
django_test_utils.setup_test_environment()
runner = DjangoTestSuiteRunner()
runner_state = runner.setup_databases()
test_state.update({
'runner': runner,
'runner_state': runner_state,
})
def setup():
global test_runner
global old_config
try:
from django.test.runner import DiscoverRunner as TestRunner
except ImportError:
from django.test.simple import DjangoTestSuiteRunner as TestRunner
test_runner = TestRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def test_setup_aliased_default_database(self):
"""
setup_databases() doesn't fail when 'default' is aliased
"""
tested_connections = db.ConnectionHandler(
{"default": {"NAME": "dummy"}, "aliased": {"NAME": "dummy"}}
)
with mock.patch("django.test.utils.connections", new=tested_connections):
runner_instance = DiscoverRunner(verbosity=0)
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
def handle(self, *args, **options):
# Configure django environment
django_test_runner = DiscoverRunner()
django_test_runner.setup_test_environment()
old_config = django_test_runner.setup_databases()
# Run Behave tests
behave_main(args=sys.argv[2:])
# Teardown django environment
django_test_runner.teardown_databases(old_config)
django_test_runner.teardown_test_environment()
def handle(self, *args, **options):
# Configure django environment
django_test_runner = DiscoverRunner()
django_test_runner.setup_test_environment()
old_config = django_test_runner.setup_databases()
# Run Behave tests
behave_main(args=sys.argv[2:])
# Teardown django environment
django_test_runner.teardown_databases(old_config)
django_test_runner.teardown_test_environment()
def setup():
global test_runner
global old_config
try:
from django.test.runner import DiscoverRunner as TestRunner
except ImportError:
from django.test.simple import DjangoTestSuiteRunner as TestRunner
test_runner = TestRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def test_setup_databases(self):
"""
Test that setup_databases() doesn't fail with dummy database backend.
"""
tested_connections = db.ConnectionHandler({})
with mock.patch("django.test.runner.connections", new=tested_connections):
runner_instance = DiscoverRunner(verbosity=0)
try:
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
except Exception as e:
self.fail("setup_databases/teardown_databases unexpectedly raised " "an error: %s" % e)
def test_setup_aliased_default_database(self):
"""
Test that setup_datebases() doesn't fail when 'default' is aliased
"""
tested_connections = db.ConnectionHandler({"default": {"NAME": "dummy"}, "aliased": {"NAME": "dummy"}})
with mock.patch("django.test.runner.connections", new=tested_connections):
runner_instance = DiscoverRunner(verbosity=0)
try:
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
except Exception as e:
self.fail("setup_databases/teardown_databases unexpectedly raised " "an error: %s" % e)
def handle(self, *args, **options):
if not TEST:
raise ValueError(
"TEST environment variable needs to be set for this command to function"
)
from django.test.runner import DiscoverRunner as TestRunner
test_runner = TestRunner(interactive=False)
test_runner.setup_databases()
test_runner.setup_test_environment()
from infi.clickhouse_orm import Database
from posthog.settings import (
CLICKHOUSE_CLUSTER,
CLICKHOUSE_DATABASE,
CLICKHOUSE_HTTP_URL,
CLICKHOUSE_PASSWORD,
CLICKHOUSE_REPLICATION,
CLICKHOUSE_USER,
CLICKHOUSE_VERIFY,
)
database = Database(
CLICKHOUSE_DATABASE,
db_url=CLICKHOUSE_HTTP_URL,
username=CLICKHOUSE_USER,
password=CLICKHOUSE_PASSWORD,
cluster=CLICKHOUSE_CLUSTER,
verify_ssl_cert=CLICKHOUSE_VERIFY,
)
try:
database.create_database()
except:
pass
database.migrate("ee.clickhouse.migrations",
replicated=CLICKHOUSE_REPLICATION)
def setUpModule():
utils.setup_test_environment()
runner = DiscoverRunner()
runner_state = runner.setup_databases()
test_state["runner"] = runner
test_state["runner_state"] = runner_state
if os.path.exists(settings.MEDIA_ROOT):
return
os.makedirs(settings.MEDIA_ROOT)
def test_setup_databases(self):
"""
Test that setup_databases() doesn't fail with dummy database backend.
"""
tested_connections = db.ConnectionHandler({})
with mock.patch('django.test.runner.connections', new=tested_connections):
runner_instance = DiscoverRunner(verbosity=0)
try:
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
except Exception as e:
self.fail("setup_databases/teardown_databases unexpectedly raised "
"an error: %s" % e)
def setup():
global test_runner
global old_config
try:
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner()
except ImportError:
# Django 1.5 did not have the DiscoverRunner
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def setup():
global test_runner
global old_config
try:
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner()
except ImportError:
# Django 1.5 did not have the DiscoverRunner
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def setup():
global test_runner
global old_config
# If you want to support Django 1.5 and older, you need
# this try-except block.
try:
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner()
except ImportError:
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def test_setup_databases(self):
"""
Test that setup_databases() doesn't fail with dummy database backend.
"""
runner_instance = DiscoverRunner(verbosity=0)
old_db_connections = db.connections
try:
db.connections = db.ConnectionHandler({})
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
except Exception as e:
self.fail("setup_databases/teardown_databases unexpectedly raised "
"an error: %s" % e)
finally:
db.connections = old_db_connections
def setup():
global test_runner
global old_config
# If you want to support Django 1.5 and older, you need
# this try-except block.
try:
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner()
except ImportError:
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def test_setup_databases(self):
"""
Test that setup_databases() doesn't fail with dummy database backend.
"""
runner_instance = DiscoverRunner(verbosity=0)
old_db_connections = db.connections
try:
db.connections = db.ConnectionHandler({})
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
except Exception as e:
self.fail("setup_databases/teardown_databases unexpectedly raised "
"an error: %s" % e)
finally:
db.connections = old_db_connections
def setup():
global test_runner
global old_config
from ella.utils.installedapps import call_modules
try:
from django.test.runner import DiscoverRunner as TestRunner
except ImportError:
from django.test.simple import DjangoTestSuiteRunner as TestRunner
try:
django.setup()
except AttributeError:
pass
test_runner = TestRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
call_modules(('register', ))
def test_setup_aliased_default_database(self):
"""
setup_databases() doesn't fail when 'default' is aliased
"""
tested_connections = db.ConnectionHandler({
'default': {
'NAME': 'dummy'
},
'aliased': {
'NAME': 'dummy'
}
})
with mock.patch('django.test.utils.connections', new=tested_connections):
runner_instance = DiscoverRunner(verbosity=0)
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
def test_setup_aliased_default_database(self):
"""
setup_datebases() doesn't fail when 'default' is aliased
"""
tested_connections = db.ConnectionHandler({
'default': {
'NAME': 'dummy'
},
'aliased': {
'NAME': 'dummy'
}
})
with mock.patch('django.test.utils.connections', new=tested_connections):
runner_instance = DiscoverRunner(verbosity=0)
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
def _test_output(self, verbosity):
runner = DiscoverRunner(debug_sql=True, verbosity=0)
suite = runner.test_suite()
suite.addTest(self.FailingTest())
suite.addTest(self.ErrorTest())
suite.addTest(self.PassingTest())
old_config = runner.setup_databases()
stream = StringIO()
resultclass = runner.get_resultclass()
runner.test_runner(
verbosity=verbosity,
stream=stream,
resultclass=resultclass,
).run(suite)
runner.teardown_databases(old_config)
return stream.getvalue()
def test_setupclass_exception(self):
runner = DiscoverRunner(debug_sql=True, verbosity=0)
suite = runner.test_suite()
suite.addTest(self.ErrorSetUpTestDataTest())
old_config = runner.setup_databases()
stream = StringIO()
runner.test_runner(
verbosity=0,
stream=stream,
resultclass=runner.get_resultclass(),
).run(suite)
runner.teardown_databases(old_config)
output = stream.getvalue()
self.assertIn(
"ERROR: setUpClass "
"(test_runner.test_debug_sql.TestDebugSQL.ErrorSetUpTestDataTest)",
output,
)
def test_setup_aliased_default_database(self):
"""
Test that setup_datebases() doesn't fail when 'default' is aliased
"""
tested_connections = db.ConnectionHandler({
'default': {
'NAME': 'dummy'
},
'aliased': {
'NAME': 'dummy'
}
})
with mock.patch('django.test.runner.connections', new=tested_connections):
runner_instance = DiscoverRunner(verbosity=0)
try:
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
except Exception as e:
self.fail("setup_databases/teardown_databases unexpectedly raised "
"an error: %s" % e)
def test_setup_aliased_default_database(self):
"""
Test that setup_datebases() doesn't fail when 'default' is aliased
"""
runner_instance = DiscoverRunner(verbosity=0)
old_db_connections = db.connections
try:
db.connections = db.ConnectionHandler({
'default': {
'NAME': 'dummy'
},
'aliased': {
'NAME': 'dummy'
}
})
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
except Exception as e:
self.fail("setup_databases/teardown_databases unexpectedly raised "
"an error: %s" % e)
finally:
db.connections = old_db_connections
def setup():
try:
from elasticsearch import Elasticsearch, ElasticsearchException
except ImportError:
raise unittest.SkipTest("elasticsearch-py not installed.")
es = Elasticsearch(settings.HAYSTACK_CONNECTIONS['elasticsearch']['URL'])
try:
es.info()
except ElasticsearchException as e:
raise unittest.SkipTest(
"elasticsearch not running on %r" %
settings.HAYSTACK_CONNECTIONS['elasticsearch']['URL'], e)
global test_runner
global old_config
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def test_setup_aliased_default_database(self):
"""
Test that setup_datebases() doesn't fail when 'default' is aliased
"""
runner_instance = DiscoverRunner(verbosity=0)
old_db_connections = db.connections
try:
db.connections = db.ConnectionHandler({
'default': {
'NAME': 'dummy'
},
'aliased': {
'NAME': 'dummy'
}
})
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
except Exception as e:
self.fail("setup_databases/teardown_databases unexpectedly raised "
"an error: %s" % e)
finally:
db.connections = old_db_connections
if __name__ == '__main__':
# Initialize app in Django 1.7 and above
setup()
# Log memcache errors to console
from django_pylibmc.memcached import log
handler = logging.StreamHandler()
handler.setLevel(logging.DEBUG)
log.addHandler(handler)
# Test that the cache is working at all
from django.core.cache import cache
assert cache
test_val = 'The test passed'
assert cache.set('test', test_val), "Could not set cache value"
cache_val = cache.get('test')
assert cache_val == test_val, "Could not get from cache"
# Ignore memcache errors during tests
handler.setLevel(logging.CRITICAL)
# Run the tests
runner = Runner()
try:
old_config = runner.setup_databases()
unittest.main()
finally:
runner.teardown_databases(old_config)
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
'LOCATION': 'localhost',
'OPTIONS': {
'MAX_ENTRIES': 2 ** 32,
},
},
},
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'ormcache',
'tests.testapp',
),
MIDDLEWARE_CLASSES=('django.middleware.common.CommonMiddleware',),
)
if django.VERSION[:2] >= (1, 7):
django.setup()
# Run tests
from django.test.runner import DiscoverRunner # noqa
test_runner = DiscoverRunner(verbosity=1)
test_runner.setup_databases()
failures = test_runner.run_tests(['tests', ])
if failures:
sys.exit(failures)
class DjangoPlugin(Fixtures):
def __init__(self, config):
self.config = config
self.check_markers()
self.configure()
self.original_connection_close = {}
try:
self.live_server_class = import_module(config.option.liveserver_class)
except ImportError:
liveserver_class = config.option.liveserver_class.split(".")
self.live_server_class = getattr(import_module(".".join(liveserver_class[:-1])), liveserver_class[-1])
def check_markers(self):
self.skip_trans = False
if "not transaction" in self.config.option.markexpr or self.config.option.skip_trans:
self.skip_trans = True
def configure(self):
self.runner = DiscoverRunner(interactive=False, verbosity=self.config.option.verbose)
self.runner.setup_test_environment()
management.get_commands() # load all commands first
is_sqlite = settings.DATABASES.get("default", {}).get("ENGINE", "").endswith("sqlite3")
wrap_database()
db_postfix = getattr(self.config, "slaveinput", {}).get("slaveid", "")
monkey_patch_creation_for_db_reuse(db_postfix if not is_sqlite else None, force=self.config.option.create_db)
migrate_db = self.config.option.migrate or self.config.option.create_db
can_migrate = "south" in settings.INSTALLED_APPS
if can_migrate:
from south.management.commands import patch_for_test_db_setup
patch_for_test_db_setup()
try:
self.runner.setup_databases()
if migrate_db and can_migrate:
management.call_command("migrate", verbosity=self.config.option.verbose)
except Exception:
raise pytest.UsageError(sys.exc_info()[1])
def pytest_pycollect_makemodule(self, path, parent):
return Module(path, parent)
@pytest.mark.tryfirst # or trylast as it was ?
def pytest_sessionstart(self, session):
# turn off debug toolbar to speed up testing
middlewares = []
for mid in settings.MIDDLEWARE_CLASSES:
if not mid.startswith("debug_toolbar"):
middlewares.append(mid)
settings.MIDDLEWARE_CLASSES = middlewares
for db in connections:
conn = connections[db]
conn.set_autocommit(False, force_begin_transaction_with_broken_autocommit=True)
conn.in_atomic_block = True
self.original_connection_close[db] = conn.close
conn.close = nop
def pytest_sessionfinish(self, session):
self.runner.teardown_test_environment()
for db in connections:
connections[db].in_atomic_block = False
transaction.rollback(using=db)
connections[db].in_atomic_block = True
if self.original_connection_close:
connections[db].close = self.original_connection_close[db]
@pytest.mark.trylast
def pytest_collection_modifyitems(self, items):
trans_items = []
non_trans = []
for index, item in enumerate(items):
if item.module.has_transactions:
trans_items.append(item)
else:
non_trans.append(item)
sorted_trans = []
for module, iterator in groupby(trans_items[:], lambda x: x.module):
for item, it in groupby(iterator, lambda x: x.cls and is_transaction_test(x.cls)):
sorted_trans.extend(it)
sorted_by_modules = non_trans + sorted_trans
items[:] = sorted_by_modules
def restore_database(self, item, nextitem):
for db in connections:
management.call_command("flush", verbosity=0, interactive=False, database=db)
all(i.setup() for i in item.listchain())
def pytest_runtest_protocol(self, item, nextitem):
"""Clear database if previous test item was from different module and it
was TransactionTestCase. then run setup on all ascending modules
"""
if item.cls is not None and is_transaction_test(item.cls):
if nextitem is None or nextitem.module != item.module:
if nextitem is not None:
item._request.addfinalizer(lambda: self.restore_database(item, nextitem))
@pytest.mark.tryfirst
def pytest_pycollect_makeitem(self, collector, name, obj):
"""Shadow builtin unittest makeitem with patched class and function
"""
try:
isunit = issubclass(obj, unittest.TestCase)
except KeyboardInterrupt:
raise
except Exception:
pass
else:
if isunit:
return SUnitTestCase(name, parent=collector)
@pytest.mark.tryfirst
def pytest_runtest_setup(self, item):
if "transaction" in item.keywords and self.skip_trans:
pytest.skip("excluding transaction test")
def pytest_runtest_call(self, item, __multicall__):
return __multicall__.execute()
class TestUpdateDBPipeline(unittest.TestCase):
def setUp(self):
self.dr = DiscoverRunner()
self.old_config = self.dr.setup_databases()
self.updatedb = UpdateDBPipeline(
images_store='tests/fixtures/images')
source = Source.objects.create(
name='source',
spider='spider',
url='http://example.com'
)
SourceLanguage.objects.create(
language='EN',
source=source
)
self.spider = Spider()
self.spider.name = 'Spider'
def tearDown(self):
self.dr.teardown_databases(self.old_config)
def test_update_relation(self):
source = Source.objects.get(spider='spider')
names = ['g1', 'g2', 'g3']
items = [{'name': i} for i in names]
n, u, d = self.updatedb._update_relation(source, 'genre_set',
'name', items,
self.updatedb._update_name)
self.assertEqual(n, set(names))
self.assertEqual(u, set())
self.assertEqual(d, set())
names = ['g2', 'g3', 'g4']
items = [{'name': i} for i in names]
n, u, d = self.updatedb._update_relation(source, 'genre_set',
'name', items,
self.updatedb._update_name)
self.assertEqual(n, set(['g4']))
self.assertEqual(u, set(['g2', 'g3']))
self.assertEqual(d, set(['g1']))
def test_update_genres(self):
names = ['g1', 'g2', 'g3']
genres = scraper.items.Genres(
names=names
)
self.updatedb.update_genres(genres, self.spider)
self.assertEqual({o.name for o in Genre.objects.all()}, set(names))
names = ['g2', 'g3', 'g4']
genres = scraper.items.Genres(
names=names
)
self.updatedb.update_genres(genres, self.spider)
self.assertEqual({o.name for o in Genre.objects.all()}, set(names))
def test_update_collection(self):
names = ['g1', 'g2', 'g3']
genres = scraper.items.Genres(
names=names
)
self.updatedb.update_genres(genres, self.spider)
manga = scraper.items.Manga(
name='Manga1',
alt_name=['Manga1', 'MangaA'],
author='Author',
artist='Artist',
reading_direction='LR',
status='O',
genres=['g1', 'g2'],
rank=1,
rank_order='ASC',
description='Description',
image_urls=['http://manga1.org/images/height-large.jpg'],
images=[{
'url': 'http://manga1.org/images/height-large.jpg',
'path': 'height-large.jpg',
'checksum': None
}],
issues=[
scraper.items.Issue(
name='issue1',
number='1',
order=1,
language='EN',
release=datetime.date(year=2014, month=1, day=1),
url='http://manga1.org/issue1'),
scraper.items.Issue(
name='issue2',
number='2',
order=2,
language='EN',
release=datetime.date(year=2014, month=1, day=2),
url='http://manga1.org/issue2'),
],
url='http://manga1.org')
self.updatedb.update_collection(manga, self.spider)
self.assertEqual(len(Manga.objects.all()), 1)
m = Manga.objects.all()[0]
self.assertEqual(m.name, 'Manga1')
self.assertEqual(len(m.altname_set.all()), 2)
self.assertEqual({o.name for o in m.altname_set.all()},
set(('Manga1', 'MangaA')))
self.assertEqual(m.author, 'Author')
self.assertEqual(m.artist, 'Artist')
self.assertEqual(m.reading_direction, 'LR')
self.assertEqual(m.status, 'O')
self.assertEqual(len(m.genres.all()), 2)
self.assertEqual({o.name for o in m.genres.all()},
set(('g1', 'g2')))
self.assertEqual(m.rank, 1.0)
self.assertEqual(m.rank_order, 'ASC')
self.assertEqual(m.description, 'Description')
self.assertEqual(len(m.issue_set.all()), 2)
i = m.issue_set.get(name='issue1')
self.assertEqual(i.name, 'issue1')
self.assertEqual(i.number, '1')
self.assertEqual(i.order, 1)
self.assertEqual(i.language, 'EN')
self.assertEqual(i.release, datetime.date(year=2014, month=1, day=1))
self.assertEqual(i.url, 'http://manga1.org/issue1')
i = m.issue_set.get(name='issue2')
self.assertEqual(i.name, 'issue2')
self.assertEqual(i.number, '2')
self.assertEqual(i.order, 2)
self.assertEqual(i.language, 'EN')
self.assertEqual(i.release, datetime.date(year=2014, month=1, day=2))
self.assertEqual(i.url, 'http://manga1.org/issue2')
# Remove the image
m.cover.delete()
def test_update2_collection(self):
names = ['g1', 'g2', 'g3']
genres = scraper.items.Genres(
names=names
)
self.updatedb.update_genres(genres, self.spider)
manga = scraper.items.Manga(
name='Manga1',
alt_name=['Manga1', 'MangaA'],
author='Author',
artist='Artist',
reading_direction='LR',
status='O',
genres=['g1', 'g2'],
rank=1,
rank_order='ASC',
description='Description',
image_urls=['http://manga1.org/images/height-large.jpg'],
images=[{
'url': 'http://manga1.org/images/height-large.jpg',
'path': 'height-large.jpg',
'checksum': None
}],
issues=[
scraper.items.Issue(
name='issue1',
number='1',
order=1,
language='EN',
release=datetime.date(year=2014, month=1, day=1),
url='http://manga1.org/issue1'),
scraper.items.Issue(
name='issue2',
number='2',
order=2,
language='EN',
release=datetime.date(year=2014, month=1, day=2),
url='http://manga1.org/issue2'),
],
url='http://manga1.org')
self.updatedb.update_collection(manga, self.spider)
# Add a new alt_name
manga['alt_name'].append('MangaB')
self.updatedb.update_collection(manga, self.spider)
m = Manga.objects.all()[0]
self.assertEqual(len(m.altname_set.all()), 3)
self.assertEqual({o.name for o in m.altname_set.all()},
set(('Manga1', 'MangaA', 'MangaB')))
# Remove an alt_name
del manga['alt_name'][0]
self.updatedb.update_collection(manga, self.spider)
m = Manga.objects.all()[0]
self.assertEqual(len(m.altname_set.all()), 2)
self.assertEqual({o.name for o in m.altname_set.all()},
set(('MangaA', 'MangaB')))
# Change author
manga['author'] = 'Another Author'
self.updatedb.update_collection(manga, self.spider)
# Change status
manga['status'] = 'C'
self.updatedb.update_collection(manga, self.spider)
# Add a new genre
manga['genres'].append('g3')
self.updatedb.update_collection(manga, self.spider)
m = Manga.objects.all()[0]
self.assertEqual(len(m.genres.all()), 3)
self.assertEqual({o.name for o in m.genres.all()},
set(('g1', 'g2', 'g3')))
# Remove a genre
del manga['genres'][1]
self.updatedb.update_collection(manga, self.spider)
m = Manga.objects.all()[0]
self.assertEqual(len(m.genres.all()), 2)
self.assertEqual({o.name for o in m.genres.all()},
set(('g1', 'g3')))
# Add a new issue
manga['issues'].append(
scraper.items.Issue(
name='issue3',
number='3',
order=3,
language='EN',
release=datetime.date(year=2014, month=1, day=3),
url='http://manga1.org/issue3')
)
self.updatedb.update_collection(manga, self.spider)
m = Manga.objects.all()[0]
self.assertEqual(len(m.issue_set.all()), 3)
# Remove an issue
del manga['issues'][0]
self.updatedb.update_collection(manga, self.spider)
m = Manga.objects.all()[0]
self.assertEqual(len(m.issue_set.all()), 2)
# Check the final result
self.assertEqual(len(Manga.objects.all()), 1)
m = Manga.objects.all()[0]
self.assertEqual(m.name, 'Manga1')
self.assertEqual(len(m.altname_set.all()), 2)
self.assertEqual({o.name for o in m.altname_set.all()},
set(('MangaA', 'MangaB')))
self.assertEqual(m.author, 'Another Author')
self.assertEqual(m.artist, 'Artist')
self.assertEqual(m.reading_direction, 'LR')
self.assertEqual(m.status, 'C')
self.assertEqual(len(m.genres.all()), 2)
self.assertEqual({o.name for o in m.genres.all()},
set(('g1', 'g3')))
self.assertEqual(m.rank, 1.0)
self.assertEqual(m.rank_order, 'ASC')
self.assertEqual(m.description, 'Description')
self.assertEqual(len(m.issue_set.all()), 2)
i = m.issue_set.get(name='issue2')
self.assertEqual(i.name, 'issue2')
self.assertEqual(i.number, '2')
self.assertEqual(i.order, 2)
self.assertEqual(i.language, 'EN')
self.assertEqual(i.release, datetime.date(year=2014, month=1, day=2))
self.assertEqual(i.url, 'http://manga1.org/issue2')
i = m.issue_set.get(name='issue3')
self.assertEqual(i.name, 'issue3')
self.assertEqual(i.number, '3')
self.assertEqual(i.order, 3)
self.assertEqual(i.language, 'EN')
self.assertEqual(i.release, datetime.date(year=2014, month=1, day=3))
self.assertEqual(i.url, 'http://manga1.org/issue3')
# Remove the image
m.cover.delete()
def test_update_latest(self):
names = ['g1', 'g2', 'g3']
genres = scraper.items.Genres(
names=names
)
self.updatedb.update_genres(genres, self.spider)
manga = scraper.items.Manga(
name='Manga1',
alt_name=['Manga1', 'MangaA'],
author='Author',
artist='Artist',
reading_direction='LR',
status='O',
genres=['g1', 'g2'],
rank=1,
rank_order='ASC',
description='Description',
image_urls=['http://manga1.org/images/height-large.jpg'],
images=[{
'url': 'http://manga1.org/images/height-large.jpg',
'path': 'height-large.jpg',
'checksum': None
}],
issues=[
scraper.items.Issue(
name='issue1',
number='1',
order=1,
language='EN',
release=datetime.date(year=2014, month=1, day=1),
url='http://manga1.org/issue1'),
scraper.items.Issue(
name='issue2',
number='2',
order=2,
language='EN',
release=datetime.date(year=2014, month=1, day=2),
url='http://manga1.org/issue2'),
],
url='http://manga1.org')
self.updatedb.update_collection(manga, self.spider)
manga = scraper.items.Manga(
name='Manga1',
issues=[
scraper.items.Issue(
name='issue3',
number='3',
order=3,
language='EN',
release=datetime.date(year=2014, month=1, day=3),
url='http://manga1.org/issue3'),
scraper.items.Issue(
name='issue4',
number='4',
order=4,
language='EN',
release=datetime.date(year=2014, month=1, day=4),
url='http://manga1.org/issue4'),
],
url='http://manga1.org')
self.updatedb.update_latest(manga, self.spider)
self.assertEqual(len(Manga.objects.all()), 1)
m = Manga.objects.all()[0]
self.assertEqual(m.name, 'Manga1')
self.assertEqual(len(m.altname_set.all()), 2)
self.assertEqual({o.name for o in m.altname_set.all()},
set(('Manga1', 'MangaA')))
self.assertEqual(m.author, 'Author')
self.assertEqual(m.artist, 'Artist')
self.assertEqual(m.reading_direction, 'LR')
self.assertEqual(m.status, 'O')
self.assertEqual(len(m.genres.all()), 2)
self.assertEqual({o.name for o in m.genres.all()},
set(('g1', 'g2')))
self.assertEqual(m.rank, 1.0)
self.assertEqual(m.rank_order, 'ASC')
self.assertEqual(m.description, 'Description')
self.assertEqual(len(m.issue_set.all()), 4)
i = m.issue_set.get(name='issue1')
self.assertEqual(i.name, 'issue1')
self.assertEqual(i.number, '1')
self.assertEqual(i.order, 1)
self.assertEqual(i.language, 'EN')
self.assertEqual(i.release, datetime.date(year=2014, month=1, day=1))
self.assertEqual(i.url, 'http://manga1.org/issue1')
i = m.issue_set.get(name='issue2')
self.assertEqual(i.name, 'issue2')
self.assertEqual(i.number, '2')
self.assertEqual(i.order, 2)
self.assertEqual(i.language, 'EN')
self.assertEqual(i.release, datetime.date(year=2014, month=1, day=2))
self.assertEqual(i.url, 'http://manga1.org/issue2')
i = m.issue_set.get(name='issue3')
self.assertEqual(i.name, 'issue3')
self.assertEqual(i.number, '3')
self.assertEqual(i.order, 3)
self.assertEqual(i.language, 'EN')
self.assertEqual(i.release, datetime.date(year=2014, month=1, day=3))
self.assertEqual(i.url, 'http://manga1.org/issue3')
i = m.issue_set.get(name='issue4')
self.assertEqual(i.name, 'issue4')
self.assertEqual(i.number, '4')
self.assertEqual(i.order, 4)
self.assertEqual(i.language, 'EN')
self.assertEqual(i.release, datetime.date(year=2014, month=1, day=4))
self.assertEqual(i.url, 'http://manga1.org/issue4')
# Remove the image
m.cover.delete()
class SetupDatabasesTests(unittest.TestCase):
def setUp(self):
self._old_db_connections = db.connections
self._old_destroy_test_db = DatabaseCreation.destroy_test_db
self._old_create_test_db = DatabaseCreation.create_test_db
self.runner_instance = DiscoverRunner(verbosity=0)
def tearDown(self):
DatabaseCreation.create_test_db = self._old_create_test_db
DatabaseCreation.destroy_test_db = self._old_destroy_test_db
db.connections = self._old_db_connections
def test_setup_aliased_databases(self):
destroyed_names = []
DatabaseCreation.destroy_test_db = (
lambda self, old_database_name, verbosity=1, keepdb=False,
serialize=True: destroyed_names.append(old_database_name))
DatabaseCreation.create_test_db = (
lambda self, verbosity=1, autoclobber=False, keepdb=False,
serialize=True: self._get_test_db_name())
db.connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
},
'other': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
}
})
old_config = self.runner_instance.setup_databases()
self.runner_instance.teardown_databases(old_config)
self.assertEqual(destroyed_names.count('dbname'), 1)
def test_destroy_test_db_restores_db_name(self):
db.connections = db.ConnectionHandler({
'default': {
'ENGINE': settings.DATABASES[db.DEFAULT_DB_ALIAS]["ENGINE"],
'NAME': 'xxx_test_database',
},
})
# Using the real current name as old_name to not mess with the test suite.
old_name = settings.DATABASES[db.DEFAULT_DB_ALIAS]["NAME"]
db.connections['default'].creation.destroy_test_db(old_name,
verbosity=0,
keepdb=True)
self.assertEqual(db.connections['default'].settings_dict["NAME"],
old_name)
def test_serialization(self):
serialize = []
DatabaseCreation.create_test_db = (
lambda *args, **kwargs: serialize.append(kwargs.get('serialize')))
db.connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
},
})
self.runner_instance.setup_databases()
self.assertEqual(serialize, [True])
def test_serialized_off(self):
serialize = []
DatabaseCreation.create_test_db = (
lambda *args, **kwargs: serialize.append(kwargs.get('serialize')))
db.connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
'TEST': {
'SERIALIZE': False
},
},
})
self.runner_instance.setup_databases()
self.assertEqual(serialize, [False])
'LOCATION': 'unique'
},
'main_cache': {
'BACKEND': 'django.core.cache.backends.dummy.DummyCache',
}
},
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'cache_fallback',
'tests.testapp',
),
MIDDLEWARE_CLASSES=('django.middleware.common.CommonMiddleware', ),
)
if django.VERSION[:2] >= (1, 7):
django.setup()
# Run tests
from django.test.runner import DiscoverRunner # noqa
test_runner = DiscoverRunner(verbosity=1)
test_runner.setup_databases()
failures = test_runner.run_tests([
'tests',
])
if failures:
sys.exit(failures)
class SetupDatabasesTests(unittest.TestCase):
def setUp(self):
self.runner_instance = DiscoverRunner(verbosity=0)
def test_setup_aliased_databases(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
},
'other': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
}
})
with mock.patch('django.db.backends.dummy.base.DatabaseCreation') as mocked_db_creation:
with mock.patch('django.test.runner.connections', new=tested_connections):
old_config = self.runner_instance.setup_databases()
self.runner_instance.teardown_databases(old_config)
mocked_db_creation.return_value.destroy_test_db.assert_called_once_with('dbname', 0, False)
def test_destroy_test_db_restores_db_name(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': settings.DATABASES[db.DEFAULT_DB_ALIAS]["ENGINE"],
'NAME': 'xxx_test_database',
},
})
# Using the real current name as old_name to not mess with the test suite.
old_name = settings.DATABASES[db.DEFAULT_DB_ALIAS]["NAME"]
with mock.patch('django.db.connections', new=tested_connections):
tested_connections['default'].creation.destroy_test_db(old_name, verbosity=0, keepdb=True)
self.assertEqual(tested_connections['default'].settings_dict["NAME"], old_name)
def test_serialization(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
},
})
with mock.patch('django.db.backends.dummy.base.DatabaseCreation') as mocked_db_creation:
with mock.patch('django.test.runner.connections', new=tested_connections):
self.runner_instance.setup_databases()
mocked_db_creation.return_value.create_test_db.assert_called_once_with(
verbosity=0, autoclobber=False, serialize=True, keepdb=False
)
def test_serialized_off(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
'TEST': {'SERIALIZE': False},
},
})
with mock.patch('django.db.backends.dummy.base.DatabaseCreation') as mocked_db_creation:
with mock.patch('django.test.runner.connections', new=tested_connections):
self.runner_instance.setup_databases()
mocked_db_creation.return_value.create_test_db.assert_called_once_with(
verbosity=0, autoclobber=False, serialize=False, keepdb=False
)
class SetupDatabasesTests(unittest.TestCase):
def setUp(self):
self.runner_instance = DiscoverRunner(verbosity=0)
def test_setup_aliased_databases(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
},
'other': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
}
})
with mock.patch(
'django.db.backends.dummy.base.DatabaseWrapper.creation_class'
) as mocked_db_creation:
with mock.patch('django.test.utils.connections',
new=tested_connections):
old_config = self.runner_instance.setup_databases()
self.runner_instance.teardown_databases(old_config)
mocked_db_creation.return_value.destroy_test_db.assert_called_once_with(
'dbname', 0, False)
def test_destroy_test_db_restores_db_name(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': settings.DATABASES[db.DEFAULT_DB_ALIAS]["ENGINE"],
'NAME': 'xxx_test_database',
},
})
# Using the real current name as old_name to not mess with the test suite.
old_name = settings.DATABASES[db.DEFAULT_DB_ALIAS]["NAME"]
with mock.patch('django.db.connections', new=tested_connections):
tested_connections['default'].creation.destroy_test_db(old_name,
verbosity=0,
keepdb=True)
self.assertEqual(
tested_connections['default'].settings_dict["NAME"], old_name)
def test_serialization(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
},
})
with mock.patch(
'django.db.backends.dummy.base.DatabaseWrapper.creation_class'
) as mocked_db_creation:
with mock.patch('django.test.utils.connections',
new=tested_connections):
self.runner_instance.setup_databases()
mocked_db_creation.return_value.create_test_db.assert_called_once_with(
verbosity=0, autoclobber=False, serialize=True, keepdb=False)
def test_serialized_off(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
'TEST': {
'SERIALIZE': False
},
},
})
with mock.patch(
'django.db.backends.dummy.base.DatabaseWrapper.creation_class'
) as mocked_db_creation:
with mock.patch('django.test.utils.connections',
new=tested_connections):
self.runner_instance.setup_databases()
mocked_db_creation.return_value.create_test_db.assert_called_once_with(
verbosity=0, autoclobber=False, serialize=False, keepdb=False)
class SetupDatabasesTests(unittest.TestCase):
def setUp(self):
self._old_db_connections = db.connections
self._old_destroy_test_db = DatabaseCreation.destroy_test_db
self._old_create_test_db = DatabaseCreation.create_test_db
self.runner_instance = DiscoverRunner(verbosity=0)
def tearDown(self):
DatabaseCreation.create_test_db = self._old_create_test_db
DatabaseCreation.destroy_test_db = self._old_destroy_test_db
db.connections = self._old_db_connections
def test_setup_aliased_databases(self):
destroyed_names = []
DatabaseCreation.destroy_test_db = (
lambda self, old_database_name, verbosity=1, keepdb=False, serialize=True:
destroyed_names.append(old_database_name)
)
DatabaseCreation.create_test_db = (
lambda self, verbosity=1, autoclobber=False, keepdb=False, serialize=True:
self._get_test_db_name()
)
db.connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
},
'other': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
}
})
old_config = self.runner_instance.setup_databases()
self.runner_instance.teardown_databases(old_config)
self.assertEqual(destroyed_names.count('dbname'), 1)
def test_destroy_test_db_restores_db_name(self):
db.connections = db.ConnectionHandler({
'default': {
'ENGINE': settings.DATABASES[db.DEFAULT_DB_ALIAS]["ENGINE"],
'NAME': 'xxx_test_database',
},
})
# Using the real current name as old_name to not mess with the test suite.
old_name = settings.DATABASES[db.DEFAULT_DB_ALIAS]["NAME"]
db.connections['default'].creation.destroy_test_db(old_name, verbosity=0, keepdb=True)
self.assertEqual(db.connections['default'].settings_dict["NAME"], old_name)
def test_serialization(self):
serialize = []
DatabaseCreation.create_test_db = (
lambda *args, **kwargs: serialize.append(kwargs.get('serialize'))
)
db.connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
},
})
self.runner_instance.setup_databases()
self.assertEqual(serialize, [True])
def test_serialized_off(self):
serialize = []
DatabaseCreation.create_test_db = (
lambda *args, **kwargs: serialize.append(kwargs.get('serialize'))
)
db.connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
'TEST': {'SERIALIZE': False},
},
})
self.runner_instance.setup_databases()
self.assertEqual(serialize, [False])
class SetupDatabasesTests(SimpleTestCase):
def setUp(self):
self.runner_instance = DiscoverRunner(verbosity=0)
def test_setup_aliased_databases(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
},
'other': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
}
})
with mock.patch(
'django.db.backends.dummy.base.DatabaseWrapper.creation_class'
) as mocked_db_creation:
with mock.patch('django.test.utils.connections',
new=tested_connections):
old_config = self.runner_instance.setup_databases()
self.runner_instance.teardown_databases(old_config)
mocked_db_creation.return_value.destroy_test_db.assert_called_once_with(
'dbname', 0, False)
def test_setup_test_database_aliases(self):
"""
The default database must be the first because data migrations
use the default alias by default.
"""
tested_connections = db.ConnectionHandler({
'other': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
},
'default': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
}
})
with mock.patch('django.test.utils.connections',
new=tested_connections):
test_databases, _ = get_unique_databases_and_mirrors()
self.assertEqual(
test_databases,
{
('', '', 'django.db.backends.dummy', 'test_dbname'): (
'dbname',
['default', 'other'],
),
},
)
def test_destroy_test_db_restores_db_name(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': settings.DATABASES[db.DEFAULT_DB_ALIAS]["ENGINE"],
'NAME': 'xxx_test_database',
},
})
# Using the real current name as old_name to not mess with the test suite.
old_name = settings.DATABASES[db.DEFAULT_DB_ALIAS]["NAME"]
with mock.patch('django.db.connections', new=tested_connections):
tested_connections['default'].creation.destroy_test_db(old_name,
verbosity=0,
keepdb=True)
self.assertEqual(
tested_connections['default'].settings_dict["NAME"], old_name)
def test_serialization(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
},
})
with mock.patch(
'django.db.backends.dummy.base.DatabaseWrapper.creation_class'
) as mocked_db_creation:
with mock.patch('django.test.utils.connections',
new=tested_connections):
self.runner_instance.setup_databases()
mocked_db_creation.return_value.create_test_db.assert_called_once_with(
verbosity=0, autoclobber=False, serialize=True, keepdb=False)
def test_serialized_off(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
'TEST': {
'SERIALIZE': False
},
},
})
msg = (
'The SERIALIZE test database setting is deprecated as it can be '
'inferred from the TestCase/TransactionTestCase.databases that '
'enable the serialized_rollback feature.')
with mock.patch(
'django.db.backends.dummy.base.DatabaseWrapper.creation_class'
) as mocked_db_creation:
with mock.patch('django.test.utils.connections',
new=tested_connections):
with self.assertWarnsMessage(RemovedInDjango50Warning, msg):
self.runner_instance.setup_databases()
mocked_db_creation.return_value.create_test_db.assert_called_once_with(
verbosity=0, autoclobber=False, serialize=False, keepdb=False)
def pytest_configure(config):
from django.conf import settings
from django.test.runner import DiscoverRunner
settings.configure(
DEBUG_PROPAGATE_EXCEPTIONS=True,
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:'
}
},
SITE_ID=1,
SECRET_KEY='not very secret in tests',
USE_I18N=True,
USE_L10N=True,
STATIC_URL='/static/',
ROOT_URLCONF='tests.urls',
TEMPLATES=[
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'APP_DIRS': True,
'OPTIONS': {
"debug": True, # We want template errors to raise
}
},
],
MIDDLEWARE=(
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
),
INSTALLED_APPS=(
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.staticfiles',
'drf_magic',
'tests',
) + tuple(map(lambda x: f'{TEST_PREFIX}.{x}', test_apps)),
SWAGGER_SETTINGS={
'DEFAULT_GENERATOR_CLASS': 'drf_magic.docs.generators.VersionAgnosticSchemaGenerator',
'DEFAULT_AUTO_SCHEMA_CLASS': 'drf_magic.docs.schema.SmartSummaryAutoSchema',
},
YASG_SCHEMA={
'TITLE': 'Test Docs',
'VERSION': '0.1.0',
'DESCRIPTION_PATH': os.path.join(os.path.dirname(__file__), 'dummy_api_desc.md'),
},
PASSWORD_HASHERS=(
'django.contrib.auth.hashers.MD5PasswordHasher',
),
)
if config.getoption('--no-pkgroot'):
sys.path.pop(0)
# import drf_magic before pytest re-adds the package root directory.
import drf_magic
package_dir = os.path.join(os.getcwd(), 'drf_magic')
assert not drf_magic.__file__.startswith(package_dir)
# Manifest storage will raise an exception if static files are not present (ie, a packaging failure).
if config.getoption('--staticfiles'):
import drf_magic
settings.STATIC_ROOT = os.path.join(os.path.dirname(drf_magic.__file__), 'static-root')
settings.STATICFILES_STORAGE = 'django.contrib.staticfiles.storage.ManifestStaticFilesStorage'
django.setup()
for app in test_apps:
management.call_command('makemigrations', app)
runner = DiscoverRunner()
runner.setup_test_environment()
runner.setup_databases()
if config.getoption('--staticfiles'):
management.call_command('collectstatic', verbosity=0, interactive=False)
