public void RollbackToVersion(long version, bool useAutomaticTransactionManagement)
{
var availableMigrations = MigrationLoader.LoadMigrations();
var migrationsToRollback = new List <IMigrationInfo>();
foreach (long appliedVersion in VersionLoader.VersionInfo.AppliedMigrations())
{
IMigrationInfo migrationInfo;
if (availableMigrations.TryGetValue(appliedVersion, out migrationInfo))
{
migrationsToRollback.Add(migrationInfo);
}
}
foreach (IMigrationInfo migrationInfo in migrationsToRollback)
{
if (version >= migrationInfo.Version)
{
continue;
}
ApplyMigrationDown(migrationInfo, useAutomaticTransactionManagement && migrationInfo.TransactionBehavior == TransactionBehavior.Default);
}
VersionLoader.LoadVersionInfo();
if (version == 0 && !VersionLoader.VersionInfo.AppliedMigrations().Any())
{
VersionLoader.RemoveVersionTable();
}
}
public void MigrateUp(bool useAutomaticTransactionManagement)
{
var migrations = MigrationLoader.LoadMigrations();
using (IMigrationScope scope = _migrationScopeHandler.CreateOrWrapMigrationScope(useAutomaticTransactionManagement && TransactionPerSession))
{
ApplyMaintenance(MigrationStage.BeforeAll, useAutomaticTransactionManagement);
foreach (var pair in migrations)
{
ApplyMaintenance(MigrationStage.BeforeEach, useAutomaticTransactionManagement);
ApplyMigrationUp(pair.Value, useAutomaticTransactionManagement && pair.Value.TransactionBehavior == TransactionBehavior.Default);
ApplyMaintenance(MigrationStage.AfterEach, useAutomaticTransactionManagement);
}
ApplyMaintenance(MigrationStage.BeforeProfiles, useAutomaticTransactionManagement);
ApplyProfiles();
ApplyMaintenance(MigrationStage.AfterAll, useAutomaticTransactionManagement);
scope.Complete();
}
VersionLoader.LoadVersionInfo();
}
public void ListMigrations()
{
IVersionInfo currentVersionInfo = this.VersionLoader.VersionInfo;
long currentVersion = currentVersionInfo.Latest();
_announcer.Heading("Migrations");
foreach (KeyValuePair <long, IMigrationInfo> migration in MigrationLoader.LoadMigrations())
{
string migrationName = migration.Value.GetName();
bool isCurrent = migration.Key == currentVersion;
string message = string.Format("{0}{1}",
migrationName,
isCurrent ? " (current)" : string.Empty);
if (isCurrent)
{
_announcer.Emphasize(message);
}
else
{
_announcer.Say(message);
}
}
}
public void ListMigrations()
{
var currentVersionInfo = this.VersionLoader.VersionInfo;
var currentVersion = currentVersionInfo.Latest();
_announcer.Heading("Migrations");
foreach (var migration in MigrationLoader.LoadMigrations())
{
var migrationName = migration.Value.GetName();
var status = GetStatus(migration, currentVersion);
var statusString = string.Join(", ", GetStatusStrings(status));
var message = $"{migrationName}{(string.IsNullOrEmpty(statusString) ? string.Empty : $" ({statusString})")}";
var isCurrent = (status & MigrationStatus.AppliedMask) == MigrationStatus.Current;
var isBreaking = (status & MigrationStatus.Breaking) == MigrationStatus.Breaking;
if (isCurrent || isBreaking)
{
_announcer.Emphasize(message);
}
else
{
_announcer.Say(message);
}
}
public void Rollback(int steps, bool useAutomaticTransactionManagement)
{
var availableMigrations = MigrationLoader.LoadMigrations();
var migrationsToRollback = new List <IMigrationInfo>();
foreach (long version in VersionLoader.VersionInfo.AppliedMigrations())
{
IMigrationInfo migrationInfo;
if (availableMigrations.TryGetValue(version, out migrationInfo))
{
migrationsToRollback.Add(migrationInfo);
}
}
using (IMigrationScope scope = _migrationScopeHandler.CreateOrWrapMigrationScope(useAutomaticTransactionManagement && TransactionPerSession))
{
foreach (IMigrationInfo migrationInfo in migrationsToRollback.Take(steps))
{
ApplyMigrationDown(migrationInfo, useAutomaticTransactionManagement && migrationInfo.TransactionBehavior == TransactionBehavior.Default);
}
scope.Complete();
}
VersionLoader.LoadVersionInfo();
if (!VersionLoader.VersionInfo.AppliedMigrations().Any())
{
VersionLoader.RemoveVersionTable();
}
}
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);
}
private IEnumerable <IMigrationInfo> GetUpMigrationsToApply(long version)
{
var migrations = MigrationLoader.LoadMigrations();
return(from pair in migrations
where IsMigrationStepNeededForUpMigration(pair.Key, version)
select pair.Value);
}
private IEnumerable <IMigrationInfo> GetUpMigrationsToApply(long startVersion, long targetVersion)
{
var migrations = MigrationLoader.LoadMigrations();
return(from pair in migrations
where pair.Key >= startVersion && pair.Key <= targetVersion
select pair.Value);
}
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 bool HasMigrationsToApplyUp(long?version = null)
{
if (version.HasValue)
{
return(GetUpMigrationsToApply(version.Value).Any());
}
return(MigrationLoader.LoadMigrations().Any(mi => !VersionLoader.VersionInfo.HasAppliedMigration(mi.Key)));
}
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 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);
}
private IEnumerable <IMigrationInfo> GetDownMigrationsToApply(long targetVersion)
{
var migrations = MigrationLoader.LoadMigrations();
var migrationsToApply = (from pair in migrations
where IsMigrationStepNeededForDownMigration(pair.Key, targetVersion)
select pair.Value);
return(migrationsToApply.OrderByDescending(x => x.Version));
}
private IEnumerable <IMigrationInfo> GetDownMigrationsToApply(long startVersion, long targetVersion)
{
var migrations = MigrationLoader.LoadMigrations();
var migrationsToApply = (from pair in migrations
where pair.Key <= startVersion && pair.Key >= targetVersion
select pair.Value)
.ToList();
return(migrationsToApply.OrderByDescending(x => x.Version));
}
public void ValidateVersionOrder()
{
var unappliedVersions = MigrationLoader.LoadMigrations().Where(kvp => MigrationVersionLessThanGreatestAppliedMigration(kvp.Key)).ToList();
if (unappliedVersions.Any())
{
throw new VersionOrderInvalidException(unappliedVersions);
}
_announcer.Say("Version ordering valid.");
}
public void MigrateUp(bool useAutomaticTransactionManagement)
{
var migrations = MigrationLoader.LoadMigrations();
foreach (var pair in migrations)
{
ApplyMigrationUp(pair.Value, useAutomaticTransactionManagement && pair.Value.TransactionBehavior == TransactionBehavior.Default);
}
ApplyProfiles();
VersionLoader.LoadVersionInfo();
}
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 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 RollbackToVersion(long version, bool useAutomaticTransactionManagement)
{
var availableMigrations = MigrationLoader.LoadMigrations();
var migrationsToRollback = new List <IMigrationInfo>();
foreach (long appliedVersion in VersionLoader.VersionInfo.AppliedMigrations())
{
IMigrationInfo migrationInfo;
if (availableMigrations.TryGetValue(appliedVersion, out migrationInfo))
{
migrationsToRollback.Add(migrationInfo);
}
}
using (IMigrationScope scope = _migrationScopeHandler.CreateOrWrapMigrationScope(useAutomaticTransactionManagement && TransactionPerSession))
{
try
{
foreach (IMigrationInfo migrationInfo in migrationsToRollback)
{
if (version >= migrationInfo.Version)
{
continue;
}
ApplyMigrationDown(migrationInfo, useAutomaticTransactionManagement && migrationInfo.TransactionBehavior == TransactionBehavior.Default);
}
scope.Complete();
}
catch
{
if (scope.IsActive)
{
scope.Cancel(); // SQLAnywhere needs explicit call to rollback transaction
}
throw;
}
}
VersionLoader.LoadVersionInfo();
if (version == 0 && !VersionLoader.VersionInfo.AppliedMigrations().Any())
{
VersionLoader.RemoveVersionTable();
}
}
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 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 MigrateUp(bool useAutomaticTransactionManagement)
{
var migrations = MigrationLoader.LoadMigrations();
using (IMigrationScope scope = _migrationScopeHandler.CreateOrWrapMigrationScope(useAutomaticTransactionManagement && TransactionPerSession))
{
try
{
ApplyMaintenance(MigrationStage.BeforeAll, useAutomaticTransactionManagement);
foreach (var pair in migrations)
{
ApplyMaintenance(MigrationStage.BeforeEach, useAutomaticTransactionManagement);
ApplyMigrationUp(pair.Value, useAutomaticTransactionManagement && pair.Value.TransactionBehavior == TransactionBehavior.Default);
ApplyMaintenance(MigrationStage.AfterEach, useAutomaticTransactionManagement);
}
ApplyMaintenance(MigrationStage.BeforeProfiles, useAutomaticTransactionManagement);
ApplyProfiles();
ApplyMaintenance(MigrationStage.AfterAll, useAutomaticTransactionManagement);
scope.Complete();
}
catch
{
if (scope.IsActive)
{
scope.Cancel(); // SQLAnywhere needs explicit call to rollback transaction
}
throw;
}
}
VersionLoader.LoadVersionInfo();
}
public void DoesNotFindsMigrationsInNestedNamepsaceWhenLoadNestedNamespacesDisabled()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new MigrationLoader(conventions, asm, "FluentMigrator.Tests.Integration.Migrations.Nested", false, null);
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 HandlesNotFindingMigrations()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new MigrationLoader(conventions, asm, "FluentMigrator.Tests.Unit.EmptyNamespace", null);
var list = loader.FindMigrations();
Assert.That(list, Is.Not.Null);
Assert.That(list.Count(), Is.EqualTo(0));
}
public void FindsMigrationsInNestedNamepsaceWhenLoadNestedNamespacesEnabled()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new MigrationLoader(conventions, asm, "FluentMigrator.Tests.Integration.Migrations.Nested", true, null, new AppliedVersions());
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.FindMigrations();
List<Type> actual = migrationList.Select(m => m.Type).ToList();
CollectionAssert.AreEquivalent(expected, actual);
}
public void DoesFindMigrationsThatHaveMatchingTags()
{
var asm = Assembly.GetExecutingAssembly();
var migrationType = typeof(TaggedMigraion);
var tagsToMatch = new[] { "UK", "Production" };
var conventionsMock = new Mock<IMigrationConventions>();
conventionsMock.SetupGet(m => m.GetMetadataForMigration).Returns(DefaultMigrationConventions.GetMetadataForMigration);
conventionsMock.SetupGet(m => m.TypeIsMigration).Returns(t => true);
conventionsMock.SetupGet(m => m.TypeHasTags).Returns(t => migrationType == t);
conventionsMock.SetupGet(m => m.TypeHasMatchingTags).Returns((type, tags) => (migrationType == type && tagsToMatch == tags));
var loader = new MigrationLoader(conventionsMock.Object, asm, migrationType.Namespace, tagsToMatch, new AppliedVersions());
var expected = new List<Type> { typeof(UntaggedMigration), migrationType };
var actual = loader.FindMigrations().Select(m => m.Type).ToList();
CollectionAssert.AreEquivalent(expected, actual);
}
public void HandlesMigrationThatDoesNotInheritFromMigrationBaseClass()
{
var conventions = new MigrationConventions();
var asm = Assembly.GetExecutingAssembly();
var loader = new MigrationLoader(conventions, asm, "FluentMigrator.Tests.Unit.DoesNotInheritFromBaseClass", null);
Assert.That(loader.Migrations.Count(), Is.EqualTo(1));
}
