/// <summary>
/// Drops the database specified in the context's DBName property
/// </summary>
public void DropDatabase(IDbTestRunnerContext context, IDbTestRunnerConfiguration config)
{
if (context == null)
{
return;
}
try
{
var connString = ProduceConnectionString(config, "master");
using (var conn = new SqlConnection(connString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = $"Drop Database {context.DbName}";
cmd.ExecuteNonQuery();
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
// ReSharper disable once UnusedMember.Global
public DbTestFixture()
{
this.dbTestSetup = DbTestSetupFinder.DbTestSetup;
if (dbTestSetup == null)
{
throw new Exception("Failed to create test fixture. Unable to determine DbTest setup class.");
}
this.ServiceProvider = dbTestSetup.ProduceServiceProvider();
this.config = ServiceProvider.GetService <IDbTestRunnerConfiguration>();
this.scaffolder = ServiceProvider.GetService <IDbScaffolder>();
this.context = ServiceProvider.GetService <IDbTestRunnerContext>();
this.context.ProduceSqlParametersForCustomTypes = dbTestSetup.ProduceSqlParametersForCustomTypes;
// if we're not supposed to run DbTests, then don't bother setting up the runner.
if (!this.config.Enabled())
{
return;
}
// ensure the db exists, has latest migrations, etc.
var initializationResult = InitializeDatabase();
if (!initializationResult.IsSuccessful)
{
throw new DbTestException("Failed to intialize database for tests.");
}
}
private string SetDbName(IDbTestRunnerConfiguration configuration)
{
if (!string.IsNullOrEmpty(configuration.DbName))
{
return(configuration.DbName);
}
return(ProduceUniqueDatabaseName());
}
/// <summary>
/// Produces the ado.net connection string using the server and credentials
/// specified in the configuration
/// </summary>
/// <returns></returns>
protected string ProduceConnectionString(IDbTestRunnerConfiguration config, string dbName = null, bool useConnectionPooling = true, int?connectionTimeoutSeconds = null)
{
return($"Data Source={config.ConnectionInfo.ServerName};" +
$"Initial Catalog={dbName ?? config.DbName};" +
(config.ConnectionInfo.UseIntegratedSecurity ? "Integrated Security=SSPI;" : $"User Id={config.ConnectionInfo.UserName};Password={config.ConnectionInfo.Password};") +
(!useConnectionPooling ? " Pooling=false;" : "") +
(connectionTimeoutSeconds.HasValue ? $" Connection Timeout={connectionTimeoutSeconds};" : "") +
"MultipleActiveResultSets=True");
}
protected override void AfterDbTestsConfigured(IDbTestRunnerConfiguration config)
{
if (config is DbTestRunnerConfiguration efConfig)
{
if (efConfig.DataContextType == null)
{
efConfig.DataContextType = typeof(TDataContext);
}
}
}
protected override void AfterDbTestsConfigured(IDbTestRunnerConfiguration config)
{
if (config is DbTestRunnerConfiguration adoConfig)
{
if (adoConfig.InitializeDbSchemaAndData == null)
{
adoConfig.SetDbInitializeFunction(InitializeDbSchemaAndData);
}
}
}
protected override void InitializeSchemaAndData(IDbTestRunnerConfiguration config, IDbTestRunnerContext context, DbInitializationResult result)
{
if (!(config is DbTestRunnerConfiguration efConfig))
{
result.IsSuccessful = false;
result.Logs.Add($"Failed to initialize schema and database. Configuration is not of the expected type. Expected: {typeof(DbTestRunnerConfiguration).FullName} actual: {config.GetType().FullName}");
return;
}
result.Logs.Add($"Preparing Database with {efConfig.DataContextType} migrations.");
EnsureMigrations(efConfig, context, result);
}
public override void TearDownDatabase(IDbTestRunnerContext context, IDbTestRunnerConfiguration config, bool allTestsWereSuccessful)
{
var sqlConnection = new SqlConnection(context.ConnectionString);
SqlConnection.ClearPool(sqlConnection);
if ((allTestsWereSuccessful && config.DropDatabaseOnSuccess) ||
(!allTestsWereSuccessful && config.DropDatabaseOnFailure))
{
context.DbScaffolder.DropDatabase(context, config);
}
}
/// <summary>
/// Determines if the specified database exists in the configured server
/// </summary>
protected bool DoesDatabaseExist(IDbTestRunnerConfiguration config, string dbName)
{
try
{
using (var conn = new SqlConnection(ProduceConnectionString(config, dbName, false, 3)))
{
conn.Open();
conn.Close();
return(true);
}
}
catch (SqlException)
{
return(false);
}
}
/// <summary>
/// Creates the database specified in Context.DbName
/// </summary>
protected void CreateDatabase(IDbTestRunnerConfiguration config, IDbTestRunnerContext context)
{
var connStr = this.ProduceConnectionString(config, "master");
string sql = $"CREATE DATABASE {context.DbName}";
using (var conn = new SqlConnection(connStr))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = sql;
cmd.CommandType = CommandType.Text;
cmd.ExecuteNonQuery();
}
conn.Close();
}
}
protected override void InitializeSchemaAndData(IDbTestRunnerConfiguration config, IDbTestRunnerContext context, DbInitializationResult result)
{
if (!(config is DbTestRunnerConfiguration adoConfig))
{
result.IsSuccessful = false;
result.Logs.Add($"Failed to initialize schema and database. Configuration is not of the expected type. Expected: {typeof(DbTestRunnerConfiguration).FullName} actual: {config.GetType().FullName}");
return;
}
var connStr = this.ProduceConnectionString(config, context.DbName);
if (string.IsNullOrEmpty(connStr))
{
result.IsSuccessful = false;
result.Logs.Add("Failed to initialize schema and database. Configuration string is empty or null.");
return;
}
result.Logs.Add($"Attempting to initialize DB Schema and Data using connection string: {connStr}");
result.IsSuccessful = adoConfig.InitializeDbSchemaAndData(connStr, result.WasDatabaseCreated);
}
public override void TearDownDatabase(IDbTestRunnerContext context, IDbTestRunnerConfiguration config, bool allTestsWereSuccessful)
{
if (!(config is DbTestRunnerConfiguration efConfig))
{
return;
}
// clears the connection pool for the specified connection
// this lets us drop the database without having hanging active connections
using (var dataContext = context.ProduceDbContext(efConfig.DataContextType))
{
if (dataContext.Database.GetDbConnection() is SqlConnection sqlConnection)
{
SqlConnection.ClearPool(sqlConnection);
}
}
if ((allTestsWereSuccessful && config.DropDatabaseOnSuccess) ||
(!allTestsWereSuccessful && config.DropDatabaseOnFailure))
{
context.DbScaffolder.DropDatabase(context, config);
}
}
protected abstract void AfterDbTestsConfigured(IDbTestRunnerConfiguration config);
public abstract void TearDownDatabase(IDbTestRunnerContext context, IDbTestRunnerConfiguration config, bool allTestsWereSuccessful);
// protected IDbTestRunnerConfiguration ProduceConfiguration()
// {
// // spin up a default config
// // pass the config to ConfigureTests and get back the configuration
// // validate the configuration
// // if its not valid, throw a fatal exception
// // return the configuration
//
// var defaultConfiguration = ProduceDefaultConfiguration();
//
// var config = this.ConfigureTests(defaultConfiguration);
// return config;
// //var config = ProduceDbTestConfiguration();
// //return config;
// }
/// <summary>
/// Here is where you configure your DB Test environment.
/// Specify the server name, login credentials, optional dbName and test run behaviors.
/// </summary>
protected abstract IDbTestRunnerConfiguration ConfigureDbTests(IDbTestRunnerConfiguration config);
/// <summary>
/// Provisions the database specified in Context.DbName
/// Creates the DB if it does not exist and runs all
/// data context migrations against the database.
/// </summary>
public DbInitializationResult InitializeDb(IDbTestRunnerConfiguration config, IDbTestRunnerContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
var result = new DbInitializationResult();
try
{
if (string.IsNullOrEmpty(context.DbName) || !DoesDatabaseExist(config, context.DbName))
{
result.Logs.Add($"Creating new Test database {context.DbName}.");
CreateDatabase(config, context);
result.WasDatabaseCreated = true;
}
else
{
result.Logs.Add($"Using existing database {context.DbName}.");
}
try
{
context.ConnectionString = ProduceConnectionString(config, context.DbName);
InitializeSchemaAndData(config, context, result);
if (!result.IsSuccessful)
{
result.Logs.Add("Failed to initialize db schema and data.");
result.IsSuccessful = false;
}
}
catch (Exception e)
{
result.Exception = e;
result.Logs.Add("Failed to initialize db schema and data.");
result.IsSuccessful = false;
}
if (result.IsSuccessful)
{
result.Logs.Add($"Database {context.DbName} has been prepared for tests.");
result.IsSuccessful = true;
}
}
catch (Exception e)
{
result.Exception = e;
result.Logs.Add($"Error attempting to Initialize DB. {e}");
result.IsSuccessful = false;
}
return(result);
}
protected virtual void RegisterServices(IServiceCollection services, IDbTestRunnerContext context, IDbTestRunnerConfiguration config, IDbScaffolder scaffolder)
{
}
protected override void RegisterServices(IServiceCollection services, IDbTestRunnerContext context, IDbTestRunnerConfiguration config, IDbScaffolder scaffolder)
{
var efScaffolder = scaffolder as EfDbScaffolder;
var efConfig = config as DbTestRunnerConfiguration;
efScaffolder?.RegisterServices <TDataContext>(services, context, efConfig);
}
protected virtual void InitializeSchemaAndData(IDbTestRunnerConfiguration config, IDbTestRunnerContext context, DbInitializationResult result)
{
result.IsSuccessful = true;
}
