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