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 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 OracleMigration_AllMigrationConfigValuesShouldHaveExpectedValues()
{
var provider = MigrationBuilder.BuildMigration(SupportedDatabaseTypes.Oracle,
new Dictionary <string, string>
{
{ "database:migration:schemaPrefix:id", "EX" },
{ "database:migration:schemaPrefix:uniqueId", "EXAbc" }
});
using (var scope = provider.CreateScope())
{
var allValues = scope.ServiceProvider.GetService <IDbMigrationConfig>().GetAllMigrationConfigValues();
allValues.Should().NotBeNull();
allValues.Should().NotBeEmpty();
Action action = () => allValues["dont:exist"].Should().BeNullOrEmpty();
action.Should().Throw <KeyNotFoundException>();
allValues["schemaprefix:id"].Should().Be("EX");
allValues["schemaPrefix:id"].Should().Be("EX");
allValues["schemaprefix:uniqueid"].Should().Be("EXAbc");
allValues["schemaPrefix:uniqueId"].Should().Be("EXAbc");
allValues["customMigrationValue1"].Should().Be("TEST:customMigrationValue1");
allValues["customMigrationValue2"].Should().Be("TEST:customMigrationValue2");
allValues["productXYValues:tableRoleName"].Should().Be("TEST:tableRoleName");
allValues["productXYValues:coderolename"].Should().Be("TEST:codeRoleName");
allValues["productXYValues:prefix"].Should().Be("XY");
allValues["productXYValues:subsection:subconfig"].Should().Be("TEST:subconfig");
}
}
public void OracleMigration_PrioritizeValues_IsResolvedCorrect()
{
var overrideConfig = new Dictionary <string, string>
{
{ "database:exampleSchema", nameof(OracleMigration_PrioritizeValues_IsResolvedCorrect) },
{ "database:migration:exampleSchema:password", nameof(OracleMigration_PrioritizeValues_IsResolvedCorrect) + "-password" },
{ "database:schemaPrefix:exampleSchemaPrefixId", "SP" },
{ "database:migration:schemaPrefix:exampleSchemaPrefixUniqueId", "xyz1234" }
};
var provider = MigrationBuilder.BuildMigration(SupportedDatabaseTypes.Oracle, overrideConfig);
using (var scope = provider.CreateScope())
{
var migrationConfig = scope.ServiceProvider.GetDbMigrationConfig();
var dbConfig = migrationConfig.GetDbConfig();
dbConfig.Schema.Should().Be(nameof(OracleMigration_PrioritizeValues_IsResolvedCorrect));
migrationConfig.Schema.Should().Be(dbConfig.Schema);
migrationConfig.SchemaPassword.Should().Be(nameof(OracleMigration_PrioritizeValues_IsResolvedCorrect) + "-password");
migrationConfig.GetSchemaPrefixId().Should().Be("SP");
migrationConfig.GetSchemaPrefixUniqueId().Should().Be("xyz1234");
dbConfig.GetSchemaPrefixId().Should().Be(migrationConfig.GetSchemaPrefixId());
}
}
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 OracleMigration_AllDatabaseConfigValuesShouldHaveExpectedValues()
{
var provider = MigrationBuilder.BuildMigration(SupportedDatabaseTypes.Oracle);
using (var scope = provider.CreateScope())
{
var dbConfig = scope.ServiceProvider.GetService <IDbMigrationConfig>().GetDbConfig();
var allValues = dbConfig
.GetAllDatabaseConfigValues();
allValues.Should().NotBeNull();
allValues.Should().NotBeEmpty();
allValues["type"].Should().Be("Oracle");
allValues["user"].Should().Be(dbConfig.User);
allValues["adminUser"].Should().Be(dbConfig.AdminUser);
allValues["hostname"].Should().Be(dbConfig.Hostname);
allValues["port"].Should().Be(dbConfig.Port);
allValues["migration:customMigrationValue1"].Should().Be("TEST:customMigrationValue1");
allValues["migration:customMigrationValue2"].Should().Be("TEST:customMigrationValue2");
allValues["migration:productXYValues:tableRoleName"].Should().Be("TEST:tableRoleName");
allValues["migration:productXYValues:codeRoleName"].Should().Be("TEST:codeRoleName");
allValues["migration:productXYValues:prefix"].Should().Be("XY");
allValues["migration:productXYValues:subsection:subconfig"].Should().Be("TEST:subconfig");
}
}
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 OracleMigration_PasswordsWithSecrets_HasExpectedValues()
{
var provider = MigrationBuilder.BuildMigration(SupportedDatabaseTypes.Oracle,
new Dictionary <string, string>
{
{ "database:secret:encoded:SYSTEMUSER", Convert.ToBase64String(Encoding.UTF8.GetBytes("systemPwd")) },
{ "database:secret:encrypted:TESTUSER", Convert.ToBase64String(new SymmetricCryptoProvider().Encrypt("testUserPwd")) },
{ "database:user", "TestUser" },
{ "database:type", "oracle" },
{ "database:adminUser", "SystemUser" }
}, loadExampleConfig: false);
using (var scope = provider.CreateScope())
{
var migrationConfig = scope.ServiceProvider.GetService <IDbMigrationConfig>();
migrationConfig.GetDbConfig().User.Should().Be("TestUser");
migrationConfig.GetDbConfig().Password.Should().Be("testUserPwd");
migrationConfig.GetDbConfig().AdminUser.Should().Be("SystemUser");
migrationConfig.GetDbConfig().AdminPassword.Should().Be("systemPwd");
migrationConfig.Schema.Should().Be("TESTUSER");
migrationConfig.SchemaPassword.Should().Be("testUserPwd");
}
}
public static IServiceProvider GetMigrationExampleServiceProvider(
SupportedDatabaseTypes databaseType = SupportedDatabaseTypes.Postgres,
Dictionary <string, string> additionalOverrideConfig = null)
{
var overrideConfig = OverrideConfig.GetInMemoryOverrideConfig(databaseType);
additionalOverrideConfig?.ToList().ForEach(x => overrideConfig[x.Key] = x.Value);
return(MigrationBuilder.BuildMigration(databaseType, overrideConfig));
}
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 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 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 OracleMigration_AllMigrationConfigValuesShouldHaveExpectedValues()
{
var provider = MigrationBuilder.BuildMigration(SupportedDatabaseTypes.Oracle);
using (var scope = provider.CreateScope())
{
var allValues = scope.ServiceProvider.GetService <IDbMigrationConfig>().GetAllMigrationConfigValues();
allValues.Should().NotBeNull();
allValues.Should().NotBeEmpty();
allValues["customMigrationValue1"].Should().Be("TEST:customMigrationValue1");
allValues["customMigrationValue2"].Should().Be("TEST:customMigrationValue2");
allValues["productXYValues:tableRoleName"].Should().Be("TEST:tableRoleName");
allValues["productXYValues:codeRoleName"].Should().Be("TEST:codeRoleName");
allValues["productXYValues:prefix"].Should().Be("XY");
allValues["productXYValues:subsection:subconfig"].Should().Be("TEST:subconfig");
}
}
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 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 OracleMigration_PrioritizeValues_SchemePasswordIsResolvedCorrect(string schemaName, string schemaPassword, string expectedSchemaPassword = null)
{
if (expectedSchemaPassword == null)
{
expectedSchemaPassword = schemaPassword;
}
var overrideConfig = new Dictionary <string, string>
{
{ "database:exampleSchema", schemaName },
{ $"database:{schemaName}:password", schemaPassword },
};
var provider = MigrationBuilder.BuildMigration(SupportedDatabaseTypes.Oracle, overrideConfig);
using (var scope = provider.CreateScope())
{
var migrationConfig = scope.ServiceProvider.GetDbMigrationConfig();
migrationConfig.Schema.Should().Be(schemaName);
migrationConfig.SchemaPassword.Should().Be(expectedSchemaPassword);
}
}
//[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_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_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_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 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;
}
