public void SetUp()
{
Connection = new SqlConnection(IntegrationTestOptions.SqlServer2012.ConnectionString);
Processor = new SqlServerProcessor(Connection, new SqlServer2012Generator(), new TextWriterAnnouncer(System.Console.Out), new ProcessorOptions(), new SqlServerDbFactory());
Connection.Open();
Processor.BeginTransaction();
}
public SqlServerProcessorTests()
{
Connection = new SqlConnection(@"server=(local)\sqlexpress;uid=;pwd=;Trusted_Connection=yes;database=FluentMigrator");
Connection.Open();
Processor = new SqlServerProcessor(Connection, new SqlServer2000Generator(), new TextWriterAnnouncer(System.Console.Out), new ProcessorOptions());
}
public void ExecuteWithSqlServer(Action<IMigrationProcessor> test)
{
var connection = new SqlConnection(sqlServerConnectionString);
connection.Open();
var processor = new SqlServerProcessor(connection, new SqlServerGenerator());
test(processor);
}
public static void Run(string connectionString)
{
var firstMigration = typeof(Lucid.Database.Migrations.Y2016.M01.V01);
var assembly = new SingleAssembly(firstMigration.Assembly);
var migrationGenerator = new SqlServer2008Generator();
var announcer = new NullAnnouncer();
var options = new ProcessorOptions();
var dbFactory = new SqlServerDbFactory();
var runnerContext = new RunnerContext(announcer)
{
Database = "SqlServer2008",
Connection = connectionString,
Targets = new string[] { firstMigration.Assembly.FullName },
NestedNamespaces = true,
Namespace = "Lucid.Database.Migrations",
};
using (var connection = new SqlConnection(connectionString))
using (var processor = new SqlServerProcessor(connection, migrationGenerator, announcer, options, dbFactory))
{
var runner = new MigrationRunner(assembly, runnerContext, processor);
runner.MigrateUp();
}
}
public SqlServerProcessorTests()
{
Connection = new SqlConnection(@"server=(local)\sqlexpress;uid=;pwd=;Trusted_Connection=yes;database=FluentMigrator");
Connection.Open();
Processor = new SqlServerProcessor(Connection, new SqlServerGenerator());
}
public void Setup()
{
Connection = new SqlConnection(IntegrationTestOptions.SqlServer2008.ConnectionString);
Processor = new SqlServerProcessor(Connection, new SqlServer2008Generator(), new TextWriterAnnouncer(System.Console.Out), new ProcessorOptions(), new SqlServerDbFactory());
SchemaDumper = new SqlServerSchemaDumper(Processor, new TextWriterAnnouncer(System.Console.Out));
Connection.Open();
}
public SqlServerTestTable(SqlServerProcessor processor, params string[] columnDefinitions)
{
Connection = processor.Connection;
Transaction = processor.Transaction;
Name = "Table" + Guid.NewGuid().ToString("N");
Create(columnDefinitions);
}
public SqlServerTestSequence(SqlServerProcessor processor, string schemaName, string sequenceName)
{
_schemaName = schemaName;
Name = sequenceName;
Connection = (SqlConnection)processor.Connection;
Transaction = (SqlTransaction)processor.Transaction;
Create();
}
public SqlServerTestTable(string table, SqlServerProcessor processor, string schemaName, params string[] columnDefinitions)
{
this.schemaName = schemaName;
Connection = (SqlConnection)processor.Connection;
Transaction = (SqlTransaction)processor.Transaction;
Name = table;
Create(columnDefinitions);
}
private static void ExecuteWithSqlServer(Action<IMigrationProcessor> test, IntegrationTestOptions.DatabaseServerOptions serverOptions)
{
if (!serverOptions.IsEnabled)
return;
var connection = new SqlConnection(serverOptions.ConnectionString);
connection.Open();
var processor = new SqlServerProcessor(connection, new SqlServer2000Generator(), new TextWriterAnnouncer(System.Console.Out), new ProcessorOptions());
test(processor);
}
MigrationRunner getRunner()
{
var connectionString = ConfigurationManager.ConnectionStrings["dahliaSQL"].ConnectionString;
var connection = new SqlConnection(connectionString);
var assembly = typeof(SqlMigrationService).Assembly;
var ns = typeof(SqlMigrationService).Namespace;
var generator = new SqlServer2005Generator();
var processor = new SqlServerProcessor(connection, generator, new NullAnnouncer(), new ProcessorOptions());
return new MigrationRunner(assembly, new RunnerContext(new NullAnnouncer()) { Namespace = ns },
processor);
}
protected static void ExecuteWithSqlServer(Action<IMigrationProcessor> test, IntegrationTestOptions.DatabaseServerOptions serverOptions, Boolean tryRollback)
{
if (!serverOptions.IsEnabled)
return;
var connection = new SqlConnection(serverOptions.ConnectionString);
var processor = new SqlServerProcessor(connection, new SqlServer2000Generator(), new TextWriterAnnouncer(System.Console.Out), new ProcessorOptions());
test(processor);
if (tryRollback && !processor.WasCommitted)
{
processor.RollbackTransaction();
}
}
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();
}
private void EnsureMigration()
{
var connection = new System.Data.SqlClient.SqlConnection(connectionString);
connection.Open();
var processor = new SqlServerProcessor(connection, new SqlServer2000Generator(),
new TextWriterAnnouncer(System.Console.Out), new ProcessorOptions());
var conventions = new MigrationConventions();
var versionRunner = new FluentMigrator.Runner.MigrationVersionRunner(conventions, processor,
new MigrationLoader(conventions), new NullAnnouncer());
//var runner = new MigrationRunner(conventions, processor, new TextWriterAnnouncer(System.Console.Out), new StopWatch());
//runner.Up(new TestCreateAndDropTableMigration());
versionRunner.MigrateUp();
versionRunner = null;
connection = null;
}
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();
}
public static void Main(string[] args)
{
var connection = new SqlConnection("data source=172.16.1.186;UID=lssuser;PWD=password1;initial catalog=lss");
var sb = new StringBuilder();
var textWriter = new StringWriter(sb);
var announcer = new TextWriterAnnouncer(textWriter);
var generator = new SqlServer2008Generator();
var processor = new SqlServerProcessor(connection, generator, announcer, new ProcessorOptions(), new SqlServerDbFactory());
var dumper = new SqlServerSchemaDumper(processor, announcer);
var schema = dumper.ReadDbSchema();
var schemaWriter = new SchemaWriter();
schemaWriter.WriteToFile(schema, "C:\\migration.cs");
}
public void CanReadLongViewDefinition()
{
// Arrange
var create = new CreateTableExpression
{
TableName = "Foo",
Columns =
new List<ColumnDefinition> { new ColumnDefinition { Name = "Id", Type = DbType.Int32 } }
};
IList<ViewDefinition> views;
var createSql = new StringBuilder();
createSql.Append("CREATE VIEW FooView As SELECT Id,");
createSql.Append("'");
createSql.Append(new string('A', 3000));
createSql.Append("'");
createSql.Append(" As LongText1,");
createSql.Append("'");
createSql.Append(new string('B', 3000));
createSql.Append("'");
createSql.Append(" As LongText2");
createSql.Append(" FROM Foo");
// Act
using (var connection = new SqlConnection(ConnectionString))
{
var processor = new SqlServerProcessor(connection, new SqlServer2005Generator(), new DebugAnnouncer(), new ProcessorOptions());
processor.Process(create);
Assert.IsTrue(processor.TableExists(string.Empty, create.TableName), "SqlServer");
processor.Execute(createSql.ToString());
var dumper = new SqlServerSchemaDumper(processor, new DebugAnnouncer());
views = dumper.ReadViewSchema();
processor.CommitTransaction();
}
// Assert
Assert.AreEqual(1, views.Count);
}
public void CallingProcessWithPerformDbOperationExpressionWhenInPreviewOnlyModeWillNotMakeDbChanges()
{
var output = new StringWriter();
var connection = new SqlConnection(IntegrationTestOptions.SqlServer2012.ConnectionString);
var processor = new SqlServerProcessor(
connection,
new SqlServer2012Generator(),
new TextWriterAnnouncer(output),
new ProcessorOptions { PreviewOnly = true },
new SqlServerDbFactory());
bool tableExists;
try
{
var expression =
new PerformDBOperationExpression
{
Operation = (con, trans) =>
{
var command = con.CreateCommand();
command.CommandText = "CREATE TABLE ProcessTestTable (test int NULL) ";
command.Transaction = trans;
command.ExecuteNonQuery();
}
};
processor.Process(expression);
tableExists = processor.TableExists("", "ProcessTestTable");
}
finally
{
processor.RollbackTransaction();
}
tableExists.ShouldBeFalse();
string fmOutput = output.ToString();
Assert.That(fmOutput, Is.StringContaining("/* Performing DB Operation */"));
}
public void CanReadMultipleViews()
{
// Arrange
var create = new CreateTableExpression
{
TableName = "Foo",
Columns =
new List<ColumnDefinition> { new ColumnDefinition { Name = "Id", Type = DbType.Int32 } }
};
IList<ViewDefinition> views;
// Act
using (var connection = new SqlConnection(ConnectionString))
{
var processor = new SqlServerProcessor(connection, new SqlServer2005Generator(), new DebugAnnouncer(), new ProcessorOptions());
processor.Process(create);
Assert.IsTrue(processor.TableExists(string.Empty, create.TableName), "SqlServer");
processor.Execute("CREATE VIEW FooViewC AS SELECT Id FROM Foo");
processor.Execute("CREATE VIEW FooViewB AS SELECT Id FROM Foo");
processor.Execute("CREATE VIEW FooViewA AS SELECT Id FROM Foo");
var dumper = new SqlServerSchemaDumper(processor, new DebugAnnouncer());
views = dumper.ReadViewSchema();
processor.CommitTransaction();
}
// Assert
Assert.AreEqual(3, views.Count);
Assert.AreEqual("FooViewA", views[0].Name);
Assert.AreEqual("FooViewB", views[1].Name);
Assert.AreEqual("FooViewC", views[2].Name);
}
public static void MigrateDown(string connectionString, long version, Stream stream, bool previewOnly)
{
if (version == 0)
{
Console.WriteLine(string.Format("Purging Database"));
Honcho.Migrations.DatabasePurge.Migrate.Execute(connectionString);
Console.WriteLine(string.Format("Database Purge Complete"));
}
else
{
Console.WriteLine(string.Format("Executing Migration Rollback Scripts."));
using (var connection = new SqlConnection(connectionString))
{
IAnnouncer announcer = new NullAnnouncer(); // TextWriterAnnouncer(Console.Out);
var processorOptions = new ProcessorOptions
{
PreviewOnly = previewOnly
};
if (stream != null)
{
announcer = new TextWriterAnnouncer(new StreamWriter(stream));
}
var runnerContext = new RunnerContext(announcer);
var processor = new SqlServerProcessor(connection, new SqlServer2008Generator(), announcer,
processorOptions);
var runner = new MigrationRunner(Assembly.GetAssembly(typeof (Runner)), runnerContext,
processor);
runner.RollbackToVersion(version);
}
Console.WriteLine(string.Format("Migration Rollback Script Execution Complete"));
}
}
public void MigrateUpWithSqlServerProcessorShouldCommitItsTransaction()
{
if (!IntegrationTestOptions.SqlServer2008.IsEnabled)
return;
var connection = new SqlConnection(IntegrationTestOptions.SqlServer2008.ConnectionString);
var processor = new SqlServerProcessor(connection, new SqlServer2008Generator(), new TextWriterAnnouncer(System.Console.Out), new ProcessorOptions(), new SqlServerDbFactory());
MigrationRunner runner = SetupMigrationRunner(processor);
runner.MigrateUp();
try
{
processor.WasCommitted.ShouldBeTrue();
}
finally
{
CleanupTestSqlServerDatabase(connection, processor);
}
}
private static void CleanupTestSqlServerDatabase(SqlConnection connection, SqlServerProcessor origProcessor)
{
if (origProcessor.WasCommitted)
{
connection.Close();
var cleanupProcessor = new SqlServerProcessor(connection, new SqlServer2008Generator(), new TextWriterAnnouncer(System.Console.Out), new ProcessorOptions(), new SqlServerDbFactory());
MigrationRunner cleanupRunner = SetupMigrationRunner(cleanupProcessor);
cleanupRunner.RollbackToVersion(0);
}
else
{
origProcessor.RollbackTransaction();
}
}
public void VersionInfoCreationScriptsOnlyGeneratedOnceInPreviewMode()
{
if (!IntegrationTestOptions.SqlServer2008.IsEnabled)
return;
var connection = new SqlConnection(IntegrationTestOptions.SqlServer2008.ConnectionString);
var processorOptions = new ProcessorOptions { PreviewOnly = true };
var outputSql = new StringWriter();
var announcer = new TextWriterAnnouncer(outputSql){ ShowSql = true };
var processor = new SqlServerProcessor(connection, new SqlServer2008Generator(), announcer, processorOptions, new SqlServerDbFactory());
try
{
var asm = typeof(MigrationRunnerTests).Assembly;
var runnerContext = new RunnerContext(announcer)
{
Namespace = "FluentMigrator.Tests.Integration.Migrations",
PreviewOnly = true
};
var runner = new MigrationRunner(asm, runnerContext, processor);
runner.MigrateUp(1, false);
processor.CommitTransaction();
string schemaName = new TestVersionTableMetaData().SchemaName;
var schemaAndTableName = string.Format("\\[{0}\\]\\.\\[{1}\\]", schemaName, TestVersionTableMetaData.TABLENAME);
var outputSqlString = outputSql.ToString();
var createSchemaMatches = new Regex(string.Format("CREATE SCHEMA \\[{0}\\]", schemaName)).Matches(outputSqlString).Count;
var createTableMatches = new Regex("CREATE TABLE " + schemaAndTableName).Matches(outputSqlString).Count;
var createIndexMatches = new Regex("CREATE UNIQUE CLUSTERED INDEX \\[" + TestVersionTableMetaData.UNIQUEINDEXNAME + "\\] ON " + schemaAndTableName).Matches(outputSqlString).Count;
var alterTableMatches = new Regex("ALTER TABLE " + schemaAndTableName).Matches(outputSqlString).Count;
System.Console.WriteLine(outputSqlString);
createSchemaMatches.ShouldBe(1);
createTableMatches.ShouldBe(1);
alterTableMatches.ShouldBe(2);
createIndexMatches.ShouldBe(1);
}
finally
{
CleanupTestSqlServerDatabase(connection, processor);
}
}
/// <summary>
/// Creates views in Oracle using the <see cref="ViewDefinition.CreateViewSql"/>
/// </summary>
/// <param name="view">The views to be created</param>
private void CreateViews(params ViewDefinition[] view)
{
using (var connection = new SqlConnection(_source.ConnectionString))
{
var processor = new SqlServerProcessor(connection, new SqlServer2005Generator(), new DebugAnnouncer(), new ProcessorOptions());
foreach (var viewDefinition in view)
{
processor.Execute(viewDefinition.CreateViewSql);
}
processor.CommitTransaction();
}
}
/// <summary>
/// Creates tables in source oracle database and asserts that they exist
/// </summary>
/// <param name="expressions">The tables to be created</param>
private void ExecuteMigrations(params IMigrationExpression[] expressions)
{
if (expressions == null)
return;
using (var connection = new SqlConnection(_source.ConnectionString))
{
var processor = new SqlServerProcessor(connection, new SqlServer2005Generator(), new DebugAnnouncer(), new ProcessorOptions());
foreach (var expression in expressions)
{
if (expression is CreateTableExpression)
{
var create = (CreateTableExpression)expression;
processor.Process(create);
Assert.IsTrue(processor.TableExists(string.Empty, create.TableName), "Source " + create.TableName);
}
if (expression is CreateForeignKeyExpression)
{
processor.Process((CreateForeignKeyExpression)expression);
}
if (expression is InsertDataExpression)
{
processor.Process((InsertDataExpression)expression);
}
}
processor.CommitTransaction();
}
}
public void SqlServerMigrationsAreTransactional()
{
var connection = new SqlConnection(sqlServerConnectionString);
connection.Open();
var processor = new SqlServerProcessor(connection, new SqlServerGenerator());
var runner = new MigrationVersionRunner(_conventions, processor, new MigrationLoader(_conventions), typeof(MigrationVersionRunnerTests).Assembly, typeof(InvalidMigration).Namespace);
try
{
runner.MigrateUp();
}
catch
{
}
processor.TableExists("Users").ShouldBeFalse();
}
public SqlServerSchemaDumper(SqlServerProcessor processor, IAnnouncer announcer)
{
Announcer = announcer;
Processor = processor;
}
/// <summary>
/// Creates a single column table using the spplied type and retruns its <see cref="ColumnDefinition"/>
/// </summary>
/// <param name="type">The Sql Server data type to apply to the column</param>
/// <returns>The translated <see cref="ColumnDefinition"/></returns>
private TableDefinition GetTableColumnColumns(string createSql, string name, params IMigrationExpression[] expresions)
{
IList<TableDefinition> tables;
// Act
using (var connection = new SqlConnection(ConnectionString))
{
var processor = new SqlServerProcessor(connection, new SqlServer2005Generator(), new DebugAnnouncer(), new ProcessorOptions());
if (!string.IsNullOrEmpty(createSql))
processor.Execute(createSql);
foreach (var expresion in expresions)
{
if (expresion is CreateTableExpression)
processor.Process((CreateTableExpression)expresion);
if (expresion is CreateIndexExpression)
processor.Process((CreateIndexExpression)expresion);
if (expresion is CreateForeignKeyExpression)
processor.Process((CreateForeignKeyExpression)expresion);
}
Assert.IsTrue(processor.TableExists(string.Empty, name), "SqlServer");
var dumper = new SqlServerSchemaDumper(processor, new DebugAnnouncer());
tables = dumper.ReadDbSchema();
processor.CommitTransaction();
}
if (!string.IsNullOrEmpty(createSql))
tables.Count.ShouldBe(1);
return tables.Where(t => t.Name == name).FirstOrDefault();
}
private static void ExecuteWithSqlServer(IntegrationTestOptions.DatabaseServerOptions serverOptions, TextWriterAnnouncer announcer, SqlServer2005Generator generator, Action<IMigrationProcessor> test, bool tryRollback)
{
using (var connection = new SqlConnection(serverOptions.ConnectionString))
{
var processor = new SqlServerProcessor(connection, generator, announcer, new ProcessorOptions(), new SqlServerDbFactory());
test(processor);
if (tryRollback && !processor.WasCommitted)
{
processor.RollbackTransaction();
}
}
}
public void SetUp()
{
Connection = new SqlConnection(IntegrationTestOptions.SqlServer.ConnectionString);
Processor = new SqlServerProcessor(Connection, new SqlServer2000Generator(), new TextWriterAnnouncer(System.Console.Out), new ProcessorOptions());
}
