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