MigSharp.Process.MigrationSelector.GetMigrationsTo C# (CSharp) Method

        public void GetMigrationsTo(long timestamp, Predicate<IMigrationMetadata> migrationSelector,
            out IEnumerable<ApplicableMigration> applicableMigrations, out IEnumerable<IMigrationMetadata> unidentifiedMigrations)
        {
            IEnumerable<ImportedMigration> moduleMigrations = _importedMigrations.Where(m => migrationSelector(m.Metadata));

            var comparer = new MigrationMetadataComparer();
            var applicableUpMigrations = new List<ApplicableMigration>(
                moduleMigrations.Where(m => m.Metadata.Timestamp <= timestamp &&
                                            !_executedMigrations.Any(x => comparer.Equals(x, m.Metadata)))
                    .OrderBy(m => m.Metadata.Timestamp)
                    .Select(m => new ApplicableMigration(m, MigrationDirection.Up)));

            var applicableDownMigrations = new List<ApplicableMigration>(
                moduleMigrations.Where(m => m.Metadata.Timestamp > timestamp &&
                                            _executedMigrations.Any(x => comparer.Equals(x, m.Metadata)))
                    .OrderByDescending(m => m.Metadata.Timestamp)
                    .Select(m => new ApplicableMigration(m, MigrationDirection.Down)));

            if (applicableDownMigrations.Any(m => !(m.Migration.Implementation is IReversibleMigration)))
            {
                throw new IrreversibleMigrationException();
            }
            int countUp = applicableUpMigrations.Count;
            int countDown = applicableDownMigrations.Count;
            Log.Info("Found {0} (up: {1}, down: {2}) applicable migration(s)", countUp + countDown, countUp, countDown);
            applicableMigrations = applicableDownMigrations.Concat(applicableUpMigrations); // order matters!

            unidentifiedMigrations = new List<IMigrationMetadata>(
                from m in _executedMigrations
                where !_importedMigrations.Any(a => a.Metadata.ModuleName == m.ModuleName &&
                                                    a.Metadata.Timestamp == m.Timestamp)
                orderby m.Timestamp
                select m);
            if (unidentifiedMigrations.Any())
            {
                Log.Warning("Found {0} migration(s) that were executed in the database but are not contained in the application.", unidentifiedMigrations.Count());
            }
        }

        public void TestGapsAreFound()
        {
            var migration = A.Fake<IMigration>();
            ImportedMigration[] importedMigrations =
                {
                    new ImportedMigration(migration, new MigrationMetadata(1, DefaultModuleName, null), false),
                    new ImportedMigration(migration, new MigrationMetadata(2, DefaultModuleName, null), false),
                    new ImportedMigration(migration, new MigrationMetadata(3, DefaultModuleName, null), false),
                };
            IMigrationMetadata[] executedMigrations =
                {
                    new MigrationMetadata(1, DefaultModuleName, null),
                    new MigrationMetadata(3, DefaultModuleName, null),
                };

            var selector = new MigrationSelector(importedMigrations, executedMigrations);

            IEnumerable<ApplicableMigration> applicableMigrations;
            IEnumerable<IMigrationMetadata> unidentifiedMigrations;
            selector.GetMigrationsTo(long.MaxValue, m => true, out applicableMigrations, out unidentifiedMigrations);

            Assert.AreEqual(1, applicableMigrations.Count());
            Assert.AreEqual(2, applicableMigrations.First().Migration.Metadata.Timestamp);
            Assert.AreEqual(MigrationDirection.Up, applicableMigrations.First().Direction);
            CollectionAssert.IsEmpty(unidentifiedMigrations);
        }