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

            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 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, new AppliedVersions());

            loader.LoadNestedNamespaces.ShouldBe(false);
        }

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

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

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