public void OracleMigration_WhenDataSourceIsValidTnsAliasName_Success()
{
var databaseType = SupportedDatabaseTypes.Oracle;
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
inMemoryOverrideConfig["database:dataSource"] = BaseConfig.InContainer ? "TNSTEST_INDOCKER" : "TNSTEST";
inMemoryOverrideConfig["database:connectionTimeoutInSecs"] = "5";
var expectedDataSource = inMemoryOverrideConfig["database:dataSource"];
var provider = MigrationBuilder.BuildMigration(databaseType, inMemoryOverrideConfig, sp => sp.AddOracleDbProvider());
using (var scope = provider.CreateScope())
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
var versionTable = scope.ServiceProvider.GetService <IVersionTableMetaData>();
var dbconfig = scope.ServiceProvider.GetDbConfig();
dbconfig.Datasource.Should().Be(inMemoryOverrideConfig["database:dataSource"]);
dbconfig
.GetDbProviderFactory(true).CreateConnection()
.DataSource.Should().Be(expectedDataSource);
migrationRunner.MigrateUp();
migrationRunner.MigrateDown(0);
migrationRunner.DropSchema(versionTable);
}
}
public void SelectCountTestOneTableOnly(SupportedDatabaseTypes databaseTypes, string schema, string expectedSql)
{
var dbConfig = OverrideConfig.CreateTestDbConfig(databaseTypes, schema);
var useSchema = !string.IsNullOrEmpty(schema);
expectedSql = string.Format(expectedSql, dbConfig.Schema);
var builder = dbConfig.CreateSqlBuilder();
var select = builder.Select();
var sqls = new List <string>
{
select
.Count()
.OnSchema(setSchemaNameIfExpressionIsEvaluatedToTrue: () => useSchema)
.Fields <Entity>(x => x.F(item => item.Name))
.Fields <Entity>(x => x.F(item => item.Description))
.Where <Entity>(x => x.WP(item => item.Id, "IdParam"))
.Where <Entity>(x => x.WV(item => item.Name, "Arild"))
.Build(),
select
.Count()
.OnSchema(setSchemaNameIfExpressionIsEvaluatedToTrue: () => useSchema)
.From <Entity>()
.Fields <Entity>(x => x.F(item => item.Name))
.Fields <Entity>(x => x.F(item => item.Description))
.Where <Entity>(x => x.WP(item => item.Id, "IdParam"))
.Where <Entity>(x => x.WV(item => item.Name, "Arild"))
.Build()
};
foreach (var sql in sqls)
{
sql.Should().Be(expectedSql);
}
}
public async Task PublishSubscribe_Event_Success(SupportedDatabaseTypes databaseType)
{
var scope = OverrideConfig.GetServiceCollection(databaseType)
.BuildServiceProvider()
.CreateScope();
var mqttClient = scope.ServiceProvider.GetRequiredService <MqttClient>();
var bus = scope.ServiceProvider.GetRequiredService <IBus>();
var repository = scope.ServiceProvider.GetRequiredService <IEventRepository>();
var dbConnection = scope.ServiceProvider.GetRequiredService <IDbConnection>();
await SubscriptionRegistration.SetupSubscriptions(bus);
mqttClient.Setup(scope.ServiceProvider);
var eventContract = new EventContract();
eventContract.PingPongs = 5;
await bus.Advanced.Topics.Publish(EventContract.Topic, eventContract);
await Tools.WaitUntilSuccess(async() =>
{
var selectedEvent = await repository.SelectEvent(dbConnection, eventContract.Id); // At some point, the event should have been sent through the message broker and handled by the message handler.
selectedEvent.Id.Should().Be(eventContract.Id); // Verify that the message handler has received and handled the event for the first time. The message handler will publish the event again, but having set the Stop event property to true.
selectedEvent.Stop.Should().BeTrue(); // Verify that the message handler published and handled the event again by marking the event as stopped.
});
await repository.DeleteEvent(dbConnection, eventContract.Id); // Finished with the event, delete it.
}
public void MigrationWithExecutorExtensionWithVersionInfo_Success(SupportedDatabaseTypes databaseType)
{
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
var configuration = new ConfigurationBuilder()
.AddDbToolsExampleConfiguration(databaseType)
.AddInMemoryCollection(inMemoryOverrideConfig)
.Build();
var serviceProvider = new ServiceCollection()
.AddSingleton <IConfiguration>(provider => configuration)
.AddDefaultDbMigrationConfig()
.AddOracleDbProvider()
.AddPostgresDbProvider()
.BuildServiceProvider();
var dbConfig = serviceProvider.GetService <IDbMigrationConfig>();
var assemblies = MigrationBuilder.MigrationAssemblies.ToList();
assemblies.Add(typeof(ExampleVersionTableMetaData).Assembly);
var runner = dbConfig.GetMigrationRunner(assemblies);
try
{
runner.MigrateUp();
VerifyExpectedVersionInfoTable(serviceProvider, nameof(ExampleVersionTableMetaData));
}
finally
{
dbConfig.DropSchema(assemblies);
}
}
public void Migration_NoConnection_NoAccessToDatabaseIsDone(SupportedDatabaseTypes databaseType)
{
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
inMemoryOverrideConfig.TryGetValue("database:schema", out var schema);
var logFile = $"Migration_Success_{schema}_{databaseType}.sql";
inMemoryOverrideConfig.Add("Logging:Migration:ShowSql", "True");
inMemoryOverrideConfig.Add("Logging:Migration:ShowElapsedTime", "True");
inMemoryOverrideConfig.Add("Logging:Migration:File", logFile);
inMemoryOverrideConfig.Add("database:adminPassword", "invalid");
var provider = MigrationBuilder.BuildMigration(databaseType, inMemoryOverrideConfig,
collection =>
collection.Configure <RunnerOptions>(opt => opt.NoConnection = true));
using (var scope = provider.CreateScope())
{
try
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
migrationRunner.MigrateUp();
migrationRunner.MigrateDown(0);
}
finally
{
scope.ServiceProvider.DropSchema();
}
}
ShowLogFileContent(logFile);
}
public void Migration_PreviewOnlyAndInvalidAdminPassword_ShouldThrowDatabaseException(SupportedDatabaseTypes databaseType)
{
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
inMemoryOverrideConfig.TryGetValue("database:schema", out var schema);
var logFile = $"Migration_Success_{schema}_{databaseType}.sql";
inMemoryOverrideConfig.Add("Logging:Migration:ShowSql", "True");
inMemoryOverrideConfig.Add("Logging:Migration:ShowElapsedTime", "True");
inMemoryOverrideConfig.Add("Logging:Migration:File", logFile);
inMemoryOverrideConfig["database:adminPassword"] = "******";
var provider = MigrationBuilder.BuildMigration(databaseType, inMemoryOverrideConfig,
collection =>
collection.Configure <ProcessorOptions>(opt => opt.PreviewOnly = true));
using (var scope = provider.CreateScope())
{
Action action = () => scope.ServiceProvider.GetService <IMigrationRunner>().MigrateUp();
if (databaseType == SupportedDatabaseTypes.Postgres)
{
action.Should().Throw <PostgresException>().Which.SqlState.Should().Be("28P01");
}
if (databaseType == SupportedDatabaseTypes.Oracle)
{
action.Should().Throw <OracleException>().Which.Number.Should().Be(1017);
}
}
ShowLogFileContent(logFile);
}
public void Migration_Logging_Test()
{
var databaseType = SupportedDatabaseTypes.Oracle;
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
var logFile = "Migration_Logging_Test.sql";
inMemoryOverrideConfig.Add("Logging:Migration:ShowSql", "True");
inMemoryOverrideConfig.Add("Logging:Migration:ShowElapsedTime", "True");
inMemoryOverrideConfig.Add("Logging:Migration:File", logFile);
var provider = MigrationBuilder.BuildMigration(databaseType, inMemoryOverrideConfig);
using (var scope = provider.CreateScope())
{
var processor = scope.ServiceProvider.GetRequiredService <IExtendedMigrationProcessorOracle>();
processor.Process(new PerformDBOperationExpression()
{
Operation = ((connection, transaction) => connection.Execute("select 0 from dual"))
});
processor.ProcessSql("select 1 from dual");
processor.ProcessSql("select 2 from dual");
processor.ProcessSql("select 3 from dual");
}
ShowLogFileContent(logFile);
}
public void Migrate(Action <IServiceProvider> testFunction, string dataSource = null, string schemaName = null)
{
var schemaPrefixId = "EX";
var schemaPrefixUniqueId = "utvoja+0000000002506";
var databaseType = SupportedDatabaseTypes.Oracle;
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, schemaName ?? OverrideConfig.NewRandomSchema);
inMemoryOverrideConfig.TryGetValue("database:schema", out var schema);
var logFile = $"Migration_Success_{schema}_{databaseType}.sql";
inMemoryOverrideConfig.Add("Logging:Migration:ShowSql", "True");
inMemoryOverrideConfig.Add("Logging:Migration:ShowElapsedTime", "True");
inMemoryOverrideConfig.Add("Logging:Migration:File", logFile);
inMemoryOverrideConfig.Add("database:schemaName", schemaPrefixId);
inMemoryOverrideConfig.Add("database:schemaprefix:id", schemaPrefixId);
inMemoryOverrideConfig.Add("database:migration:schemaprefix:uniqueId", schemaPrefixUniqueId);
inMemoryOverrideConfig.Add("database:schemaprefix:tables:person:shortName", "sn");
inMemoryOverrideConfig.Add("database:schemaprefix:tables:person:globalId", "glob");
//inMemoryOverrideConfig.Add("database:migration:migrationName", "migrationName");
inMemoryOverrideConfig.Add("database:migration:name", "name");
inMemoryOverrideConfig.Add("database::name", "name");
if (dataSource.IsNotEmpty())
{
inMemoryOverrideConfig["database:dataSource"] = dataSource;
}
File.Delete(logFile);
var provider = MigrationBuilder.BuildMigration(SupportedDatabaseTypes.Oracle, inMemoryOverrideConfig, sc => sc.RegisterCustomMigrationProcessor());
using (provider as ServiceProvider)
using (var scope = provider.CreateScope())
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
migrationRunner.DropSchema(scope.ServiceProvider.GetVersionTableMetaData());
migrationRunner.MigrateUp();
try
{
testFunction.Invoke(scope.ServiceProvider);
}
finally
{
migrationRunner.MigrateDown(0);
migrationRunner.DropSchema(scope.ServiceProvider.GetVersionTableMetaData());
}
}
ShowLogFileContent(logFile);
}
public void SelectTestWithJoins_WithTableNameSet(SupportedDatabaseTypes databaseTypes, string schema, string expectedSql)
{
const string entityTableName = "EntityTable";
const string childTableName = "ChildEntityTable";
const string childChildTableName = "ChildChildEntityTable";
var dbConfig = OverrideConfig.CreateTestDbConfig(databaseTypes, schema);
var useSchema = !string.IsNullOrEmpty(schema);
expectedSql = string.Format(expectedSql, dbConfig.Schema);
var builder = dbConfig.CreateSqlBuilder();
var select = builder.Select();
var sqls = new List <string>
{
@select
.OnSchema(setSchemaNameIfExpressionIsEvaluatedToTrue: () => useSchema)
.From <Entity>(entityTableName)
.InnerJoin <Entity, ChildEntity>(fromTableName: entityTableName, toTableName: childTableName)
.LeftOuterJoin <ChildEntity, ChildChildEntity>(fromTableName: childTableName, toTableName: childChildTableName)
.Fields <ChildEntity>(x => x.F(item => item.Description))
.Fields <ChildEntity>(x => x.F(item => item.Relation))
.Fields <Entity>(x => x.F(item => item.Name))
.Fields <Entity>(x => x.F(item => item.Description))
.Where <Entity>(x => x.WP(item => item.Id, "IdParam"))
.Where <Entity>(x => x.WV(item => item.Name, "Arild"))
.Build(),
@select
.OnSchema(setSchemaNameIfExpressionIsEvaluatedToTrue: () => useSchema)
.From <Entity>(entityTableName)
.Fields <ChildEntity>(x => x.F(item => item.Description))
.Fields <ChildEntity>(x => x.F(item => item.Relation))
.Fields <Entity>(x => x.F(item => item.Name))
.Fields <Entity>(x => x.F(item => item.Description))
.InnerJoin <Entity, ChildEntity>(fromTableName: entityTableName, toTableName: childTableName)
.LeftOuterJoin <ChildEntity, ChildChildEntity>(fromTableName: childTableName, toTableName: childChildTableName)
.Where <Entity>(x => x.WP(item => item.Id, "IdParam"))
.Where <Entity>(x => x.WV(item => item.Name, "Arild"))
.Build(),
@select
.OnSchema(setSchemaNameIfExpressionIsEvaluatedToTrue: () => useSchema)
.InnerJoin <Entity, ChildEntity>(fromTableName: entityTableName, toTableName: childTableName)
.LeftOuterJoin <ChildEntity, ChildChildEntity>(fromTableName: childTableName, toTableName: childChildTableName)
.Fields <ChildEntity>(x => x.F(item => item.Description))
.Fields <ChildEntity>(x => x.F(item => item.Relation))
.Fields <Entity>(x => x.F(item => item.Name))
.Fields <Entity>(x => x.F(item => item.Description))
.Where <Entity>(x => x.WP(item => item.Id, "IdParam"))
.Where <Entity>(x => x.WV(item => item.Name, "Arild"))
.Build(),
};
foreach (var sql in sqls)
{
sql.Should().Be(expectedSql);
}
}
public void Migration_PreviewOnly_ShouldBeOk(SupportedDatabaseTypes databaseType)
{
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
inMemoryOverrideConfig.TryGetValue("database:schema", out var schema);
var config2 = new Dictionary <string, string>(inMemoryOverrideConfig);
if (databaseType == SupportedDatabaseTypes.Postgres)
{
using (var scope = MigrationBuilder.BuildMigration(databaseType, inMemoryOverrideConfig).CreateScope())
{
scope.ServiceProvider.CreateSchema();
}
}
var logFile = $"Migration_Success_{schema}_{databaseType}.sql";
inMemoryOverrideConfig.Add("Logging:Migration:ShowSql", "True");
inMemoryOverrideConfig.Add("Logging:Migration:ShowElapsedTime", "True");
inMemoryOverrideConfig.Add("Logging:Migration:File", logFile);
inMemoryOverrideConfig["database:adminPassword"] = "******";
var provider = MigrationBuilder.BuildMigration(databaseType, config2,
collection =>
collection
.Configure <RunnerOptions>(opt => opt.NoConnection = true)
.Configure <ProcessorOptions>(opt => opt.PreviewOnly = true));
using (var scope = provider.CreateScope())
{
try
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
migrationRunner.MigrateUp();
migrationRunner.MigrateDown(0);
}
finally
{
if (databaseType == SupportedDatabaseTypes.Postgres)
{
using (var scope2 = MigrationBuilder.BuildMigration(databaseType, config2).CreateScope())
{
scope2.ServiceProvider.CreateSchema();
}
}
}
}
ShowLogFileContent(logFile);
}
public void SelectWithIfStatementTest(bool ifStatementResult, string expectedSql)
{
var dbConfig = OverrideConfig.CreateTestDbConfig(SupportedDatabaseTypes.Postgres);
expectedSql = string.Format(expectedSql, dbConfig.Schema);
var builder = dbConfig.CreateSqlBuilder();
var sql =
builder.Select()
.Fields <Entity>(x => x.F(item => item.Name))
.Fields <Entity>(x => x.F(item => item.Description))
.Where <Entity>(x => x.WP(item => item.Id, "IdParam"))
.WhereIf <Entity>(x => x.WV(item => item.Name, "Arild"), () => ifStatementResult)
.Build();
sql.Should().Be(expectedSql);
}
public void Migration_Success(SupportedDatabaseTypes databaseType)
{
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
var provider = MigrationBuilder.BuildMigration(databaseType, inMemoryOverrideConfig);
using (var scope = provider.CreateScope())
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
var versionTable = scope.ServiceProvider.GetService <IVersionTableMetaData>();
migrationRunner.MigrateUp();
migrationRunner.MigrateDown(0);
migrationRunner.DropSchema(versionTable);
}
}
public void Migration_Success(SupportedDatabaseTypes databaseType)
{
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
inMemoryOverrideConfig.TryGetValue("database:schema", out var schema);
var logFile = $"Migration_Success_{schema}_{databaseType}.sql";
inMemoryOverrideConfig.Add("Logging:Migration:ShowSql", "True");
inMemoryOverrideConfig.Add("Logging:Migration:ShowElapsedTime", "True");
inMemoryOverrideConfig.Add("Logging:Migration:File", logFile);
var provider = MigrationBuilder.BuildMigration(databaseType, inMemoryOverrideConfig);
using (var scope = provider.CreateScope())
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
var versionTable = scope.ServiceProvider.GetService <IVersionTableMetaData>();
migrationRunner.MigrateUp();
migrationRunner.MigrateDown(0);
migrationRunner.DropSchema(versionTable);
}
if (!logFile.IsEmpty() && File.Exists(logFile))
{
var tmpFile = logFile + ".tmp";
if (File.Exists(tmpFile))
{
File.Delete(tmpFile);
}
File.Copy(logFile, tmpFile);
var logContent = File.ReadAllText(logFile + ".tmp");
var s = $"************* LogContent {logFile} **************";
WriteLine($"\n{s}");
WriteLine($"{"".PadRight(s.Length, '*')}");
WriteLine(logContent);
if (File.Exists(tmpFile))
{
File.Delete(tmpFile);
}
}
}
public void UpdateTestWithWhereIfTest(SupportedDatabaseTypes databaseTypes, string schema, string expectedSql)
{
var dbConfig = OverrideConfig.CreateTestDbConfig(databaseTypes, schema);
var ifStatementResult = !string.IsNullOrEmpty(schema);
expectedSql = string.Format(expectedSql, dbConfig.Schema);
var builder = dbConfig.CreateSqlBuilder();
var update = builder.Update <Entity>();
var sql = update
.Fields(x => x.FP(f => f.Description)
.FV(f => f.Name, "Arild"))
.Where(x => x.WP(item => item.Id, "IdParam"))
.WhereIf(x => x.WV(item => item.Name, "Arild", OP.DI), () => ifStatementResult)
.Build();
sql.Should().Be(expectedSql);
}
public void Migration_Success(SupportedDatabaseTypes databaseType)
{
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
inMemoryOverrideConfig.TryGetValue("database:schema", out var schema);
var logFile = $"Migration_Success_{schema}_{databaseType}.sql";
var loglogFile = $"Migration_Success_{schema}_{databaseType}.log";
inMemoryOverrideConfig.Add("Logging:Migration:ShowSql", "True");
inMemoryOverrideConfig.Add("Logging:Migration:ShowElapsedTime", "True");
inMemoryOverrideConfig.Add("Logging:Migration:File", logFile);
inMemoryOverrideConfig.Add("Logging:File", loglogFile);
var provider = MigrationBuilder.BuildMigration(databaseType, inMemoryOverrideConfig,
collection => collection
.AddSingleton <ICustomSqlTitleConverter, CustomSqlTitleConverter1>()
.AddSingleton <ICustomSqlTitleConverter, CustomSqlTitleConverter2>());
using (var scope = provider.CreateScope())
{
try
{
var versionTable = scope.ServiceProvider.GetService <IVersionTableMetaData>();
var processor = scope.ServiceProvider.GetRequiredService <IExtendedMigrationProcessorOracle>();
var prefixId = scope.ServiceProvider.GetDbMigrationConfig().GetSchemaPrefixId();
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
migrationRunner.MigrateUp();
if (databaseType == SupportedDatabaseTypes.Oracle)
{
processor.ExecuteSql($"create or replace synonym {versionTable.SchemaName}.{Table.Testing}8 for {versionTable.SchemaName}.{Table.Testing.GetPrefixedName(prefixId)}");
processor.ProcessSql($"create or replace synonym {versionTable.SchemaName}.{Table.Testing}9 for {versionTable.SchemaName}.{Table.Testing.GetPrefixedName(prefixId)}", "Sql-title");
}
migrationRunner.MigrateDown(0);
}
finally
{
scope.ServiceProvider.DropSchema();
}
}
ShowLogFileContent(logFile);
}
public void DeleteTest(SupportedDatabaseTypes databaseTypes, string schema, string expectedSql)
{
var useSchema = !string.IsNullOrEmpty(schema);
var dbConfig = OverrideConfig.CreateTestDbConfig(databaseTypes, schema);
expectedSql = string.Format(expectedSql, dbConfig.Schema);
var builder = dbConfig.CreateSqlBuilder();
var delete = builder.Delete <Entity>();
var sql = delete
.OnSchema(setSchemaNameIfExpressionIsEvaluatedToTrue: () => useSchema)
.Where(x => x.WP(item => item.Id, "IdParam"))
.Where(x => x.WV(item => item.Name, "Arild"))
.Build();
sql.Should().Be(expectedSql);
}
public void InsertTest_WithSequence(SupportedDatabaseTypes databaseTypes, string schema, string expectedSql)
{
var useSchema = !string.IsNullOrEmpty(schema);
var dbConfig = OverrideConfig.CreateTestDbConfig(databaseTypes, schema);
expectedSql = string.Format(expectedSql, dbConfig.Schema);
var builder = dbConfig.CreateSqlBuilder();
var resolver = dbConfig.CreateParameterResolver();
var insert = builder.Insert <Entity>();
var sql = insert
.OnSchema(setSchemaNameIfExpressionIsEvaluatedToTrue: () => useSchema)
.Fields(x => x.FV(f => f.Id, resolver.WithNextSequence("seq"), true))
.Fields(x => x.FV(f => f.Name, "Arild"))
.Fields(x => x.FP(f => f.Description))
.Build();
sql.Should().Be(expectedSql);
}
public void UpdateTest_WithTableNameSet(SupportedDatabaseTypes databaseTypes, string schema, string expectedSql)
{
const string tableName = "EntityTable";
var dbConfig = OverrideConfig.CreateTestDbConfig(databaseTypes, schema);
var useSchema = !string.IsNullOrEmpty(schema);
expectedSql = string.Format(expectedSql, dbConfig.Schema);
var builder = dbConfig.CreateSqlBuilder();
var update = builder.Update <Entity>();
var sql = update
.OnTable(tableName)
.OnSchema(setSchemaNameIfExpressionIsEvaluatedToTrue: () => useSchema)
.Fields(x => x.FP(f => f.Description)
.FV(f => f.Name, "Arild"))
.Where(x => x.WP(item => item.Id, "IdParam"))
.Build();
sql.Should().Be(expectedSql);
}
public void MigrationWithExecutorExtension_Success(SupportedDatabaseTypes databaseType)
{
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
var configuration = new ConfigurationBuilder()
.AddDbToolsExampleConfiguration(databaseType)
.AddInMemoryCollection(inMemoryOverrideConfig)
.Build();
var serviceProvider = new ServiceCollection()
.AddScoped <IConfiguration>(provider => configuration)
.AddScoped <IDbConfig, MSDbConfig>()
.BuildServiceProvider();
var dbConfig = serviceProvider.GetService <IDbConfig>();
var runner = dbConfig.GetMigrationRunner(MigrationBuilder.MigrationAssemblies);
runner.MigrateUp();
dbConfig.DropSchema(MigrationBuilder.MigrationAssemblies);
}
//[InlineData(SupportedDatabaseTypes.Oracle)]
public async Task DbProvider_ExampleRepository_Success(SupportedDatabaseTypes databaseType)
{
var overrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType);
overrideConfig.TryGetValue("database:schema", out var schema);
//overrideConfig.Add("database:schemaprefix:id", "EX");
//overrideConfig.Add("database:migration:schemaprefix:id", "EX");
var logFile = $"DbProvider_ExampleRepository_Success_{schema}_{databaseType}.sql";
var loglogFile = $"DbProvider_ExampleRepository_Success_{schema}_{databaseType}.log";
overrideConfig.Add("Logging:Migration:File:ShowSql", "false");
overrideConfig.Add("Logging:Migration:ShowElapsedTime", "True");
overrideConfig.Add("Logging:Migration:File", logFile);
overrideConfig.Add("Logging:Migration:Console:ShowSql", "false");
//overrideConfig.Add("Logging:Migration:Console", "True");
overrideConfig.Add("Logging:File", loglogFile);
var provider = MigrationBuilder.BuildMigration(databaseType, overrideConfig, assemblies: new [] { typeof(AddPersonTable).Assembly });
using var scope = provider.CreateScope();
try
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
var configuration = scope.ServiceProvider.GetService <IConfiguration>();
logFile = configuration.GetMigrationLogFile();
migrationRunner.DropSchema(scope.ServiceProvider.GetVersionTableMetaData());
migrationRunner.MigrateUp();
await DbExampleExecutor.ExecuteDbExample(databaseType, overrideConfig);
migrationRunner.DropSchema(scope.ServiceProvider.GetVersionTableMetaData());
}
catch (InvalidOperationException)
{
//
}
ShowLogFileContent(logFile);
}
public void OracleMigration_WhenDataSourceIsValidEzConnect_Success()
{
var databaseType = SupportedDatabaseTypes.Oracle;
var defaulDbConfig = MigrationBuilder.BuildMigration(databaseType).GetDbConfig();
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
inMemoryOverrideConfig["database:dataSource"] = $"{defaulDbConfig.Hostname}/{defaulDbConfig.DatabaseName}";
inMemoryOverrideConfig["database:connectionTimeoutInSecs"] = "5";
var expectedDataSource = inMemoryOverrideConfig["database:dataSource"];
var provider = MigrationBuilder.BuildMigration(databaseType, inMemoryOverrideConfig, sp => sp.AddOracleDbProvider());
using (var scope = provider.CreateScope())
{
try
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
var config = scope.ServiceProvider.GetDbConfig();
config.Datasource.Should().Be(inMemoryOverrideConfig["database:dataSource"]);
config.GetDbProviderFactory(true)
.CreateConnection()
.DataSource.Should().Be(expectedDataSource);
migrationRunner.MigrateUp();
migrationRunner.MigrateDown(0);
}
finally
{
scope.ServiceProvider.DropSchema();
}
}
}
public void OracleMigration_WhenDataSourceIsInvalidTnsAliastName_ShouldFailWithTnsResolvingError()
{
var databaseType = SupportedDatabaseTypes.Oracle;
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
inMemoryOverrideConfig["database:dataSource"] = "InvalidTnsAlias";
inMemoryOverrideConfig["database:connectionTimeoutInSecs"] = "5";
var expectedDataSource = inMemoryOverrideConfig["database:dataSource"];
var provider = MigrationBuilder.BuildMigration(databaseType, inMemoryOverrideConfig, sp => sp.AddOracleDbProvider());
using (var scope = provider.CreateScope())
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
var versionTable = scope.ServiceProvider.GetService <IVersionTableMetaData>();
var dbconfig = scope.ServiceProvider.GetDbConfig();
dbconfig.Datasource.Should().Be(inMemoryOverrideConfig["database:dataSource"]);
dbconfig
.GetDbProviderFactory(true).CreateConnection()
.DataSource.Should().Be(expectedDataSource);
Action action = () =>
{
migrationRunner.MigrateUp();
migrationRunner.MigrateDown(0);
migrationRunner.DropSchema(versionTable);
};
// Unable to resolve ORA-12154: TNS:could not resolve the connect identifier specified
action.Should().Throw <OracleException>().Which.Number.Should().Be(12154);
}
}
public void OracleMigration_SchemaPrefixHasExpectedValueAndMigrationSucceed()
{
FluentMigrationLoggingExtensions.UseLogFileAppendFluentMigratorLoggerProvider = true;
var schemaPrefixId = "EX";
var schemaPrefixUniqueId = "exabcd-0000000001000";
var databaseType = SupportedDatabaseTypes.Oracle;
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
inMemoryOverrideConfig.TryGetValue("database:schema", out var schema);
var logFile = $"Migration_Success_{schema}_{databaseType}.sql";
inMemoryOverrideConfig.Add("Logging:Migration:ShowSql", "True");
inMemoryOverrideConfig.Add("Logging:Migration:ShowElapsedTime", "True");
inMemoryOverrideConfig.Add("Logging:Migration:File", logFile);
inMemoryOverrideConfig.Add("database:schemaprefix:id", schemaPrefixId);
inMemoryOverrideConfig.Add("database:migration:schemaprefix:uniqueId", schemaPrefixUniqueId);
inMemoryOverrideConfig.Add("database:schemaprefix:tables:person:shortName", "sn");
inMemoryOverrideConfig.Add("database:schemaprefix:tables:person:globalId", "glob");
//inMemoryOverrideConfig.Add("database:migration:migrationName", "migrationName");
inMemoryOverrideConfig.Add("database:migration:name", "name");
inMemoryOverrideConfig.Add("database:migration:schemaprefix:triggersAndViewsGeneration:tables:person", "both");
inMemoryOverrideConfig.Add("database:migration:schemaprefix:triggersAndViewsGeneration:tables:exparent", "triggers");
File.Delete(logFile);
var provider = MigrationBuilder.BuildMigration(SupportedDatabaseTypes.Oracle, inMemoryOverrideConfig, sc => sc.RegisterCustomMigrationProcessor());
using (provider as ServiceProvider)
using (var scope = provider.CreateScope())
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
var dbMigrationConfig = scope.ServiceProvider.GetDbMigrationConfig();
dbMigrationConfig.GetSchemaPrefixId().Should().Be(schemaPrefixId);
dbMigrationConfig.GetSchemaPrefixUniqueId().Should().Be("exabcd-0000000001000");
var personLog = new ChangeLogContext(dbMigrationConfig, Table.Person);
var parentLog = new ChangeLogContext(dbMigrationConfig, Table.Parent);
var unknownLog = new ChangeLogContext(dbMigrationConfig, "Unknown")
{
EnabledTriggersAndViewsGeneration = TriggersAndViewsGeneration.Disabled
};
var unknown2Log = new ChangeLogContext(dbMigrationConfig, "Unknown2");
personLog.SchemaPrefixId.Should().Be(schemaPrefixId);
personLog.SchemaPrefixUniqueId.Should().Be(schemaPrefixUniqueId);
personLog.ShortName.Should().Be($"{schemaPrefixId}sn");
personLog.GlobalId.Should().Be("glob");
personLog.EnabledTriggersAndViewsGeneration.Should().Be(TriggersAndViewsGeneration.Both);
parentLog.SchemaPrefixId.Should().Be(schemaPrefixId);
parentLog.SchemaPrefixUniqueId.Should().Be(schemaPrefixUniqueId);
parentLog.ShortName.Should().BeNullOrEmpty();
parentLog.GlobalId.Should().BeNullOrEmpty();
parentLog.EnabledTriggersAndViewsGeneration.Should().Be(TriggersAndViewsGeneration.Triggers);
unknownLog.SchemaPrefixId.Should().Be(schemaPrefixId);
unknownLog.SchemaPrefixUniqueId.Should().Be(schemaPrefixUniqueId);
unknownLog.ShortName.Should().BeNullOrEmpty();
unknownLog.GlobalId.Should().BeNullOrEmpty();
unknownLog.EnabledTriggersAndViewsGeneration.Should().Be(TriggersAndViewsGeneration.Disabled);
unknown2Log.SchemaPrefixId.Should().Be(schemaPrefixId);
unknown2Log.SchemaPrefixUniqueId.Should().Be(schemaPrefixUniqueId);
unknown2Log.ShortName.Should().BeNullOrEmpty();
unknown2Log.GlobalId.Should().BeNullOrEmpty();
unknown2Log.EnabledTriggersAndViewsGeneration.Should().BeNull();
migrationRunner.MigrateUp();
var oracleProcessor = scope.ServiceProvider.GetService <IExtendedMigrationProcessorOracle>();
oracleProcessor.TableExists(dbMigrationConfig.Schema, Table.Person).Should().BeFalse();
oracleProcessor.TableExists(dbMigrationConfig.Schema, Table.Parent).Should().BeFalse();
oracleProcessor.TableExists(dbMigrationConfig.Schema, "Unknown").Should().BeFalse();
oracleProcessor.TableExists(dbMigrationConfig.Schema, Table.Person.GetPrefixedName(schemaPrefixId)).Should().BeTrue();
oracleProcessor.TableExists(dbMigrationConfig.Schema, Table.Parent.GetPrefixedName(schemaPrefixId)).Should().BeTrue();
oracleProcessor.TableExists(dbMigrationConfig.Schema, "Unknown".GetPrefixedName(schemaPrefixId)).Should().BeFalse();
oracleProcessor.SequenceExists(dbMigrationConfig.Schema, $"{Table.Person.GetPrefixedName(schemaPrefixId)}_seq");
migrationRunner.MigrateDown(0);
migrationRunner.DropSchema(scope.ServiceProvider.GetVersionTableMetaData());
}
provider = MigrationBuilder.BuildMigration(SupportedDatabaseTypes.Oracle, inMemoryOverrideConfig, sc => sc.RegisterCustomMigrationProcessor());
using (provider as ServiceProvider)
using (var scope = provider.CreateScope())
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
migrationRunner.MigrateDown(0);
}
provider = MigrationBuilder.BuildMigration(SupportedDatabaseTypes.Oracle, inMemoryOverrideConfig, sc => sc.RegisterCustomMigrationProcessor());
using (provider as ServiceProvider)
using (var scope = provider.CreateScope())
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
migrationRunner.DropSchema(scope.ServiceProvider.GetVersionTableMetaData());
}
ShowLogFileContent(logFile);
FluentMigrationLoggingExtensions.UseLogFileAppendFluentMigratorLoggerProvider = false;
}
public void OracleMigration_WhenDataSourceIsInvalidTnsAliasName_ShouldFailWithTnsResolvingError(string fileStart, string expectedStart, string logPath = null)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && fileStart.StartsWithIgnoreCase(@"C:\DIPS-Log") && logPath == null)
{
if (Directory.Exists(@"C:\DIPS-Log") == false)
{
Directory.CreateDirectory(@"C:\DIPS-Log");
}
expectedStart = Path.Combine(fileStart, expectedStart);
}
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
fileStart = fileStart.ReplaceIgnoreCase(@"\", $"{Path.DirectorySeparatorChar}");
expectedStart = expectedStart.ReplaceIgnoreCase(@"\", $"{Path.DirectorySeparatorChar}");
logPath = logPath.ReplaceIgnoreCase(@"\", $"{Path.DirectorySeparatorChar}");
}
var databaseType = SupportedDatabaseTypes.Oracle;
var inMemoryOverrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType, OverrideConfig.NewRandomSchema);
if (logPath != null)
{
inMemoryOverrideConfig["LogPath"] = logPath;
}
inMemoryOverrideConfig["database:dataSource"] = "InvalidTnsAlias";
inMemoryOverrideConfig["database:connectionTimeoutInSecs"] = "5";
inMemoryOverrideConfig.TryGetValue("database:schema", out var schema);
var logFile = $"{fileStart}Migration_Success_{schema}_{databaseType}.sql";
inMemoryOverrideConfig.Add("Logging:Migration:ShowSql", "True");
inMemoryOverrideConfig.Add("Logging:Migration:ShowElapsedTime", "True");
inMemoryOverrideConfig.Add("Logging:Migration:File", logFile);
var expectedDataSource = inMemoryOverrideConfig["database:dataSource"];
var provider = MigrationBuilder.BuildMigration(databaseType, inMemoryOverrideConfig, sp => sp.AddOracleDbProvider());
using (var scope = provider.CreateScope())
{
var migrationRunner = scope.ServiceProvider.GetService <IMigrationRunner>();
var versionTable = scope.ServiceProvider.GetService <IVersionTableMetaData>();
var config = scope.ServiceProvider.GetDbConfig();
var configuration = scope.ServiceProvider.GetService <IConfiguration>();
logFile = configuration.GetMigrationLogFile();
config.Datasource.Should().Be(inMemoryOverrideConfig["database:dataSource"]);
config
.GetDbProviderFactory(true).CreateConnection()
.DataSource.Should().Be(expectedDataSource);
Action action = () =>
{
try
{
migrationRunner.MigrateUp();
migrationRunner.MigrateDown(0);
}
finally
{
migrationRunner.DropSchema(versionTable);
}
};
// Unable to resolve ORA-12154: TNS:could not resolve the connect identifier specified
action.Should().Throw <OracleException>().Which.Number.Should().Be(12154);
}
logFile.Should().StartWith(expectedStart);
ShowLogFileContent(logFile);
}
public async Task DbProvider_ExampleRepository_WithDbProviderFactory_Success(SupportedDatabaseTypes databaseType)
{
var overrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType);
await DbExampleExecutor.ExecuteDbExample(databaseType, true, overrideConfig);
}
