static IModel BuildModel(ConstructInstance <TDbContext> constructInstance)
{
var builder = DefaultOptionsBuilder.Build <TDbContext>();
builder.UseSqlServer("Fake");
return(constructInstance(builder).Model);
}
/// <summary>
/// Instantiate a <see cref="SqlInstance{TDbContext}"/>.
/// Should usually be scoped as once instance per appdomain. So all tests use the same instance of <see cref="SqlInstance{TDbContext}"/>.
/// </summary>
/// <param name="constructInstance"></param>
/// <param name="buildTemplate"></param>
/// <param name="storage">Disk storage convention for where the mdb and the ldf files will be located. Optional.</param>
/// <param name="timestamp"></param>
/// <param name="templateSize">The size in MB for the template. Optional.</param>
/// <param name="existingTemplate">Existing mdb and the ldf files to use when building the template. Optional.</param>
/// <param name="callback">Callback that is executed after the template database has been created. Optional.</param>
/// <param name="sqlOptionsBuilder">Passed to <see cref="SqlServerDbContextOptionsExtensions.UseSqlServer(DbContextOptionsBuilder,string,Action{SqlServerDbContextOptionsBuilder})"/>.</param>
public SqlInstance(
ConstructInstance <TDbContext> constructInstance,
TemplateFromConnection <TDbContext> buildTemplate,
Storage?storage = null,
DateTime?timestamp = null,
ushort templateSize = 3,
ExistingTemplate?existingTemplate = null,
Callback <TDbContext>?callback = null,
Action <SqlServerDbContextOptionsBuilder>?sqlOptionsBuilder = null)
{
storage ??= DefaultStorage;
var resultTimestamp = GetTimestamp(timestamp, buildTemplate);
Guard.AgainstNull(nameof(buildTemplate), buildTemplate);
Guard.AgainstNull(nameof(constructInstance), constructInstance);
Model = BuildModel(constructInstance);
this.constructInstance = constructInstance;
this.sqlOptionsBuilder = sqlOptionsBuilder;
var storageValue = storage.Value;
DirectoryCleaner.CleanInstance(storageValue.Directory);
Task BuildTemplate(DbConnection connection)
{
var builder = DefaultOptionsBuilder.Build <TDbContext>();
builder.UseSqlServer(connection, sqlOptionsBuilder);
return(buildTemplate(connection, builder));
}
Func <DbConnection, Task>?wrapperCallback = null;
if (callback != null)
{
wrapperCallback = async connection =>
{
var builder = DefaultOptionsBuilder.Build <TDbContext>();
builder.UseSqlServer(connection, sqlOptionsBuilder);
#if NET5_0
await using var context = constructInstance(builder);
#else
using var context = constructInstance(builder);
#endif
await callback(connection, context);
};
}
Wrapper = new(
s => new SqlConnection(s),
storageValue.Name,
storageValue.Directory,
templateSize,
existingTemplate,
wrapperCallback);
Wrapper.Start(resultTimestamp, BuildTemplate);
}
private IEnumerable <T> ExecuteReaderSync(IDataReader reader, ConstructInstance map)
{
using (reader)
{
while (reader.Read())
{
object row = map(reader);
yield return((T)row);
}
}
}
internal SqlDatabase(
string connectionString,
string name,
ConstructInstance <TDbContext> constructInstance,
Func <Task> delete,
IEnumerable <object>?data)
{
Name = name;
this.constructInstance = constructInstance;
this.delete = delete;
this.data = data;
ConnectionString = connectionString;
Connection = new(connectionString);
}
internal SqlDatabase(
string connectionString,
string name,
ConstructInstance <TDbContext> constructInstance,
Func <Task> delete,
IEnumerable <object>?data,
Action <SqlServerDbContextOptionsBuilder>?sqlOptionsBuilder)
{
Name = name;
this.constructInstance = constructInstance;
this.delete = delete;
this.data = data;
this.sqlOptionsBuilder = sqlOptionsBuilder;
ConnectionString = connectionString;
Connection = new(connectionString);
}
public SqlInstance(
ConstructInstance <TDbContext> constructInstance,
TemplateFromContext <TDbContext>?buildTemplate = null,
Storage?storage = null,
DateTime?timestamp = null,
ushort templateSize = 3,
ExistingTemplate?existingTemplate = null,
Callback <TDbContext>?callback = null) :
this(
constructInstance,
BuildTemplateConverter.Convert(constructInstance, buildTemplate),
storage,
GetTimestamp(timestamp, buildTemplate),
templateSize,
existingTemplate,
callback)
{
}
public static TemplateFromConnection Convert <TDbContext>(
ConstructInstance <TDbContext> constructInstance,
TemplateFromContext <TDbContext>?buildTemplate)
where TDbContext : DbContext
{
return(async connection =>
{
using var context = constructInstance(connection);
if (buildTemplate == null)
{
await context.CreateOnExistingDb();
}
else
{
await buildTemplate(context);
}
});
}
public static TemplateFromConnection <TDbContext> Convert <TDbContext>(
ConstructInstance <TDbContext> constructInstance,
TemplateFromContext <TDbContext>?buildTemplate)
where TDbContext : DbContext
{
return(async(_, builder) =>
{
await using var data = constructInstance(builder);
if (buildTemplate == null)
{
await data.Database.EnsureCreatedAsync();
}
else
{
await buildTemplate(data);
}
});
}
public SqlInstance(
ConstructInstance <TDbContext> constructInstance,
TemplateFromConnection buildTemplate,
Storage?storage = null,
DateTime?timestamp = null,
ushort templateSize = 3,
ExistingTemplate?existingTemplate = null,
Callback <TDbContext>?callback = null)
{
storage ??= DefaultStorage;
var resultTimestamp = GetTimestamp(timestamp, buildTemplate);
Guard.AgainstNull(nameof(constructInstance), constructInstance);
this.constructInstance = constructInstance;
var storageValue = storage.Value;
DirectoryCleaner.CleanInstance(storageValue.Directory);
Func <DbConnection, Task>?wrapperCallback = null;
if (callback != null)
{
wrapperCallback = async connection =>
{
using var context = constructInstance(connection);
await callback(connection, context);
};
}
Wrapper = new(
s => new SqlConnection(s),
storageValue.Name,
storageValue.Directory,
templateSize,
existingTemplate,
wrapperCallback);
Wrapper.Start(resultTimestamp, connection => buildTemplate(connection));
}
