public BatchingTest()
{
_testStore = SpannerTestStore.CreateScratch();
_serviceProvider = new ServiceCollection()
.AddEntityFrameworkSpanner()
.BuildServiceProvider();
}
private static async Task Create_creates_physical_database_but_not_tables_test(bool async)
{
using (var testDatabase = SpannerTestStore.CreateScratch(false))
{
var creator = GetDatabaseCreator(testDatabase);
Assert.False(creator.Exists());
if (async)
{
await creator.CreateAsync();
}
else
{
creator.Create();
}
Assert.True(creator.Exists());
if (testDatabase.Connection.State != ConnectionState.Open)
{
await testDatabase.Connection.OpenAsync();
}
Assert.Equal(0,
(await testDatabase.QueryAsync <string>(
@"SELECT TABLE_NAME FROM information_schema.tables AS t
WHERE t.table_catalog = '' and t.table_schema = ''")
).Count());
}
}
private static async Task Exists_returns_true_when_database_exists_test(bool async)
{
using (var testDatabase = SpannerTestStore.CreateScratch(true))
{
var creator = GetDatabaseCreator(testDatabase);
Assert.True(async ? await creator.ExistsAsync() : creator.Exists());
}
}
private static IServiceProvider CreateContextServices(SpannerTestStore testStore)
=> ((IInfrastructure <IServiceProvider>) new BloggingContext(
new DbContextOptionsBuilder()
.UseSpanner(testStore.ConnectionString, b => b.ApplyConfiguration())
.UseInternalServiceProvider(new ServiceCollection()
.AddEntityFrameworkSpanner()
//.AddScoped<SpannerExecutionStrategyFactory, TestSpannerExecutionStrategyFactory>()
.AddScoped <IRelationalDatabaseCreator, TestDatabaseCreator>().BuildServiceProvider())
.Options))
.Instance;
public NotificationEntitiesSpannerFixture()
{
_options = new DbContextOptionsBuilder()
.UseSpanner(SpannerTestStore.CreateConnectionString(DatabaseName), b => b.ApplyConfiguration())
.UseInternalServiceProvider(new ServiceCollection()
.AddEntityFrameworkSpanner()
.AddSingleton(TestModelSource.GetFactory(OnModelCreating))
.BuildServiceProvider())
.Options;
}
public ExecutionStrategyTest(ExecutionStrategyFixture fixture)
{
Fixture = fixture;
TestStore = SpannerTestStore.GetOrCreateShared(DatabaseName, () =>
{
using (var context = CreateContext())
{
context.Database.EnsureCreated();
}
});
}
private static async Task Can_use_an_existing_closed_connection_test(bool openConnection)
{
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkSpanner()
.BuildServiceProvider();
using (var store = SpannerTestStore.GetNorthwindStore())
{
var openCount = 0;
var closeCount = 0;
var disposeCount = 0;
using (var connection = new SpannerConnection(store.ConnectionString))
{
if (openConnection)
{
await connection.OpenAsync();
}
connection.StateChange += (_, a) =>
{
if (a.CurrentState == ConnectionState.Open)
{
openCount++;
}
else if (a.CurrentState == ConnectionState.Closed)
{
closeCount++;
}
};
connection.Disposed += (_, __) => disposeCount++;
using (var context = new NorthwindContext(serviceProvider, connection))
{
Assert.Equal(91, await context.Customers.CountAsync());
}
if (openConnection)
{
Assert.Equal(ConnectionState.Open, connection.State);
Assert.Equal(0, openCount);
Assert.Equal(0, closeCount);
}
else
{
Assert.Equal(ConnectionState.Closed, connection.State);
Assert.Equal(1, openCount);
Assert.Equal(1, closeCount);
}
Assert.Equal(0, disposeCount);
}
}
}
private static async Task HasTables_returns_false_when_database_exists_but_has_no_tables_test(bool async)
{
using (var testDatabase = SpannerTestStore.CreateScratch(true))
{
var creator = GetDatabaseCreator(testDatabase);
Assert.False(async
? await((TestDatabaseCreator)creator).HasTablesAsyncBase()
: ((TestDatabaseCreator)creator).HasTablesBase());
}
}
public override SpannerTestStore CreateTestStore()
{
return(SpannerTestStore.GetOrCreateShared(DatabaseName, () =>
{
using (var context = new LoadContext(_options))
{
context.Database.EnsureCreated();
Seed(context);
}
}));
}
public override DbContext CreateContext(SpannerTestStore testStore)
{
var optionsBuilder = new DbContextOptionsBuilder()
.UseSpanner(testStore.Connection)
.UseInternalServiceProvider(_serviceProvider);
var context = new GraphUpdatesContext(optionsBuilder.Options);
context.Database.UseTransaction(testStore.Transaction);
return(context);
}
public override DbContext CreateContext(SpannerTestStore testStore)
{
var optionsBuilder = new DbContextOptionsBuilder()
.UseSpanner(testStore.Connection, b => b.ApplyConfiguration())
.UseInternalServiceProvider(_serviceProvider);
var context = new AdvancedPatternsMasterContext(optionsBuilder.Options);
context.Database.UseTransaction(testStore.Transaction);
return(context);
}
protected override void CreateAndSeedDatabase(string databaseName, Func <MonsterContext> createContext,
Action <MonsterContext> seed)
{
_testStore = SpannerTestStore.GetOrCreateShared(databaseName, () =>
{
using (var context = createContext())
{
context.Database.EnsureCreated();
seed(context);
}
});
}
public SystemColumnTest()
{
_testStore = SpannerTestStore.CreateScratch();
_options = new DbContextOptionsBuilder()
.UseSpanner(_testStore.Connection)
.Options;
using (var context = CreateContext())
{
context.Database.EnsureCreated();
}
}
public override SpannerTestStore CreateTestStore()
=> SpannerTestStore.GetOrCreateShared(DatabaseName, () =>
{
var optionsBuilder = new DbContextOptionsBuilder()
.UseSpanner(SpannerTestStore.CreateConnectionString(DatabaseName), b => b.ApplyConfiguration())
.UseInternalServiceProvider(_serviceProvider);
using (var context = new AdvancedPatternsMasterContext(optionsBuilder.Options))
{
context.Database.EnsureCreated();
Seed(context);
}
});
private static async Task HasTables_throws_when_database_doesnt_exist_test(bool async)
{
using (var testDatabase = SpannerTestStore.CreateScratch(false))
{
await((TestDatabaseCreator)GetDatabaseCreator(testDatabase)).ExecutionStrategyFactory.Create()
.ExecuteAsync(
(TestDatabaseCreator)GetDatabaseCreator(testDatabase),
async creator =>
{
await Assert.ThrowsAsync <SpannerException>(() => creator.HasTablesAsyncBase());
});
}
}
public override SpannerTestStore CreateTestStore()
{
return(SpannerTestStore.GetOrCreateShared(DatabaseName, () =>
{
var optionsBuilder = new DbContextOptionsBuilder()
.UseSpanner(SpannerTestStore.CreateConnectionString(DatabaseName))
.UseInternalServiceProvider(_serviceProvider);
using (var context = new StoreGeneratedContext(optionsBuilder.Options))
{
context.Database.EnsureCreated();
}
}));
}
public LoadSpannerFixture()
{
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkSpanner()
.AddSingleton(TestModelSource.GetFactory(OnModelCreating))
.AddSingleton <ILoggerFactory>(TestSqlLoggerFactory)
.BuildServiceProvider();
_options = new DbContextOptionsBuilder()
.UseSpanner(SpannerTestStore.CreateConnectionString(DatabaseName), b => b.ApplyConfiguration())
.UseInternalServiceProvider(serviceProvider)
.EnableSensitiveDataLogging()
.Options;
}
public NullKeysSpannerFixture()
{
var name = "stringscontext";
var connectionString = SpannerTestStore.CreateConnectionString(name);
_options = new DbContextOptionsBuilder()
.UseSpanner(connectionString, b => b.ApplyConfiguration())
.UseInternalServiceProvider(new ServiceCollection()
.AddEntityFrameworkSpanner()
.AddSingleton(TestModelSource.GetFactory(OnModelCreating))
.BuildServiceProvider())
.Options;
_testStore = SpannerTestStore.GetOrCreateShared(name, EnsureCreated);
}
public MappingQuerySpannerFixture()
{
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkSpanner()
.AddSingleton <ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider();
_testDatabase = SpannerTestStore.GetNorthwindStore();
_options = new DbContextOptionsBuilder()
.UseModel(CreateModel())
.UseSpanner(_testDatabase.ConnectionString)
.UseInternalServiceProvider(serviceProvider)
.Options;
}
private static async Task HasTables_returns_true_when_database_exists_and_has_any_tables_test(bool async)
{
using (var testDatabase = SpannerTestStore.CreateScratch(true))
{
await testDatabase.ExecuteNonQueryAsync(
@"CREATE TABLE SomeTable (
Id INT64 NOT NULL,
) PRIMARY KEY (Id)");
var creator = GetDatabaseCreator(testDatabase);
Assert.True(async
? await((TestDatabaseCreator)creator).HasTablesAsyncBase()
: ((TestDatabaseCreator)creator).HasTablesBase());
}
}
private static async Task Create_throws_if_database_already_exists_test(bool async)
{
using (var testDatabase = SpannerTestStore.CreateScratch(true))
{
var creator = GetDatabaseCreator(testDatabase);
if (async)
{
await Assert.ThrowsAsync <SpannerException>(() => creator.CreateAsync());
}
else
{
Assert.Throws <SpannerException>(() => creator.Create());
}
}
}
private static async Task CreateTables_throws_if_database_does_not_exist_test(bool async)
{
using (var testDatabase = SpannerTestStore.CreateScratch(false))
{
var creator = GetDatabaseCreator(testDatabase);
if (async)
{
await Assert.ThrowsAsync <SpannerException>(() => creator.CreateTablesAsync());
}
else
{
Assert.Throws <AggregateException>(() => creator.CreateTables());
}
}
}
private static async Task Delete_throws_when_database_doesnt_exist_test(bool async)
{
using (var testDatabase = SpannerTestStore.CreateScratch(false))
{
var creator = GetDatabaseCreator(testDatabase);
if (async)
{
await Assert.ThrowsAsync <SpannerException>(() => creator.DeleteAsync());
}
else
{
Assert.Throws <SpannerException>(() => creator.Delete());
}
}
}
private static async Task CreateTables_creates_schema_in_existing_database_test(bool async)
{
using (var testDatabase = SpannerTestStore.CreateScratch(true))
{
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkSpanner()
.BuildServiceProvider();
var optionsBuilder = new DbContextOptionsBuilder()
.UseInternalServiceProvider(serviceProvider)
.UseSpanner(testDatabase.ConnectionString, b => b.ApplyConfiguration());
using (var context = new BloggingContext(optionsBuilder.Options))
{
var creator = (RelationalDatabaseCreator)context.GetService <IDatabaseCreator>();
if (async)
{
await creator.CreateTablesAsync();
}
else
{
creator.CreateTables();
}
if (testDatabase.Connection.State != ConnectionState.Open)
{
await testDatabase.Connection.OpenAsync();
}
var tables =
await testDatabase.QueryAsync <string>(
@"SELECT TABLE_NAME FROM information_schema.tables AS t
WHERE t.table_catalog = '' and t.table_schema = ''");
Assert.Equal(1, tables.Count());
Assert.Equal("Blogs", tables.Single());
var columns =
await testDatabase.QueryAsync <string>(
"SELECT * FROM information_schema.columns WHERE TABLE_NAME='Blogs'");
Assert.Equal(2, columns.Count());
}
}
}
public ExecutionStrategyFixture()
{
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkSpanner()
.AddSingleton <ILoggerFactory>(TestSqlLoggerFactory)
.AddScoped <ISpannerRelationalConnection, TestSpannerConnection>()
.AddScoped <IRelationalCommandBuilderFactory, TestRelationalCommandBuilderFactory>()
.BuildServiceProvider();
_baseOptions = new DbContextOptionsBuilder()
.UseInternalServiceProvider(serviceProvider)
.EnableSensitiveDataLogging()
.Options;
_options = new DbContextOptionsBuilder(_baseOptions)
.UseSpanner(SpannerTestStore.CreateConnectionString(DatabaseName), ApplySpannerOptions)
.Options;
}
public OneToOneQuerySpannerFixture()
{
_testStore = SpannerTestStore.CreateScratch();
_options = new DbContextOptionsBuilder()
.UseSpanner(_testStore.ConnectionString)
.UseInternalServiceProvider(new ServiceCollection()
.AddEntityFrameworkSpanner()
.AddSingleton(TestModelSource.GetFactory(OnModelCreating))
.AddSingleton <ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider())
.Options;
using (var context = new DbContext(_options))
{
context.Database.EnsureCreated();
AddTestData(context);
}
}
public BuiltInDataTypesSpannerFixture()
{
_testStore = SpannerTestStore.Create("builtindatatypes");
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkSpanner()
.AddSingleton(TestModelSource.GetFactory(OnModelCreating))
.AddSingleton <ILoggerFactory>(_testSqlLoggerFactory)
.BuildServiceProvider();
_options = new DbContextOptionsBuilder()
.UseSpanner(_testStore.Connection, b => b.ApplyConfiguration())
.EnableSensitiveDataLogging()
.UseInternalServiceProvider(serviceProvider)
.Options;
using (var context = new DbContext(_options))
{
context.Database.EnsureCreated();
}
}
private static async Task Delete_will_delete_database_test(bool async)
{
using (var testDatabase = SpannerTestStore.CreateScratch(true))
{
testDatabase.Connection.Close();
var creator = GetDatabaseCreator(testDatabase);
Assert.True(async ? await creator.ExistsAsync() : creator.Exists());
if (async)
{
await creator.DeleteAsync();
}
else
{
creator.Delete();
}
Assert.False(async ? await creator.ExistsAsync() : creator.Exists());
}
}
public ArrayFixture()
{
_testStore = SpannerTestStore.CreateScratch();
_options = new DbContextOptionsBuilder()
.UseSpanner(_testStore.Connection, b => b.ApplyConfiguration())
.UseInternalServiceProvider(
new ServiceCollection()
.AddEntityFrameworkSpanner()
.AddSingleton <ILoggerFactory>(TestSqlLoggerFactory)
.BuildServiceProvider())
.Options;
using (var ctx = CreateContext())
{
ctx.Database.EnsureCreated();
ctx.SomeEntities.Add(new SomeEntity
{
Id = 1,
SomeArray = new[] { 3, 4 },
SomeBytea = new byte[] { 3, 4 },
SomeMatrix = new[, ] {
{ 5, 6 }, { 7, 8 }
}
});
ctx.SomeEntities.Add(new SomeEntity
{
Id = 2,
SomeArray = new[] { 5, 6, 7 },
SomeBytea = new byte[] { 5, 6, 7 },
SomeMatrix = new[, ] {
{ 10, 11 }, { 12, 13 }
}
});
ctx.SaveChanges();
}
}
private static IRelationalDatabaseCreator GetDatabaseCreator(SpannerTestStore testStore) => CreateContextServices(testStore).GetRequiredService <IRelationalDatabaseCreator>();
