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
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 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_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_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): """ 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): # 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 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_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_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 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)
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 _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
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 )
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)
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 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])
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)
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)