public void DeleteVersionShouldExecuteDeleteDataExpression()
{
var processor = new Mock <IMigrationProcessor>();
var runner = new Mock <IMigrationRunner>();
runner.SetupGet(r => r.Processor).Returns(processor.Object);
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new VersionLoader(runner.Object, asm, conventions);
processor.Setup(p => p.Process(It.Is <DeleteDataExpression>(expression =>
expression.SchemaName == loader.VersionTableMetaData.SchemaName &&
expression.TableName == loader.VersionTableMetaData.TableName &&
expression.Rows.All(
definition =>
definition.All(
pair =>
pair.Key == loader.VersionTableMetaData.ColumnName && pair.Value.Equals(1L))))))
.Verifiable();
loader.DeleteVersion(1);
processor.VerifyAll();
}
public void DeleteVersionShouldExecuteDeleteDataExpression()
{
var processor = new Mock <IMigrationProcessor>();
var runner = new Mock <IMigrationRunner>();
runner.SetupGet(r => r.Processor).Returns(processor.Object);
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new VersionLoader(runner.Object, asm, conventions);
Func <IDataDefinition, bool> predicate =
definition =>
{
if (definition is ExplicitDataDefinition)
{
IDataValue kvp = ((ExplicitDataDefinition)definition).Data.First();
return(kvp.ColumnName == loader.VersionTableMetaData.ColumnName && kvp.Value.Equals(1L));
}
else
{
return(false);
}
};
processor.Setup(p => p.Process(It.Is <DeleteDataExpression>(expression =>
expression.SchemaName == loader.VersionTableMetaData.SchemaName &&
expression.TableName == loader.VersionTableMetaData.TableName &&
expression.Rows.All(predicate)))).Verifiable();
loader.DeleteVersion(1);
processor.VerifyAll();
}
public void DeleteVersionShouldExecuteDeleteDataExpression()
{
var processor = new Mock<IMigrationProcessor>();
var runner = new Mock<IMigrationRunner>();
runner.SetupGet(r => r.Processor).Returns(processor.Object);
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new VersionLoader(runner.Object, asm, conventions);
Func<IDataDefinition, bool> predicate =
definition =>
{
if (definition is ExplicitDataDefinition)
{
IDataValue kvp = ((ExplicitDataDefinition)definition).Data.First();
return kvp.ColumnName == loader.VersionTableMetaData.ColumnName && kvp.Value.Equals(1L);
}
else
{
return false;
}
};
processor.Setup(p => p.Process(It.Is<DeleteDataExpression>(expression =>
expression.SchemaName == loader.VersionTableMetaData.SchemaName
&& expression.TableName == loader.VersionTableMetaData.TableName
&& expression.Rows.All(predicate)))).Verifiable();
loader.DeleteVersion(1);
processor.VerifyAll();
}
public MigrationRunner(IAssemblyCollection assemblies, IRunnerContext runnerContext, IMigrationProcessor processor)
{
_migrationAssemblies = assemblies;
_announcer = runnerContext.Announcer;
Processor = processor;
_stopWatch = runnerContext.StopWatch;
ApplicationContext = runnerContext.ApplicationContext;
TransactionPerSession = runnerContext.TransactionPerSession;
SilentlyFail = false;
CaughtExceptions = null;
Conventions = new MigrationConventions();
if (!string.IsNullOrEmpty(runnerContext.WorkingDirectory))
{
Conventions.GetWorkingDirectory = () => runnerContext.WorkingDirectory;
}
_migrationScopeHandler = new MigrationScopeHandler(Processor);
_migrationValidator = new MigrationValidator(_announcer, Conventions);
MigrationLoader = new DefaultMigrationInformationLoader(Conventions, _migrationAssemblies, runnerContext.Namespace, runnerContext.NestedNamespaces, runnerContext.Tags);
ProfileLoader = new ProfileLoader(runnerContext, this, Conventions);
MaintenanceLoader = new MaintenanceLoader(_migrationAssemblies, runnerContext.Tags, Conventions);
if (runnerContext.NoConnection)
{
VersionLoader = new ConnectionlessVersionLoader(this, _migrationAssemblies, Conventions, runnerContext.StartVersion, runnerContext.Version);
}
else
{
VersionLoader = new VersionLoader(this, _migrationAssemblies, Conventions);
}
}
public void DeleteVersionShouldExecuteDeleteDataExpression()
{
var processor = new Mock<IMigrationProcessor>();
var runner = new Mock<IMigrationRunner>();
runner.SetupGet(r => r.Processor).Returns(processor.Object);
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new VersionLoader(runner.Object, asm, conventions);
processor.Setup(p => p.Process(It.Is<DeleteDataExpression>(expression =>
expression.SchemaName == loader.VersionTableMetaData.SchemaName
&& expression.TableName == loader.VersionTableMetaData.TableName
&& expression.Rows.All(
definition =>
definition.All(
pair =>
pair.Key == loader.VersionTableMetaData.ColumnName && pair.Value.Equals(1L))))))
.Verifiable();
loader.DeleteVersion(1);
processor.VerifyAll();
}
public MigrationRunner(IAssemblyCollection assemblies, IRunnerContext runnerContext, IMigrationProcessor processor)
{
_migrationAssemblies = assemblies;
_announcer = runnerContext.Announcer;
Processor = processor;
_stopWatch = runnerContext.StopWatch;
RunnerContext = runnerContext;
SilentlyFail = false;
CaughtExceptions = null;
Conventions = new MigrationConventions();
if (!string.IsNullOrEmpty(runnerContext.WorkingDirectory))
Conventions.GetWorkingDirectory = () => runnerContext.WorkingDirectory;
_migrationScopeHandler = new MigrationScopeHandler(Processor);
_migrationValidator = new MigrationValidator(_announcer, Conventions);
MigrationLoader = new DefaultMigrationInformationLoader(Conventions, _migrationAssemblies, runnerContext.Namespace, runnerContext.NestedNamespaces, runnerContext.Tags);
ProfileLoader = new ProfileLoader(runnerContext, this, Conventions);
MaintenanceLoader = new MaintenanceLoader(_migrationAssemblies, runnerContext.Tags, Conventions);
if (runnerContext.NoConnection){
VersionLoader = new ConnectionlessVersionLoader(this, _migrationAssemblies, Conventions, runnerContext.StartVersion, runnerContext.Version);
}
else{
VersionLoader = new VersionLoader(this, _migrationAssemblies, Conventions);
}
}
public void RemoveVersionTableShouldBehaveAsExpected()
{
var runnerContext = new Mock <IRunnerContext>();
var processor = new Mock <IMigrationProcessor>();
var runner = new Mock <IMigrationRunner>();
runner.SetupGet(r => r.Processor).Returns(processor.Object);
runner.SetupGet(r => r.RunnerContext).Returns(runnerContext.Object);
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new VersionLoader(runner.Object, asm, conventions);
processor.Setup(p => p.Process(It.Is <DeleteTableExpression>(expression =>
expression.SchemaName == loader.VersionTableMetaData.SchemaName &&
expression.TableName == loader.VersionTableMetaData.TableName)))
.Verifiable();
processor.Setup(p => p.Process(It.Is <DeleteSchemaExpression>(expression =>
expression.SchemaName == loader.VersionTableMetaData.SchemaName)))
.Verifiable();
loader.RemoveVersionTable();
processor.VerifyAll();
}
public void CanLoadDefaultVersionTableMetaData()
{
var conventions = new MigrationConventions();
var loader = new MigrationLoader(conventions);
var asm = Assembly.GetExecutingAssembly();
IVersionTableMetaData versionTableMetaData = loader.GetVersionTableMetaData(asm);
versionTableMetaData.ShouldBeOfType<TestVersionTableMetaData>();
}
public void DefaultBehaviorIsToNotLoadNestedNamespaces()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new MigrationLoader(conventions, asm, "FluentMigrator.Tests.Integration.Migrations.Nested", null);
loader.LoadNestedNamespaces.ShouldBe(false);
}
public void HandlesMigrationThatDoesNotInheritFromMigrationBaseClass()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new DefaultMigrationInformationLoader(conventions, asm, "FluentMigrator.Tests.Unit.DoesNotInheritFromBaseClass", null);
Assert.That(loader.LoadMigrations().Count(), Is.EqualTo(1));
}
public void DefaultBehaviorIsToNotLoadNestedNamespaces()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new MigrationLoader(conventions, asm, "FluentMigrator.Tests.Integration.Migrations.Nested", null, new AppliedVersions());
loader.LoadNestedNamespaces.ShouldBe(false);
}
public void ShouldThrowExceptionIfDuplicateVersionNumbersAreLoaded()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var migrationLoader = new DefaultMigrationInformationLoader(conventions, asm, "FluentMigrator.Tests.Unit.DuplicateVersionNumbers", null);
Assert.Throws <DuplicateMigrationException>(() => migrationLoader.LoadMigrations());
}
public void CanFindMigrationsInNamespace()
{
var conventions = new MigrationConventions();
var loader = new MigrationLoader(conventions);
var asm = Assembly.GetExecutingAssembly();
var migrationList = loader.FindMigrationsIn(asm, "FluentMigrator.Tests.Integration.Migrations.Interleaved.Pass1");
migrationList.Select(x => x.Type).ShouldNotContain(typeof(VersionedMigration));
migrationList.Count().ShouldBeGreaterThan(0);
}
public void ShouldApplyIndexNameConventionWhenIndexNameIsNull()
{
var indexDefinition = new IndexDefinition();
var conventions = new MigrationConventions { GetIndexName = definition => "IX_Table_Name" };
indexDefinition.ApplyConventions(conventions);
Assert.AreEqual("IX_Table_Name", indexDefinition.Name);
}
public void CanLoadCustomVersionTableMetaData()
{
var conventions = new MigrationConventions();
var loader = new MigrationLoader(conventions);
var asm = GetAssemblyWithCustomVersionTableMetaData();
IVersionTableMetaData versionTableMetaData = loader.GetVersionTableMetaData(asm);
Assert.AreEqual(TestVersionTableMetaData.TABLENAME,versionTableMetaData.TableName);
Assert.AreEqual(TestVersionTableMetaData.COLUMNNAME, versionTableMetaData.ColumnName);
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var expression = new DeleteDefaultConstraintExpression { TableName = "ThaTable", ColumnName = "ThaColumn" };
var migrationConventions = new MigrationConventions { GetDefaultSchema = () => "testdefault" };
expression.ApplyConventions(migrationConventions);
Assert.That(expression.SchemaName, Is.EqualTo("testdefault"));
}
private void Initialize()
{
var migrationConventions = new MigrationConventions();
if (!string.IsNullOrEmpty(RunnerContext.WorkingDirectory))
migrationConventions.GetWorkingDirectory = () => RunnerContext.WorkingDirectory;
Assembly assembly = AssemblyLoaderFactory.GetAssemblyLoader(RunnerContext.Target).Load();
Runner = new MigrationVersionRunner(migrationConventions, RunnerContext.Processor, new MigrationLoader(migrationConventions), assembly, RunnerContext.Namespace);
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var migrationConventions = new MigrationConventions {
GetDefaultSchema = () => "testdefault"
};
expression.ApplyConventions(migrationConventions);
Assert.That(expression.SchemaName, Is.EqualTo("testdefault"));
}
public void CanUseScriptsOnAnotherDriveToWorkingDirectory()
{
var scriptOnAnotherDrive = "z" + Path.VolumeSeparatorChar + Path.DirectorySeparatorChar + testSqlScript;
var expression = new ExecuteSqlScriptExpression { SqlScript = scriptOnAnotherDrive };
var conventions = new MigrationConventions { GetWorkingDirectory = () => "c" + Path.VolumeSeparatorChar + Path.DirectorySeparatorChar + "code" };
expression.ApplyConventions(conventions);
expression.SqlScript.ShouldBe(scriptOnAnotherDrive);
}
public void CanFindMigrationsInNamespace()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new MigrationLoader(conventions, asm, "FluentMigrator.Tests.Integration.Migrations.Interleaved.Pass1", null);
var migrationList = loader.FindMigrations();
migrationList.Select(x => x.Type).ShouldNotContain(typeof(VersionedMigration));
migrationList.Count().ShouldBeGreaterThan(0);
}
public void ShouldApplyIndexNameConventionWhenIndexNameIsNull()
{
var indexDefinition = new IndexDefinition();
var conventions = new MigrationConventions {
GetIndexName = definition => "IX_Table_Name"
};
indexDefinition.ApplyConventions(conventions);
Assert.AreEqual("IX_Table_Name", indexDefinition.Name);
}
public void HandlesNotFindingMigrations()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new DefaultMigrationInformationLoader(conventions, asm, "FluentMigrator.Tests.Unit.EmptyNamespace", null);
var list = loader.LoadMigrations();
Assert.That(list, Is.Not.Null);
Assert.That(list.Count(), Is.EqualTo(0));
}
public void CanLoadDefaultVersionTableMetaData()
{
var runner = new Mock<IMigrationRunner>();
runner.SetupGet(r=>r.Processor.Options).Returns(new TestMigrationProcessorOptions());
var conventions = new MigrationConventions();
var asm = "s".GetType().Assembly;
var loader = new VersionLoader(runner.Object, asm, conventions);
var versionTableMetaData = loader.GetVersionTableMetaData();
versionTableMetaData.ShouldBeOfType<DefaultVersionTableMetaData>();
}
public void CanLoadCustomVersionTableMetaData()
{
var runner = new Mock<IMigrationRunner>();
runner.SetupGet(r => r.Processor.Options).Returns(new TestMigrationProcessorOptions());
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new VersionLoader(runner.Object, asm, conventions);
var versionTableMetaData = loader.GetVersionTableMetaData();
versionTableMetaData.ShouldBeOfType<TestVersionTableMetaData>();
}
private void Initialize()
{
if (!Path.IsPathRooted(RunnerContext.Target))
RunnerContext.Target = Path.GetFullPath(RunnerContext.Target);
var migrationConventions = new MigrationConventions();
if (!string.IsNullOrEmpty(RunnerContext.WorkingDirectory))
migrationConventions.GetWorkingDirectory = () => RunnerContext.WorkingDirectory;
Assembly assembly = Assembly.LoadFile(RunnerContext.Target);
Runner = new MigrationVersionRunner(migrationConventions, RunnerContext.Processor, new MigrationLoader(migrationConventions), assembly, RunnerContext.Namespace);
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var expression = new AlterDefaultConstraintExpression {
TableName = "test", ColumnName = "Column1", DefaultValue = SystemMethods.CurrentDateTime
};
var migrationConventions = new MigrationConventions {
GetDefaultSchema = () => "testdefault"
};
expression.ApplyConventions(migrationConventions);
Assert.That(expression.SchemaName, Is.EqualTo("testdefault"));
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var expression = new CreateColumnExpression {
TableName = "Bacon", Column = { Name = "BaconId", Type = DbType.Int32 }
};
var migrationConventions = new MigrationConventions {
GetDefaultSchema = () => "testdefault"
};
expression.ApplyConventions(migrationConventions);
Assert.That(expression.SchemaName, Is.EqualTo("testdefault"));
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var expression = new RenameColumnExpression {
TableName = "Bacon", OldName = "BaconId", NewName = "ChunkyBaconId"
};
var migrationConventions = new MigrationConventions {
GetDefaultSchema = () => "testdefault"
};
expression.ApplyConventions(migrationConventions);
Assert.That(expression.SchemaName, Is.EqualTo("testdefault"));
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var table = new TableDefinition {
Name = "Test"
};
var migrationConventions = new MigrationConventions {
GetDefaultSchema = () => "testdefault"
};
table.ApplyConventions(migrationConventions);
Assert.That(table.SchemaName, Is.EqualTo("testdefault"));
}
public void CanLoadDefaultVersionTableMetaData()
{
var runner = new Mock <IMigrationRunner>();
runner.SetupGet(r => r.Processor.Options).Returns(new TestMigrationProcessorOptions());
var conventions = new MigrationConventions();
var asm = "s".GetType().Assembly;
var loader = new VersionLoader(runner.Object, asm, conventions);
var versionTableMetaData = loader.GetVersionTableMetaData();
versionTableMetaData.ShouldBeOfType <DefaultVersionTableMetaData>();
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var foreignKeyDefinition = new ForeignKeyDefinition {
Name = "Test"
};
var migrationConventions = new MigrationConventions {
GetDefaultSchema = () => "testdefault"
};
foreignKeyDefinition.ApplyConventions(migrationConventions);
Assert.That(foreignKeyDefinition.ForeignTableSchema, Is.EqualTo("testdefault"));
Assert.That(foreignKeyDefinition.PrimaryTableSchema, Is.EqualTo("testdefault"));
}
public void CanLoadCustomVersionTableMetaData()
{
var runner = new Mock <IMigrationRunner>();
runner.SetupGet(r => r.Processor.Options).Returns(new TestMigrationProcessorOptions());
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new VersionLoader(runner.Object, asm, conventions);
var versionTableMetaData = loader.GetVersionTableMetaData();
versionTableMetaData.ShouldBeOfType <TestVersionTableMetaData>();
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var constraintDefinition = new ConstraintDefinition(ConstraintType.PrimaryKey)
{
ConstraintName = "Test"
};
var migrationConventions = new MigrationConventions {
GetDefaultSchema = () => "testdefault"
};
constraintDefinition.ApplyConventions(migrationConventions);
Assert.That(constraintDefinition.SchemaName, Is.EqualTo("testdefault"));
}
public void CanApplyIndexConvention()
{
ExecuteWithSupportedProcessors(
processor =>
{
var conventions = new MigrationConventions();
var runner = new MigrationRunner(conventions, processor, new TextWriterAnnouncer(System.Console.Out), new StopWatch());
runner.Up(new TestIndexNamingConvention());
processor.TableExists("Users").ShouldBeTrue();
runner.Down(new TestIndexNamingConvention());
processor.TableExists("Users").ShouldBeFalse();
});
}
public void CanFindMigrationsInAssembly()
{
var conventions = new MigrationConventions();
var loader = new MigrationLoader(conventions);
var asm = Assembly.GetExecutingAssembly();
IEnumerable<MigrationMetadata> migrationList = loader.FindMigrationsIn(asm, string.Empty);
//if this works, there will be at least one migration class because i've included on in this code file
var en = migrationList.GetEnumerator();
int count = 0;
while (en.MoveNext())
count++;
count.ShouldBeGreaterThan(0);
}
public void CanRunMigration()
{
ExecuteWithSupportedProcessors(processor =>
{
var conventions = new MigrationConventions();
var runner = new MigrationRunner(conventions, processor, new TextWriterAnnouncer(System.Console.Out), new StopWatch());
runner.Up(new TestCreateAndDropTableMigration());
processor.TableExists("TestTable").ShouldBeTrue();
runner.Down(new TestCreateAndDropTableMigration());
processor.TableExists("TestTable").ShouldBeFalse();
});
}
public void CanUseScriptsOnAnotherDriveToWorkingDirectory()
{
var scriptOnAnotherDrive = "z" + Path.VolumeSeparatorChar + Path.DirectorySeparatorChar + testSqlScript;
var expression = new ExecuteSqlScriptExpression {
SqlScript = scriptOnAnotherDrive
};
var conventions = new MigrationConventions {
GetWorkingDirectory = () => "c" + Path.VolumeSeparatorChar + Path.DirectorySeparatorChar + "code"
};
expression.ApplyConventions(conventions);
expression.SqlScript.ShouldBe(scriptOnAnotherDrive);
}
public void CanApplyIndexConvention()
{
ExecuteWithSupportedProcessors(
processor =>
{
var conventions = new MigrationConventions();
var runner = new MigrationRunner(conventions, processor);
runner.Up(new TestIndexNamingConvention());
processor.TableExists("Users").ShouldBeTrue();
runner.Down(new TestIndexNamingConvention());
processor.TableExists("Users").ShouldBeFalse();
});
}
public void CanRunMigration()
{
ExecuteWithSupportedProcessors(processor =>
{
var conventions = new MigrationConventions();
var runner = new MigrationRunner(conventions, processor);
runner.Up(new TestCreateAndDropTableMigration());
processor.TableExists("TestTable").ShouldBeTrue();
runner.Down(new TestCreateAndDropTableMigration());
processor.TableExists("TestTable").ShouldBeFalse();
});
}
public void CanApplyIndexConvention()
{
var connection = new SqlConnection(sqlServerConnectionString);
connection.Open();
var processor = new SqlServerProcessor(connection, new SqlServerGenerator());
var conventions = new MigrationConventions();
var runner = new MigrationRunner(conventions, processor);
runner.Up(new TestIndexNamingConvention());
processor.TableExists("Users").ShouldBeTrue();
runner.Down(new TestIndexNamingConvention());
processor.TableExists("Users").ShouldBeFalse();
}
public void CanApplyForeignKeyConvention()
{
ExecuteWithSupportedProcessors(
processor =>
{
var conventions = new MigrationConventions();
var runner = new MigrationRunner(conventions, processor);
runner.Up(new TestForeignKeyNamingConvention());
processor.TableExists("Users").ShouldBeTrue();
processor.ConstraintExists("Users", "FK_Users_GroupId_Groups_GroupId").ShouldBeTrue();
runner.Down(new TestForeignKeyNamingConvention());
processor.TableExists("Users").ShouldBeFalse();
});
}
public void CanApplyForeignKeyConvention()
{
var connection = new SqlConnection(sqlServerConnectionString);
connection.Open();
var processor = new SqlServerProcessor(connection, new SqlServerGenerator());
var conventions = new MigrationConventions();
var runner = new MigrationRunner(conventions, processor);
runner.Up(new TestForeignKeyNamingConvention());
processor.TableExists("Users").ShouldBeTrue();
processor.ConstraintExists( "Users", "FK_Users_GroupId_Groups_GroupId").ShouldBeTrue();
runner.Down(new TestForeignKeyNamingConvention());
processor.TableExists("Users").ShouldBeFalse();
}
public void DoesNotFindsMigrationsInNestedNamepsaceWhenLoadNestedNamespacesDisabled()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new MigrationLoader(conventions, asm, "FluentMigrator.Tests.Integration.Migrations.Nested", false);
List <Type> expected = new List <Type>
{
typeof(Integration.Migrations.Nested.NotGrouped),
};
var migrationList = loader.FindMigrations();
List <Type> actual = migrationList.Select(m => m.Type).ToList();
CollectionAssert.AreEquivalent(expected, actual);
}
public void DoesNotFindsMigrationsInNestedNamepsaceWhenLoadNestedNamespacesDisabled()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new MigrationLoader(conventions, asm, "FluentMigrator.Tests.Integration.Migrations.Nested", false);
List<Type> expected = new List<Type>()
{
typeof(Integration.Migrations.Nested.NotGrouped),
};
var migrationList = loader.FindMigrations();
List<Type> actual = migrationList.Select(m => m.Type).ToList();
CollectionAssert.AreEquivalent(expected, actual);
}
public void CanSilentlyFail()
{
var processor = new Mock<IMigrationProcessor>();
processor.Setup(x => x.Process(It.IsAny<CreateForeignKeyExpression>())).Throws(new Exception("Error"));
processor.Setup(x => x.Process(It.IsAny<DeleteForeignKeyExpression>())).Throws(new Exception("Error"));
var conventions = new MigrationConventions();
var runner = new MigrationRunner(conventions, processor.Object) { SilentlyFail = true };
runner.Up(new TestForeignKeySilentFailure());
runner.CaughtExceptions.Count.ShouldBeGreaterThan(0);
runner.Down(new TestForeignKeySilentFailure());
runner.CaughtExceptions.Count.ShouldBeGreaterThan(0);
}
public void CanFindMigrationsInAssembly()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new MigrationLoader(conventions, asm, "FluentMigrator.Tests.Integration.Migrations.Interleaved.Pass1", null, new AppliedVersions());
SortedList<long, IMigration> migrationList = loader.Migrations;
//if this works, there will be at least one migration class because i've included on in this code file
var en = migrationList.GetEnumerator();
int count = 0;
while (en.MoveNext())
count++;
count.ShouldBeGreaterThan(0);
}
public void VersionDescriptionMigrationOnlyRunOnceEvenIfExistenceChecksReturnFalse()
{
var conventions = new MigrationConventions();
var processor = new Mock <IMigrationProcessor>();
var runner = new Mock <IMigrationRunner>();
var asm = Assembly.GetExecutingAssembly();
runner.SetupGet(r => r.Processor).Returns(processor.Object);
processor.Setup(p => p.ColumnExists(new TestVersionTableMetaData().SchemaName, TestVersionTableMetaData.TABLENAME, "AppliedOn")).Returns(false);
var loader = new VersionLoader(runner.Object, asm, conventions);
loader.LoadVersionInfo();
runner.Verify(r => r.Up(loader.VersionDescriptionMigration), Times.Once());
}
public void VersionSchemaMigrationOnlyRunOnceEvenIfExistenceChecksReturnFalse()
{
var conventions = new MigrationConventions();
var processor = new Mock <IMigrationProcessor>();
var runner = new Mock <IMigrationRunner>();
var asm = Assembly.GetExecutingAssembly();
runner.SetupGet(r => r.Processor).Returns(processor.Object);
processor.Setup(p => p.SchemaExists(It.IsAny <string>())).Returns(false);
var loader = new VersionLoader(runner.Object, asm, conventions);
loader.LoadVersionInfo();
runner.Verify(r => r.Up(loader.VersionSchemaMigration), Times.Once());
}
public void ShouldHandleTransactionlessMigrations()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new DefaultMigrationInformationLoader(conventions, asm, "FluentMigrator.Tests.Unit.DoesHandleTransactionLessMigrations", null);
var list = loader.LoadMigrations().ToList();
list.Count().ShouldBe(2);
list[0].Value.Migration.GetType().ShouldBe(typeof(DoesHandleTransactionLessMigrations.MigrationThatIsTransactionLess));
list[0].Value.TransactionBehavior.ShouldBe(TransactionBehavior.None);
list[0].Value.Version.ShouldBe(1);
list[1].Value.Migration.GetType().ShouldBe(typeof(DoesHandleTransactionLessMigrations.MigrationThatIsNotTransactionLess));
list[1].Value.TransactionBehavior.ShouldBe(TransactionBehavior.Default);
list[1].Value.Version.ShouldBe(2);
}
public MigrationRunner(Assembly assembly, IRunnerContext runnerContext, IMigrationProcessor processor)
{
_migrationAssembly = assembly;
_announcer = runnerContext.Announcer;
Processor = processor;
_stopWatch = runnerContext.StopWatch;
SilentlyFail = false;
CaughtExceptions = null;
Conventions = new MigrationConventions();
if (!string.IsNullOrEmpty(runnerContext.WorkingDirectory))
Conventions.GetWorkingDirectory = () => runnerContext.WorkingDirectory;
VersionLoader = new VersionLoader(this, _migrationAssembly, Conventions);
MigrationLoader = new MigrationLoader(Conventions, _migrationAssembly, runnerContext.Namespace);
ProfileLoader = new ProfileLoader(runnerContext, this, Conventions);
}
public void CanSetupApplicationContext()
{
var applicationContext = "Test context";
var runnerContext = new Mock<IRunnerContext>();
runnerContext.SetupGet(r => r.ApplicationContext).Returns(applicationContext);
var runner = new Mock<IMigrationRunner>();
runner.SetupGet(r => r.Processor.Options).Returns(new TestMigrationProcessorOptions());
runner.SetupGet(r => r.RunnerContext).Returns(runnerContext.Object);
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new VersionLoader(runner.Object, asm, conventions);
var versionTableMetaData = loader.GetVersionTableMetaData();
versionTableMetaData.ApplicationContext.ShouldBe(applicationContext);
}
public void CanFindMigrationsInAssembly()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new MigrationLoader(conventions, asm, "FluentMigrator.Tests.Integration.Migrations.Interleaved.Pass1", null);
SortedList <long, IMigration> migrationList = loader.Migrations;
//if this works, there will be at least one migration class because i've included on in this code file
var en = migrationList.GetEnumerator();
int count = 0;
while (en.MoveNext())
{
count++;
}
count.ShouldBeGreaterThan(0);
}
public void FindsMigrationsInNestedNamespaceWhenLoadNestedNamespacesEnabled()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new DefaultMigrationInformationLoader(conventions, asm, "FluentMigrator.Tests.Integration.Migrations.Nested", true, null);
List <Type> expected = new List <Type>
{
typeof(Integration.Migrations.Nested.NotGrouped),
typeof(Integration.Migrations.Nested.Group1.FromGroup1),
typeof(Integration.Migrations.Nested.Group1.AnotherFromGroup1),
typeof(Integration.Migrations.Nested.Group2.FromGroup2),
};
var migrationList = loader.LoadMigrations();
List <Type> actual = migrationList.Select(m => m.Value.Migration.GetType()).ToList();
CollectionAssert.AreEquivalent(expected, actual);
}
public void FindsMigrationsInNestedNamespaceWhenLoadNestedNamespacesEnabled()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new DefaultMigrationInformationLoader(conventions, asm, "FluentMigrator.Tests.Integration.Migrations.Nested", true, null);
List<Type> expected = new List<Type>
{
typeof(Integration.Migrations.Nested.NotGrouped),
typeof(Integration.Migrations.Nested.Group1.FromGroup1),
typeof(Integration.Migrations.Nested.Group1.AnotherFromGroup1),
typeof(Integration.Migrations.Nested.Group2.FromGroup2),
};
var migrationList = loader.LoadMigrations();
List<Type> actual = migrationList.Select(m => m.Value.Migration.GetType()).ToList();
CollectionAssert.AreEquivalent(expected, actual);
}
public MigrationRunner(ICollection<MigrationAssemblyInfo> assemblyInfos, IRunnerContext runnerContext, IMigrationProcessor processor, bool loadNestedNamespaces)
{
_migrationAssemblies = assemblyInfos;
_announcer = runnerContext.Announcer;
Processor = processor;
_stopWatch = runnerContext.StopWatch;
ApplicationContext = runnerContext.ApplicationContext;
SilentlyFail = false;
CaughtExceptions = null;
Conventions = new MigrationConventions();
if (!string.IsNullOrEmpty(runnerContext.WorkingDirectory))
Conventions.GetWorkingDirectory = () => runnerContext.WorkingDirectory;
VersionLoader = new VersionLoader(this, assemblyInfos, Conventions);
MigrationLoader = new MigrationLoader(Conventions, assemblyInfos, loadNestedNamespaces , runnerContext.Tags);
ProfileLoader = new ProfileLoader(runnerContext, this, Conventions);
}
public MigrationRunner(Assembly assembly, IRunnerContext runnerContext, IMigrationProcessor processor)
{
_migrationAssembly = assembly;
_announcer = runnerContext.Announcer;
Processor = processor;
_stopWatch = runnerContext.StopWatch;
SilentlyFail = false;
CaughtExceptions = null;
Conventions = new MigrationConventions();
ProcessWorkingDirectory(runnerContext);
ProcessAutoReverse(runnerContext);
VersionLoader = new VersionLoader(this, _migrationAssembly, Conventions);
MigrationLoader = new MigrationLoader(Conventions, _migrationAssembly, runnerContext.Namespace);
ProfileLoader = new ProfileLoader(runnerContext, this, Conventions);
}
public MigrationRunner(Assembly assembly, IRunnerContext runnerContext, IMigrationProcessor processor)
{
_migrationAssembly = assembly;
_announcer = runnerContext.Announcer;
Processor = processor;
_stopWatch = runnerContext.StopWatch;
SilentlyFail = false;
CaughtExceptions = null;
Conventions = new MigrationConventions();
if (!string.IsNullOrEmpty(runnerContext.WorkingDirectory))
{
Conventions.GetWorkingDirectory = () => runnerContext.WorkingDirectory;
}
VersionLoader = new VersionLoader(this, _migrationAssembly, Conventions);
MigrationLoader = new MigrationLoader(Conventions, _migrationAssembly, runnerContext.Namespace);
ProfileLoader = new ProfileLoader(runnerContext, this, Conventions);
}
public void CanSetupApplicationContext()
{
var applicationContext = "Test context";
var runnerContext = new Mock <IRunnerContext>();
runnerContext.SetupGet(r => r.ApplicationContext).Returns(applicationContext);
var runner = new Mock <IMigrationRunner>();
runner.SetupGet(r => r.Processor.Options).Returns(new TestMigrationProcessorOptions());
runner.SetupGet(r => r.RunnerContext).Returns(runnerContext.Object);
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new VersionLoader(runner.Object, asm, conventions);
var versionTableMetaData = loader.GetVersionTableMetaData();
versionTableMetaData.ApplicationContext.ShouldBe(applicationContext);
}
public MigrationRunner(Assembly assembly, IRunnerContext runnerContext, IMigrationProcessor processor)
{
_migrationAssembly = assembly;
_announcer = runnerContext.Announcer;
Processor = processor;
_stopWatch = runnerContext.StopWatch;
ApplicationContext = runnerContext.ApplicationContext;
TransactionPerSession = runnerContext.TransactionPerSession;
SilentlyFail = false;
CaughtExceptions = null;
Conventions = new MigrationConventions();
if (!string.IsNullOrEmpty(runnerContext.WorkingDirectory))
Conventions.GetWorkingDirectory = () => runnerContext.WorkingDirectory;
_migrationScopeHandler = new MigrationScopeHandler(Processor);
_migrationValidator = new MigrationValidator(_announcer, Conventions);
VersionLoader = new VersionLoader(this, _migrationAssembly, Conventions);
MigrationLoader = new DefaultMigrationInformationLoader(Conventions, _migrationAssembly, runnerContext.Namespace, runnerContext.NestedNamespaces, runnerContext.Tags);
ProfileLoader = new ProfileLoader(runnerContext, this, Conventions);
}
public void RemoveVersionTableShouldNotRemoveSchemaIfItDidNotOwnTheSchema()
{
var processor = new Mock <IMigrationProcessor>();
var runner = new Mock <IMigrationRunner>();
runner.SetupGet(r => r.Processor).Returns(processor.Object);
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new VersionLoader(runner.Object, asm, conventions);
((TestVersionTableMetaData)loader.VersionTableMetaData).OwnsSchema = false;
processor.Setup(p => p.Process(It.Is <DeleteTableExpression>(expression =>
expression.SchemaName == loader.VersionTableMetaData.SchemaName &&
expression.TableName == loader.VersionTableMetaData.TableName)))
.Verifiable();
loader.RemoveVersionTable();
processor.Verify(p => p.Process(It.IsAny <DeleteSchemaExpression>()), Times.Never());
}
