def test_latest_available_version(self):
# This one has no migrations, so the latest is 0
self.assertEqual(
models.MigrationPackage(migration_packages.a).latest_available_version, 0)
self.assertEqual(models.MigrationPackage(
migration_packages.platform).latest_available_version, 1)
self.assertEqual(
models.MigrationPackage(migration_packages.z).latest_available_version, 3)
def test_current_version(self):
mp = models.MigrationPackage(migration_packages.z)
# By default, a MigrationPackage will be at version 0
self.assertEqual(mp.current_version, 0)
# Now let's change the version to 4 and see what happens
mp._migration_tracker.version = 4
mp._migration_tracker.save()
# Now we should be able to reinstantiate this mammajamma and see that the version is right
mp = models.MigrationPackage(migration_packages.z)
self.assertEqual(mp.current_version, 4)
def test___cmp__(self):
mp_1 = models.MigrationPackage(migration_packages.a)
mp_2 = models.MigrationPackage(migration_packages.platform)
mp_3 = models.MigrationPackage(migration_packages.z)
# platform should always sort first, and they should otherwise be alphabeticalness
self.assertEqual(cmp(mp_1, mp_1), 0)
self.assertEqual(cmp(mp_1, mp_2), 1)
self.assertEqual(cmp(mp_1, mp_3), -1)
self.assertEqual(cmp(mp_2, mp_1), -1)
self.assertEqual(cmp(mp_2, mp_2), 0)
self.assertEqual(cmp(mp_2, mp_3), -1)
self.assertEqual(cmp(mp_3, mp_1), 1)
self.assertEqual(cmp(mp_3, mp_2), 1)
self.assertEqual(cmp(mp_3, mp_3), 0)
def test__init__2(self, mock_tracker):
"""
Test package does not exist.
"""
mock_tracker.objects.return_value.get.side_effect = DoesNotExist()
models.MigrationPackage(migration_packages.b)
self.assertEqual(mock_tracker.return_value.save.call_count, 1)
def test_migration_version_gap(self):
"""
Make sure that we allow migrations to have version gaps. Previously version gaps were not
allowed, and this call would have caused a validation failure. This test makes sure no such
failure happens.
"""
models.MigrationPackage(migration_packages.version_gap)
def test_nonconforming_modules(self, log_mock):
# The z package has a module called doesnt_conform_to_naming_convention.py. This shouldn't
# count as a migration module, but it also should not interfere with the existing migration
# modules, and the debug log should mention that the file was found but was not found to be
# a migration module. The z package also has a module called 0004_doesnt_have_migrate.py.
# Since it doesn't have a migrate function, it should just be logged and things should keep
# going as usual.
mp = models.MigrationPackage(migration_packages.z)
migrations = mp.migrations
self.assertEqual(len(migrations), 3)
self.assertTrue(all([isinstance(migration, models.MigrationModule)
for migration in migrations]))
# Make sure their versions are set and sorted appropriately
self.assertEqual([1, 2, 3], [migration.version for migration in migrations])
# Check the names
self.assertEqual(['unit.server.db.migration_packages.z.0001_test',
'unit.server.db.migration_packages.z.0002_test',
'unit.server.db.migration_packages.z.0003_test'],
[migration.name for migration in migrations])
# Now let's assert that the non-conforming dealios were logged
# They actually get logged twice each, once for when we initialized the MP, and the other
# when we retrieved the migrations
log_mock.assert_has_calls([
call('The module unit.server.db.migration_packages.z.0004_doesnt_have_migrate '
'doesn\'t have a migrate function. It will be ignored.'),
call('The module '
'unit.server.db.migration_packages.z.doesnt_conform_to_naming_convention '
'doesn\'t conform to the migration package naming conventions. It will be '
'ignored.'),
call('The module unit.server.db.migration_packages.z.0004_doesnt_have_migrate '
'doesn\'t have a migrate function. It will be ignored.'),
call('The module '
'unit.server.db.migration_packages.z.doesnt_conform_to_naming_convention '
'doesn\'t conform to the migration package naming conventions. It will be '
'ignored.')])
def test__init__3(self, mock_tracker):
"""
Test package exists.
"""
mock_some = MagicMock()
mock_tracker.objects.return_value.get = mock_some
models.MigrationPackage(migration_packages.a)
self.assertEqual(mock_tracker.return_value.save.call_count, 0)
def test___init__(self):
mp = models.MigrationPackage(migration_packages.z)
self.assertEquals(mp._package.__name__,
'unit.server.db.migration_packages.z')
self.assertEquals(mp._migration_tracker.name,
'unit.server.db.migration_packages.z')
# By default, MigrationPackages should start at version 0
self.assertEquals(mp._migration_tracker.version, 0)
def test_duplicate_versions(self):
error_message = 'There are two migration modules that share version 2 in ' +\
'unit.server.db.migration_packages.duplicate_versions.'
try:
models.MigrationPackage(migration_packages.duplicate_versions)
self.fail('The MigrationPackage.DuplicateVersions exception should have been raised, '
'but was not raised.')
except models.MigrationPackage.DuplicateVersions, e:
self.assertEquals(str(e), error_message)
def test_unapplied_migrations(self):
mp = models.MigrationPackage(migration_packages.z)
# Drop the version to 1, which should make this method return two migrations
mp._migration_tracker.version = 1
mp._migration_tracker.save()
unapplied = mp.unapplied_migrations
self.assertEqual(len(unapplied), 2)
self.assertEqual([m.version for m in unapplied], [2, 3])
self.assertEqual(
[m._module.__name__ for m in unapplied],
['unit.server.db.migration_packages.z.0002_test',
'unit.server.db.migration_packages.z.0003_test'])
def test_migration_version_gap(self):
"""
Make sure that we require migration versions to be continuous, with no gaps.
"""
error_message = 'Migration version 2 is missing in ' +\
'unit.server.db.migration_packages.version_gap.'
try:
models.MigrationPackage(migration_packages.version_gap)
self.fail('The MigrationPackage.MissingVersion exception should have been raised, '
'but was not raised.')
except models.MigrationPackage.MissingVersion, e:
self.assertEquals(str(e), error_message)
def test_migrations(self):
migration_package = models.MigrationPackage(migration_packages.z)
migrations = migration_package.migrations
self.assertEqual(len(migrations), 3)
self.assertTrue(all([isinstance(migration, models.MigrationModule)
for migration in migrations]))
# Make sure their versions are set and sorted appropriately
self.assertEqual([1, 2, 3], [migration.version for migration in migrations])
# Check the names
self.assertEqual(['unit.server.db.migration_packages.z.0001_test',
'unit.server.db.migration_packages.z.0002_test',
'unit.server.db.migration_packages.z.0003_test'],
[migration._module.__name__ for migration in migrations])
def test_migration_version_cant_be_zero(self):
"""
Make sure that we reserve migration zero.
"""
error_message = (
'0 is a reserved migration version number, but the module '
'unit.server.db.migration_packages.version_zero.0000_not_allowed has been '
'assigned that version.')
try:
models.MigrationPackage(migration_packages.version_zero)
self.fail('The MigrationPackage.DuplicateVersions exception should have been raised, '
'but was not raised.')
except models.MigrationPackage.DuplicateVersions, e:
self.assertEquals(str(e), error_message)
def test_apply_migration(self):
mp = models.MigrationPackage(migration_packages.z)
# Let's fake the migration version being at 2 instead of 3
mp._migration_tracker.version = 2
mp._migration_tracker.save()
# Now, let's apply version 3
mm_v3 = mp.unapplied_migrations[-1]
self.assertEqual(mm_v3.version, 3)
# Let's change the migrate() function to one that tracks that it gets called.
mm_v3.migrate = MagicMock(name='migrate')
self.assertEquals(mm_v3.migrate.called, False)
# Now try to run the migration and assert that it gets called
mp.apply_migration(mm_v3)
self.assertEquals(mm_v3.migrate.called, True)
# Now the mp should be at v3
self.assertEqual(mp.current_version, 3)
def test_apply_wrong_migration(self):
"""
We want to assert that apply_migration() only allows migrations of current_version + 1.
"""
mp = models.MigrationPackage(migration_packages.z)
# Let's fake the migration version being at 1 instead of 3
mp._migration_tracker.version = 1
mp._migration_tracker.save()
# Now, let's try to apply version 3
mm_v3 = mp.unapplied_migrations[-1]
self.assertEqual(mm_v3.version, 3)
# Let's change the migrate() function to one that tracks whether it gets called.
mm_v3.migrate = MagicMock(name='migrate')
# Now try to run the migration and assert that it didn't get called
try:
mp.apply_migration(mm_v3)
self.fail('Applying migration 3 should have raised an Exception, but it did not.')
except Exception, e:
expected_msg = ('Cannot apply migration unit.server.db.migration_packages.z.0003_test,'
' because the next migration version is 2.')
self.assertEquals(str(e), expected_msg)
def test___str__(self):
mp = models.MigrationPackage(migration_packages.z)
self.assertEqual(str(mp), 'unit.server.db.migration_packages.z')
def test___repr__(self):
mp = models.MigrationPackage(data.test_migration_packages.z)
self.assertEqual(repr(mp), 'data.test_migration_packages.z')
def test_name(self):
mp = models.MigrationPackage(data.test_migration_packages.z)
self.assertEqual(mp.name, 'data.test_migration_packages.z')
def test_available_versions(self):
mp = models.MigrationPackage(migration_packages.z)
self.assertEquals(mp.available_versions, [1, 2, 3])
def test_name(self):
mp = models.MigrationPackage(migration_packages.z)
self.assertEqual(mp.name, 'unit.server.db.migration_packages.z')
