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)