public void AddMigration(IDatabaseMigration migration)
{
if (!migrations.Contains(migration))
{
migrations.Add(migration);
}
}
public void Save(IMongoDatabase db, IDatabaseMigration migration)
{
GetMigrationsCollection(db).InsertOne(new MigrationHistory
{
MigrationId = migration.GetType().ToString(),
Version = migration.Version
});
}
private void RecordMigration(IDatabaseMigration migration)
{
var migrationsTableExistsCommand = new DbCommandSpec()
.SetCommandText(string.Format("insert into {0} (Name) values ({1}name)", MIGRATIONS_TABLE_NAME,
SessionFactory.DEFAULT_SQL_PARAMETER_PREFIX))
.AddParameter("name", migration.Name);
UnitOfWork.Current.Session.ExecuteNonQuery(migrationsTableExistsCommand);
}
private bool PreviouslyRun(IDatabaseMigration migration)
{
var command = new DbCommandSpec()
.SetCommandText(string.Format("select count(*) from {0} where Name = {1}name",
MIGRATIONS_TABLE_NAME, SessionFactory.DEFAULT_SQL_PARAMETER_PREFIX))
.AddParameter("name", migration.Name);
var result = (long)UnitOfWork.Current.Session.ExecuteScalar(command);
return(result > 0);
}
private void RecordMigration(IDatabaseMigration migration)
{
var migrationsTableExistsCommand = new DbCommandSpec()
.SetCommandText(string.Format("insert into {0} ({1}) values ({2})",
MIGRATIONS_TABLE_NAME,
session.DbAdapter.Quote(MIGRATION_NAME_COLUMN_NAME),
session.DbAdapter.FormatParameterName("name")))
.AddParameter("name", migration.Name);
session.ExecuteNonQuery(migrationsTableExistsCommand);
}
private bool PreviouslyRun(IDatabaseMigration migration)
{
var command = new DbCommandSpec()
.SetCommandText(string.Format("select count(*) from {0} where {1} = {2}",
MIGRATIONS_TABLE_NAME,
session.DbAdapter.Quote(MIGRATION_NAME_COLUMN_NAME),
session.DbAdapter.FormatParameterName("name")))
.AddParameter("name", migration.Name);
var result = session.ExecuteScalar(command);
return Convert.ToInt64(result) > 0;
}
protected IDatabaseMigration CreateMigrationInstance(MigrationReference migrationReference)
{
Type type = CompileMigration(migrationReference);
object fixture = Activator.CreateInstance(type);
IDatabaseMigration instance = fixture as IDatabaseMigration;
if (instance == null)
{
throw new ArgumentException(type + " should be a " + typeof(IDatabaseMigration));
}
return(instance);
}
public override MigrationInitializer Create()
{
_databaseProvider = _mocks.StrictMock <IDatabaseProvider>();
_schemaProvider = _mocks.StrictMock <ISchemaProvider>();
_migration = _mocks.StrictMock <IDatabaseMigration>();
_configuration = _mocks.StrictMock <IConfiguration>();
_commonTransformations = _mocks.StrictMock <ICommonTransformations>();
_connectionProvider = _mocks.StrictMock <IConnectionProvider>();
return(new MigrationInitializer(_configuration, _databaseProvider, _schemaProvider, _commonTransformations,
_connectionProvider));
}
public bool CanMigrate(IDictionary <string, List <MigrationStep> > steps)
{
foreach (MigrationStep step in steps.SelectMany(row => row.Value).OrderBy(row => row.Version))
{
MigrationReference migrationReference = step.MigrationReference;
IMigrationFactory migrationFactory = _migrationFactoryChooser.ChooseFactory(migrationReference);
IDatabaseMigration migration = migrationFactory.CreateMigration(migrationReference);
step.DatabaseMigration = migration;
_migrationInitializer.InitializeMigration(migration);
}
_log.Info("All migrations are initialized.");
return(true);
}
public void CreateMigration_reading_a_file_with_Down_marker_only_will_initialize_SqlScriptMigration_with_Down_scripts_only()
{
using (_mocks.Record())
{
SetupResult.For(_fileSystem.ReadAllText(_migrationPath)).Repeat.Once().Return(ReadScriptWithDownMarkerOnly);
}
using (_mocks.Playback())
{
resultingMigration = _target.CreateMigration(_migrationReference);
}
var sqlScriptMigration = resultingMigration as SqlScriptMigration;
Assert.That(sqlScriptMigration.UpScript == "");
Assert.That(sqlScriptMigration.DownScript == DownScript);
_mocks.VerifyAll();
}
public override MigrationRunner Create()
{
_steps = new Dictionary <string, List <MigrationStep> >();
_steps[string.Empty] = new List <MigrationStep>();
_steps[string.Empty].Add(new MigrationStep(new MigrationReference(1, "A", "001_a.cs"), false));
_steps[string.Empty].Add(new MigrationStep(new MigrationReference(2, "B", "002_b.cs"), false));
_migration1 = _mocks.StrictMock <IDatabaseMigration>();
_migration2 = _mocks.StrictMock <IDatabaseMigration>();
_schemaStateManager = _mocks.DynamicMock <ISchemaStateManager>();
_migrationFactoryChooser = _mocks.DynamicMock <IMigrationFactoryChooser>();
_migrationInitializer = _mocks.DynamicMock <IMigrationInitializer>();
_migrationFactory = _mocks.DynamicMock <IMigrationFactory>();
_configuration = _mocks.DynamicMock <IConfiguration>();
_transactionProvider = _mocks.DynamicMock <ITransactionProvider>();
_transaction = _mocks.StrictMock <IDbTransaction>();
return(new MigrationRunner(_migrationFactoryChooser, _migrationInitializer, _schemaStateManager, _configuration,
_transactionProvider));
}
private async Task <List <DatabaseMigrationSpecifier> > GetRequiredMigrationDependenciesAsync(
IDatabaseMigration migration, List <DatabaseMigrationSpecifier> queuedMigrations, string[] tags)
{
var dependencies = new List <DatabaseMigrationSpecifier>();
foreach (var dependency in migration.Dependencies)
{
var dependencyMigrations = await SelectModuleMigrationsNoDependenciesAsync(dependency, tags, queuedMigrations);
if (dependencyMigrations.Count > 0)
{
dependencies.Add(new DatabaseMigrationSpecifier(
dependencyMigrations.Last().ModuleName,
dependencyMigrations.Last().Version));
}
}
return(dependencies);
}
private static ISessionFactory Bootstrap(IDatabaseMigration createSchema, IDbAdapter dbAdapter, Action<string> createDatabaseFunc)
{
Log.Level = LogLevel.Off;
const string dbFileName = "main.db";
const string connectionString = "Data source=" + dbFileName;
File.Delete(dbFileName);
if (createDatabaseFunc != null)
{
createDatabaseFunc(connectionString);
}
var sessionFactory = Fluently.Configure
.ConnectionString(connectionString)
.DatabaseAdapter(dbAdapter)
.Domain(DomainMapping.Get())
.Build();
UnitOfWork.Initialize(sessionFactory);
using (var s = sessionFactory.Create())
{
s.Open();
new DatabaseMigratorUtility(s).Migrate(createSchema);
}
return sessionFactory;
}
public void CreateMigration_reading_empty_file_will_return_a_SqlScriptMigration_with_empty_Up_and_Down_scripts()
{
using (_mocks.Record())
{
SetupResult.For(_fileSystem.ReadAllText(_migrationPath)).Repeat.Once().Return("");
}
using (_mocks.Playback())
{
resultingMigration = _target.CreateMigration(_migrationReference);
}
var sqlScriptMigration = resultingMigration as SqlScriptMigration;
if (sqlScriptMigration == null)
{
Assert.Fail("Returned migration should be SqlScriptMigration!");
}
Assert.That(sqlScriptMigration.UpScript == "");
Assert.That(sqlScriptMigration.DownScript == "");
_mocks.VerifyAll();
}
public bool SupportsMigration(IDatabaseMigration migration)
{
return(migration is SqlDatabaseMigration);
}
private async Task <List <DatabaseMigrationSpecifier> > GetRequiredMigrationDependenciesAsync(
IDatabaseMigration migration, List <DatabaseMigrationSpecifier> queuedMigrations, string[] tags)
{
var dependencies = new List <DatabaseMigrationSpecifier>();
history = history ?? await migrationProvider.GetMigrationHistoryAsync();
var tagMatchingMigrations = migrationRegistry.Migrations
.Where(x => x.Tags.All(tagGroup => tags.Any(tagGroup.Contains)));
foreach (var dependency in migration.Dependencies)
{
// repeatable dependencies
var repeatableMigration = tagMatchingMigrations.FirstOrDefault(x => x.ModuleName == dependency.ModuleName && x.IsRepeatable);
if (dependency.Version == null && repeatableMigration != null)
{
if (queuedMigrations.Any(x => x.ModuleName == dependency.ModuleName))
{
continue;
}
var lastMigration = history
.Where(x => string.Equals(x.ModuleName, dependency.ModuleName, StringComparison.InvariantCultureIgnoreCase))
.OrderByDescending(x => x.TimeApplied).FirstOrDefault();
if (lastMigration?.Checksum == repeatableMigration.Checksum)
{
continue;
}
dependencies.Add(dependency);
}
// versioned dependencies
else
{
var version = queuedMigrations
.Where(x => string.Equals(x.ModuleName, dependency.ModuleName, StringComparison.InvariantCultureIgnoreCase))
.OrderByDescending(x => x.Version)
.Select(x => x.Version)
.FirstOrDefault();
if (version == null)
{
var lastMigration = history
.Where(x => string.Equals(x.ModuleName, dependency.ModuleName, StringComparison.InvariantCultureIgnoreCase))
.OrderByDescending(x => x.Version).FirstOrDefault();
version = lastMigration?.Version;
}
IEnumerable <IDatabaseMigration> matchingDependencies = tagMatchingMigrations
.Where(x => x.ModuleName == dependency.ModuleName)
.OrderByDescending(x => x.Version);
if (dependency.Version != null)
{
matchingDependencies = matchingDependencies.Where(x => dependency.Version.Equals(x.Version));
if (matchingDependencies.Any() && version != null && version.CompareTo(matchingDependencies.First().Version) >= 0)
{
continue; // nothing to upgrade, case when !matchingDependencies.Any() is handled later
}
}
else
{
if (matchingDependencies.Any())
{
var maxVersion = matchingDependencies.Select(x => x.Version).Max();
if (version != null && version.CompareTo(maxVersion) >= 0)
{
continue; // nothing to upgrade, case when !matchingDependencies.Any() is handled later
}
matchingDependencies = matchingDependencies.Where(x => maxVersion.Equals(x.Version));
}
}
if (!matchingDependencies.Any())
{
throw new DatabaseMigrationException($"Database migration {migration} specifies dependency to {dependency.ModuleName}@{dependency.Version?.ToString() ?? "latest"}, but no matching migrations to that version were found");
}
matchingDependencies = matchingDependencies.ToArray();
if (version != null)
{
matchingDependencies = matchingDependencies.Where(x => !x.IsBaseline);
if (!matchingDependencies.Any())
{
throw new DatabaseMigrationException($"Database migration {migration} specifies dependency to {dependency.ModuleName}@{dependency.Version?.ToString() ?? "latest"}, for which there is a baseline migration, but no upgrade migration from version {version}");
}
}
dependencies.Add(dependency);
}
}
return(dependencies);
}
public void InitializeMigration(IDatabaseMigration migration)
{
migration.Initialize(new MigrationContext(_configuration, _databaseProvider, _schemaProvider, _commonTransformations, _connectionProvider));
}
public void Remove(IMongoDatabase db, IDatabaseMigration migration)
{
GetMigrationsCollection(db).DeleteOne(Builders <MigrationHistory> .Filter.Eq(mh => mh.MigrationId, migration.GetType().ToString()));
}
public void InitializeMigration(IDatabaseMigration migration)
{
migration.Initialize(new MigrationContext(_configuration, _databaseProvider, _schemaProvider, _commonTransformations,
_connectionProvider));
}
