C# Migrator.FetchMigrations方法代码示例

        public void VerifyPendingMigrationsAreFoundForSpecificModule()
        {
            IVersioning versioning = GetVersioning(false, false, false);

            Migrator migrator = new Migrator("", ProviderNames.SqlServer2008, new MigrationOptions { ModuleSelector = m => m == Migration2.Module });
            migrator.UseCustomVersioning(versioning);
            IMigrationBatch batch = migrator.FetchMigrations(typeof(Migration1).Assembly);

            Assert.AreEqual(1, batch.Count, string.Format(CultureInfo.CurrentCulture, "Only one migration for the module named '{0}' exists.", Migration2.Module));
        }

        public int VerifyPendingMigrationsAreFound(bool migration1IsContained, bool migration2IsContained, bool migration3IsContained)
        {
            IVersioning versioning = GetVersioning(migration1IsContained, migration2IsContained, migration3IsContained);

            Migrator migrator = new Migrator("", ProviderNames.SqlServer2008);
            migrator.UseCustomVersioning(versioning);
            IMigrationBatch batch = migrator.FetchMigrations(typeof(Migration1).Assembly);

            versioning.VerifyAllExpectations();
            return batch.Count;
        }

        public void MigratorUsesModuleSpecificTimestampProvider()
        {
            var migrator = new Migrator("not-used", ProviderNames.SqlServer2005);
            var versioning = MockRepository.GenerateStub<IVersioning>();
            versioning.Expect(v => v.ExecutedMigrations).Return(Enumerable.Empty<IMigrationMetadata>()); // pretend, no migrations ran so far
            migrator.UseCustomVersioning(versioning);

            IMigrationBatch batch = migrator.FetchMigrations(_timestampModuleTestAssembly);

            Assert.AreEqual(4, batch.ScheduledMigrations.Count);

            IScheduledMigrationMetadata migration = batch.ScheduledMigrations.Single(m => m.ModuleName == MigrationExportAttribute.DefaultModuleName);
            Assert.AreEqual(1, migration.Timestamp);

            migration = batch.ScheduledMigrations.Single(m => m.ModuleName == "NonDefaultModuleTreatedWithDefaultTimestampProvider");
            Assert.AreEqual(23, migration.Timestamp);

            migration = batch.ScheduledMigrations.Single(m => m.ModuleName == "ModuleA");
            Assert.AreEqual(201110251455L, migration.Timestamp);

            migration = batch.ScheduledMigrations.Single(m => m.ModuleName == "ModuleB");
            Assert.AreEqual(201211171825L, migration.Timestamp);
        }

        public void TestCustomBootstrapping()
        {
            // use a Module selection to verify that the bootstrapping is still considering *all* migrations
            _options.ModuleSelector = moduleName => moduleName == Migration2.Module;
            Migrator migrator = new Migrator(ConnectionString, ProviderName, _options);

            IBootstrapper bootstrapper = MockRepository.GenerateStrictMock<IBootstrapper>();
            bootstrapper.Expect(b => b.BeginBootstrapping(null, null)).IgnoreArguments();
            for (int i = 0; i < Migrations.Count; i++) // assume that all migrations were already performed
            {
                long timestamp = Timestamps[i];
                bootstrapper.Expect(b => b.IsContained(Arg<IMigrationMetadata>.Matches(m => m.Timestamp == timestamp))).Return(true);
            }
            bootstrapper.Expect(b => b.EndBootstrapping(null, null)).IgnoreArguments();
            migrator.UseCustomBootstrapping(bootstrapper);

            IMigrationBatch batch = migrator.FetchMigrations(typeof(Migration1).Assembly);
            CollectionAssert.IsEmpty(batch.ScheduledMigrations, "All migrations should be viewed as already run.");
            CollectionAssert.IsEmpty(batch.UnidentifiedMigrations, "There should be no unidentified migrations.");
            batch.Execute(); // should have no effect as no migrations are scheduled

            migrator.MigrateAll(typeof(Migration1).Assembly); // should have no effect as no migrations are scheduled

            // assert Migration1 table was *not* created
            DataTable table = GetTable(new Migration1().Tables[0].Name);
            Assert.IsNull(table);

            // assert Versioning table has necessary entries
            DataTable versioningTable = GetTable(_options.VersioningTableName);
            Assert.AreEqual(Migrations.Count, versioningTable.Rows.Count, "The versioning table is missing entries.");

            bootstrapper.VerifyAllExpectations();
        }

        public void TestUnidentifiedMigrations()
        {
            if (ProviderName == ProviderNames.Teradata || ProviderName == ProviderNames.TeradataOdbc ||
                ProviderName == ProviderNames.Oracle || ProviderName == ProviderNames.OracleOdbc) return; // for some reason, the ODBC data adapter updating does not work

            // migrate to 1 in order to create a versioning table
            var migrator = new Migrator(ConnectionString, ProviderName, _options);
            IMigrationBatch batch = migrator.FetchMigrationsTo(typeof(Migration1).Assembly, Timestamps[0]);
            Assert.AreEqual(0, batch.UnidentifiedMigrations.Count);
            batch.Execute();

            // insert unidentified migrations into the versioning table
            DataTable versioningTable = GetTable(_options.VersioningTableName);
            const long timestamp = 123456L;
            const string moduleName = "Test";
            const string tag = "This migration is not known to the application.";
            versioningTable.Rows.Add(timestamp, moduleName, tag);
            SaveTable(versioningTable);

            // verify if the UnidentifiedMigrations is populated correctly
            batch = migrator.FetchMigrations(typeof(Migration1).Assembly);
            Assert.AreEqual(1, batch.UnidentifiedMigrations.Count);
            Assert.AreEqual(timestamp, batch.UnidentifiedMigrations[0].Timestamp);
            Assert.AreEqual(moduleName, batch.UnidentifiedMigrations[0].ModuleName);
            Assert.AreEqual(tag, batch.UnidentifiedMigrations[0].Tag);
        }

        public void TestOnlyFetchingMigrationsDoesNotCreateVersioningTable()
        {
            _options.VersioningTableName = "My Versioning Table"; // test overriding the default versioning table name
            var migrator = new Migrator(ConnectionString, ProviderName, _options);
            IMigrationBatch batch = migrator.FetchMigrations(typeof(Migration1).Assembly);
            Assert.AreEqual(Timestamps.Count, batch.ScheduledMigrations.Count);

            DataTable versioningTable = GetTable(_options.VersioningTableName);
            Assert.IsNull(versioningTable, "Migrator.IsUpToDate should not have any side-effects. In particualar, it should *not* create a versioning table. This allows for being able to check the up-to-dateness of a db without having the privilege to create tables.");
        }

        public void TestMigration1SucceededByAllOtherMigrations()
        {
            // execute Migration1
            var migrator = new Migrator(ConnectionString, ProviderName, _options);
            Assembly assemblyContainingMigrations = typeof(Migration1).Assembly;
            migrator.MigrateTo(assemblyContainingMigrations, Timestamps[0]);

            // execute all other migrations
            migrator = new Migrator(ConnectionString, ProviderName, _options);
            migrator.MigrateAll(assemblyContainingMigrations);

            // make sure there are no more migrations to run
            IMigrationBatch batch = migrator.FetchMigrations(assemblyContainingMigrations);
            Assert.AreEqual(0, batch.ScheduledMigrations.Count);

            VerifyResultsOfAllMigrations();
        }

        public void MigratorUsesModuleSpecificTimestampProvider()
        {
            var migrator = new Migrator("not-used", DbPlatform.SqlServer2005);
            var versioning = A.Fake<IVersioning>();
            A.CallTo(() => versioning.ExecutedMigrations).Returns(Enumerable.Empty<IMigrationMetadata>()); // pretend, no migrations ran so far
            migrator.UseCustomVersioning(versioning);

            IMigrationBatch batch = migrator.FetchMigrations(_timestampModuleTestAssembly);

            Assert.AreEqual(4, batch.Steps.Count);

            IMigrationStepMetadata step = batch.Steps.Single(m => m.ModuleName == MigrationExportAttribute.DefaultModuleName);
            Assert.AreEqual(1, step.Migrations.Single().Timestamp);

            step = batch.Steps.Single(m => m.ModuleName == "NonDefaultModuleTreatedWithDefaultTimestampProvider");
            Assert.AreEqual(23, step.Migrations.Single().Timestamp);

            step = batch.Steps.Single(m => m.ModuleName == "ModuleA");
            Assert.AreEqual(201110251455L, step.Migrations.Single().Timestamp);

            step = batch.Steps.Single(m => m.ModuleName == "ModuleB");
            Assert.AreEqual(201211171825L, step.Migrations.Single().Timestamp);
        }