//[Fact]
//public async Task WithRollback()
//{
// var entity = new TestEntity
// {
// Property = "prop"
// };
// using var database1 = await instance.BuildWithRollback(new List<object> {entity});
// using var database2 = await instance.BuildWithRollback();
// Assert.NotNull(await database1.Context.TestEntities.FindAsync(entity.Id));
// Assert.Empty(database2.Context.TestEntities.ToList());
//}
//[Fact]
//public async Task WithRollbackPerf()
//{
// using (await instance.BuildWithRollback())
// {
// }
// var entity = new TestEntity
// {
// Property = "prop"
// };
// SqlDatabaseWithRollback<TestDbContext>? database2 = null;
// try
// {
// var stopwatch1 = Stopwatch.StartNew();
// database2 = await instance.BuildWithRollback();
// Trace.WriteLine(stopwatch1.ElapsedMilliseconds);
// await database2.AddData(entity);
// }
// finally
// {
// var stopwatch2 = Stopwatch.StartNew();
// database2?.Dispose();
// Trace.WriteLine(stopwatch2.ElapsedMilliseconds);
// }
//}
public Tests(ITestOutputHelper output) :
base(output)
{
instance = new SqlInstance <TestDbContext>(
connection => new TestDbContext(connection),
instanceSuffix: "Classic");
}
public async Task NoFileAndNoDb()
{
LocalDbApi.StopAndDelete("TestDbContext_EfNoFileAndNoDb");
var directory = DirectoryFinder.Find("TestDbContext_EfNoFileAndNoDb");
if (Directory.Exists(directory))
{
Directory.Delete(directory, true);
}
var instance = new SqlInstance <TestDbContext>(
constructInstance: builder => new TestDbContext(builder.Options),
instanceSuffix: "EfNoFileAndNoDb");
var entity = new TestEntity
{
Property = "prop"
};
using (var database = await instance.Build(new List <object> {
entity
}))
{
Assert.NotNull(database.Context.TestEntities.FindAsync(entity.Id));
}
}
public async Task WithRebuildDbContext()
{
var dateTime = DateTime.Now;
var instance1 = new SqlInstance <WithRebuildDbContext>(
constructInstance: builder => new WithRebuildDbContext(builder.Options),
timestamp: dateTime);
await using (var database1 = await instance1.Build())
{
var entity = new TestEntity
{
Property = "prop"
};
await database1.AddData(entity);
}
var instance2 = new SqlInstance <WithRebuildDbContext>(
constructInstance: builder => new WithRebuildDbContext(builder.Options),
buildTemplate: x => throw new Exception(),
timestamp: dateTime);
await using var database2 = await instance2.Build();
Assert.Empty(database2.Context.TestEntities);
}
public static void Script(this SqlInstance sqlInstance, string outputpath, Action <string> logAction)
{
var scripter = new Scripter(sqlInstance.Server);
var database = sqlInstance.Server.Databases[sqlInstance.SqlConnection.Database];
//add a database level folder
var dbDirectory = Directory.CreateDirectory(Path.Combine(outputpath, database.Name));
logAction(string.Format("Created folder for database : {0}", dbDirectory.FullName));
if (database.Tables.Count > 0)
{
ScriptTables(logAction, scripter, database, dbDirectory);
}
if (database.StoredProcedures.Count > 0)
{
ScriptStoredProcedures(logAction, scripter, database, dbDirectory);
}
if (database.Views.Count > 0)
{
ScriptViews(logAction, scripter, database, dbDirectory);
}
if (database.UserDefinedFunctions.Count > 0)
{
ScriptUserDefinedFunctions(logAction, scripter, database, dbDirectory);
}
}
public async Task WithRollbackPerf()
{
var instance = new SqlInstance("Name", TestDbBuilder.CreateTable);
await using (await instance.BuildWithRollback())
{
}
SqlDatabaseWithRollback?database = null;
try
{
var stopwatch = Stopwatch.StartNew();
database = await instance.BuildWithRollback();
Trace.WriteLine(stopwatch.ElapsedMilliseconds);
await TestDbBuilder.AddData(database.Connection);
}
finally
{
var stopwatch = Stopwatch.StartNew();
database?.Dispose();
Trace.WriteLine(stopwatch.ElapsedMilliseconds);
}
}
static IntegrationTests()
{
GraphTypeTypeRegistry.Register <FilterChildEntity, FilterChildGraph>();
GraphTypeTypeRegistry.Register <FilterParentEntity, FilterParentGraph>();
GraphTypeTypeRegistry.Register <WithManyChildrenEntity, WithManyChildrenGraph>();
GraphTypeTypeRegistry.Register <CustomTypeEntity, CustomTypeGraph>();
GraphTypeTypeRegistry.Register <Child1Entity, Child1Graph>();
GraphTypeTypeRegistry.Register <ChildEntity, ChildGraph>();
GraphTypeTypeRegistry.Register <ParentEntity, ParentGraph>();
GraphTypeTypeRegistry.Register <Level1Entity, Level1Graph>();
GraphTypeTypeRegistry.Register <Level2Entity, Level2Graph>();
GraphTypeTypeRegistry.Register <Level3Entity, Level3Graph>();
GraphTypeTypeRegistry.Register <WithMisNamedQueryParentEntity, WithMisNamedQueryParentGraph>();
GraphTypeTypeRegistry.Register <WithNullableEntity, WithNullableGraph>();
GraphTypeTypeRegistry.Register <NamedIdEntity, NamedIdGraph>();
GraphTypeTypeRegistry.Register <WithMisNamedQueryChildEntity, WithMisNamedQueryChildGraph>();
sqlInstance = new SqlInstance <IntegrationDbContext>(
buildTemplate: async dbContext =>
{
await dbContext.Database.EnsureCreatedAsync();
await dbContext.Database.ExecuteSqlRawAsync(
@"create view ParentEntityView as
select Property
from ParentEntities");
},
constructInstance: builder => new IntegrationDbContext(builder.Options));
}
public async Task WithRebuild()
{
var dateTime = DateTime.Now;
var instance1 = new SqlInstance(
"rebuild",
TestDbBuilder.CreateTable,
timestamp: dateTime);
int data;
using (var database1 = await instance1.Build())
{
data = await TestDbBuilder.AddData(database1.Connection);
}
var instance2 = new SqlInstance(
"rebuild",
connection => throw new Exception(),
timestamp: dateTime);
using (var database = await instance2.Build())
{
var connection1 = database.Connection;
Assert.DoesNotContain(data, await TestDbBuilder.GetData(connection1));
}
}
public void InitializeServer()
{
_s = new SqlInstance("localhost", "", "", true, true);
_token = new CancellationTokenSource().Token;
Utils.CreateLocalSettings();
Utils.WriteLog("Test Started.");
}
static DbContextBuilder()
{
var sqlInstance = new SqlInstance <GraphQlEfSampleDbContext>(
buildTemplate: CreateDb,
constructInstance: builder => new GraphQlEfSampleDbContext(builder.Options));
database = sqlInstance.Build("GraphQLEntityFrameworkSample").GetAwaiter().GetResult();
}
public async Task StartAsync(CancellationToken cancellationToken)
{
var sqlInstance = new SqlInstance <SampleDbContext>(
buildTemplate: CreateDb,
constructInstance: builder => new SampleDbContext(builder.Options));
database = await sqlInstance.Build("GraphQLEntityFrameworkSample");
}
public async Task WithFileAndNoInstance()
{
new SqlInstance("WithFileAndNoInstance", TestDbBuilder.CreateTable);
LocalDbApi.StopAndDelete("WithFileAndNoInstance");
var instance = new SqlInstance("WithFileAndNoInstance", TestDbBuilder.CreateTable);
await AddAndVerifyData(instance);
}
EfExplicitName()
{
#region EfExplicitName
var sqlInstance = new SqlInstance <TheDbContext>(
constructInstance: builder => new TheDbContext(builder.Options),
name: "theInstanceName",
directory: @"C:\LocalDb\theInstance");
#endregion
}
public async Task NoFileAndWithInstance()
{
LocalDbApi.CreateInstance("NoFileAndWithInstance");
DirectoryFinder.Delete("NoFileAndWithInstance");
var instance = new SqlInstance("NoFileAndWithInstance", TestDbBuilder.CreateTable);
await AddAndVerifyData(instance);
}
static MappingTests()
{
ArgumentGraphs.Initialise();
GraphTypeTypeRegistry.Register <MappingParent, MappingParentGraph>();
GraphTypeTypeRegistry.Register <MappingChild, MappingChildGraph>();
sqlInstance = new SqlInstance <MappingContext>(
constructInstance: builder => new MappingContext(builder.Options));
}
public async Task Delegate_TimeStamp()
{
var instance = new SqlInstance(
name: "Delegate_TimeStamp",
buildTemplate: TestDbBuilder.CreateTable);
await using var database = await instance.Build();
Assert.Equal(Timestamp.LastModified <Tests>(), File.GetCreationTime(instance.Wrapper.TemplateDataFile));
}
ExplicitName()
{
#region ExplicitName
var sqlInstance = new SqlInstance(
name: "theInstanceName",
buildTemplate: TestDbBuilder.CreateTable,
directory: @"C:\LocalDb\theInstance"
);
#endregion
}
public async Task Assembly_TimeStamp()
{
var instance = new SqlInstance <TestDbContext>(
constructInstance: connection => new TestDbContext(connection),
instanceSuffix: "Assembly_TimeStamp");
using var database = await instance.Build();
Assert.Equal(Timestamp.LastModified <Tests>(), File.GetCreationTime(instance.Wrapper.TemplateDataFile));
}
static async Task AddAndVerifyData(SqlInstance instance)
{
using (var database = await instance.Build())
{
var connection = database.Connection;
var data = await TestDbBuilder.AddData(connection);
Assert.Contains(data, await TestDbBuilder.GetData(connection));
}
}
public Tests()
{
instance = new(
builder => new(builder.Options),
callback : (_, _) =>
{
callbackCalled = true;
return(Task.CompletedTask);
});
}
public async Task Delegate_TimeStamp()
{
var instance = new SqlInstance <TestDbContext>(
constructInstance: builder => new TestDbContext(builder.Options),
buildTemplate: async context => { await context.Database.EnsureCreatedAsync(); },
instanceSuffix: "Delegate_TimeStamp");
await using var database = await instance.Build();
Assert.Equal(Timestamp.LastModified <Tests>(), File.GetCreationTime(instance.Wrapper.TemplateDataFile));
}
public async Task Simple()
{
var instance = new SqlInstance("Name", TestDbBuilder.CreateTable);
await using var database = await instance.Build();
var connection = database.Connection;
var data = await TestDbBuilder.AddData(connection);
Assert.Contains(data, await TestDbBuilder.GetData(connection));
}
public Tests()
{
instance = new(
connection => new(connection),
storage : Storage.FromSuffix <TestDbContext>($"Classic{Environment.Version.Major}"),
callback : (_, _) =>
{
callbackCalled = true;
return(Task.CompletedTask);
});
}
public static SqlInstance CreateCustomDatabase(string DatabaseName)
{
SqlInstance instance = new SqlInstance();
instance.CreateDatabase(DatabaseName);
instance.SetDatabase(DatabaseName);
DatabaseConfiguration dbConfig = DatabaseConfigurations.SqlPersistenceConfiguration(InstanceStoreVersion.Version45);
instance.ExecuteSqlFile(dbConfig.CreateSchema);
instance.ExecuteSqlFile(dbConfig.CreateLogic);
return(instance);
}
public async Task Defined_TimeStamp()
{
var dateTime = DateTime.Now;
var instance = new SqlInstance(
name: "Defined_TimeStamp",
buildTemplate: TestDbBuilder.CreateTable,
timestamp: dateTime);
await using var database = await instance.Build();
Assert.Equal(dateTime, File.GetCreationTime(instance.Wrapper.TemplateDataFile));
}
static DbContextBuilder()
{
var sqlInstance = new SqlInstance <GraphQlEfSampleDbContext>(
buildTemplate: (connection, builder) => { CreateDb(builder); },
constructInstance: builder => new GraphQlEfSampleDbContext(builder.Options));
database = sqlInstance.Build("GraphQLEntityFrameworkSample").GetAwaiter().GetResult();
using (var context = database.NewDbContext())
{
Model = context.Model;
}
}
async Task Usage()
{
#region EfWithRollback
var sqlInstance = new SqlInstance <TheDbContext>(
constructInstance: builder => new TheDbContext(builder.Options));
await using var sqlDatabase = await sqlInstance.BuildWithRollback();
var connection = sqlDatabase.Connection;
var dbContext = sqlDatabase.Context;
//Use the Connection or TheDbContext
#endregion
}
public async Task WithRollback()
{
var instance = new SqlInstance("Name", TestDbBuilder.CreateTable);
await using var database1 = await instance.BuildWithRollback();
await using var database2 = await instance.BuildWithRollback();
var data = await TestDbBuilder.AddData(database1.Connection);
Assert.Contains(data, await TestDbBuilder.GetData(database1.Connection));
Assert.Empty(await TestDbBuilder.GetData(database2.Connection));
}
public async Task Defined_TimeStamp()
{
var dateTime = DateTime.Now;
var instance = new SqlInstance <TestDbContext>(
constructInstance: builder => new TestDbContext(builder.Options),
buildTemplate: async context => { await context.Database.EnsureCreatedAsync(); },
timestamp: dateTime,
instanceSuffix: "Defined_TimeStamp");
await using var database = await instance.Build();
Assert.Equal(dateTime, File.GetCreationTime(instance.Wrapper.TemplateDataFile));
}
static ConnectionConverterTests()
{
sqlInstance = new SqlInstance <MyContext>(
buildTemplate: async dbContext =>
{
await dbContext.Database.EnsureCreatedAsync();
dbContext.AddRange(list.Select(x => new Entity {
Property = x
}));
await dbContext.SaveChangesAsync();
},
constructInstance: builder => new MyContext(builder.Options));
}
static IntegrationTests()
{
sqlInstance = new(
buildTemplate : async data =>
{
await data.Database.EnsureCreatedAsync();
await data.Database.ExecuteSqlRawAsync(
@"create view ParentEntityView as
select Property
from ParentEntities");
},
constructInstance : builder => new(builder.Options));
}
