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)); }