public override SqlCeTestStore CreateTestStore() { var testStore = SqlCeTestStore.CreateScratch(true); _options = new DbContextOptionsBuilder() .UseSqlCe(testStore.Connection, b => b.ApplyConfiguration()) .UseInternalServiceProvider(_serviceProvider) .Options; using (var context = new GraphUpdatesContext(_options)) { context.Database.EnsureClean(); Seed(context); } //var testStore = SqlCeTestStore.GetOrCreateShared(DatabaseName, () => //{ // var options = new DbContextOptionsBuilder() // .UseSqlCe(SqlCeTestStore.CreateConnectionString(DatabaseName), b => b.ApplyConfiguration()) // .UseInternalServiceProvider(_serviceProvider) // .Options; // using (var context = new GraphUpdatesContext(options)) // { // context.Database.EnsureDeleted(); // Seed(context); // } //}); return(testStore); }
private static async Task EnsuredDeleted_noop_when_database_doesnt_exist_test(bool async) { using (var testDatabase = await SqlCeTestStore.CreateScratchAsync(createDatabase: false)) { using (var context = new BloggingContext(testDatabase)) { var creator = context.GetService <IRelationalDatabaseCreator>(); Assert.False(async ? await creator.ExistsAsync() : creator.Exists()); if (async) { Assert.False(await creator.EnsureDeletedAsync()); } else { Assert.False(creator.EnsureDeleted()); } Assert.Equal(ConnectionState.Closed, context.Database.GetDbConnection().State); Assert.False(async ? await creator.ExistsAsync() : creator.Exists()); Assert.Equal(ConnectionState.Closed, context.Database.GetDbConnection().State); } } }
private static async Task EnsureCreated_can_create_physical_database_and_schema_test(bool async) { using (var testDatabase = await SqlCeTestStore.CreateScratchAsync(createDatabase: false)) { await RunDatabaseCreationTest(testDatabase, async); } }
private static async Task Create_creates_physical_database_but_not_tables_test(bool async) { using (var testDatabase = SqlCeTestStore.CreateScratch(createDatabase: 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, (testDatabase.Query <string>("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES")).Count()); Assert.True(testDatabase.Exists()); } }
public async Task Can_use_one_context_nested_inside_another_of_the_same_type() { using (SqlCeTestStore.GetNorthwindStore()) { var serviceProvider = new ServiceCollection() .AddEntityFrameworkSqlCe() .BuildServiceProvider(); using (var context1 = new NorthwindContext(serviceProvider)) { var customers1 = await context1.Customers.ToListAsync(); Assert.Equal(91, customers1.Count); Assert.Equal(91, context1.ChangeTracker.Entries().Count()); using (var context2 = new NorthwindContext(serviceProvider)) { Assert.Equal(0, context2.ChangeTracker.Entries().Count()); var customers2 = await context2.Customers.ToListAsync(); Assert.Equal(91, customers2.Count); Assert.Equal(91, context2.ChangeTracker.Entries().Count()); Assert.Equal(customers1[0].CustomerID, customers2[0].CustomerID); Assert.NotSame(customers1[0], customers2[0]); } } } }
private static async Task EnsureCreated_can_create_schema_in_existing_database_test(bool async) { using (var testDatabase = await SqlCeTestStore.CreateScratchAsync()) { await RunDatabaseCreationTest(testDatabase, async); } }
private static IServiceProvider CreateContextServices(SqlCeTestStore testStore) => ((IInfrastructure <IServiceProvider>) new BloggingContext( new DbContextOptionsBuilder() .UseSqlCe(testStore.ConnectionString) .UseInternalServiceProvider(new ServiceCollection() .AddEntityFrameworkSqlCe() .AddScoped <IRelationalDatabaseCreator, TestDatabaseCreator>().BuildServiceProvider()).Options)) .Instance;
private static async Task Exists_returns_true_when_database_exists_test(bool async) { using (var testDatabase = SqlCeTestStore.CreateScratch(createDatabase: true)) { var creator = GetDatabaseCreator(testDatabase); Assert.True(async ? await creator.ExistsAsync() : creator.Exists()); } }
private static async Task HasTables_returns_false_when_database_exists_but_has_no_tables_test(bool async) { using (var testDatabase = SqlCeTestStore.CreateScratch(createDatabase: true)) { var creator = GetDatabaseCreator(testDatabase); Assert.False(async ? await((TestDatabaseCreator)creator).HasTablesAsyncBase() : ((TestDatabaseCreator)creator).HasTablesBase()); } }
public async Task Can_query_with_implicit_services_and_OnConfiguring() { using (SqlCeTestStore.GetNorthwindStore()) { using (var context = new NorthwindContext()) { Assert.Equal(91, await context.Customers.CountAsync()); } } }
public async Task Can_pass_connection_string_to_constructor_and_use_in_OnConfiguring() { using (SqlCeTestStore.GetNorthwindStore()) { using (var context = new NorthwindContext(SqlCeTestStore.NorthwindConnectionString)) { Assert.Equal(91, await context.Customers.CountAsync()); } } }
public NotificationEntitiesSqlCeFixture() { _options = new DbContextOptionsBuilder() .UseSqlCe(SqlCeTestStore.CreateConnectionString(DatabaseName), b => b.ApplyConfiguration()) .UseInternalServiceProvider(new ServiceCollection() .AddEntityFrameworkSqlCe() .AddSingleton(TestModelSource.GetFactory(OnModelCreating)) .BuildServiceProvider()) .Options; }
private static async Task HasTables_returns_true_when_database_exists_and_has_any_tables_test(bool async) { using (var testDatabase = SqlCeTestStore.CreateScratch(createDatabase: true)) { testDatabase.ExecuteNonQuery("CREATE TABLE SomeTable (Id uniqueidentifier)"); var creator = GetDatabaseCreator(testDatabase); Assert.True(async ? await((TestDatabaseCreator)creator).HasTablesAsyncBase() : ((TestDatabaseCreator)creator).HasTablesBase()); } }
public override SqlCeTestStore CreateTestStore() { return(SqlCeTestStore.GetOrCreateShared(DatabaseName, () => { using (var context = new FindContext(_options)) { context.Database.EnsureClean(); Seed(context); } })); }
public async Task Can_pass_context_options_to_constructor_and_use_in_builder() { using (SqlCeTestStore.GetNorthwindStore()) { using (var context = new NorthwindContext(new DbContextOptionsBuilder() .UseSqlCe(SqlCeTestStore.NorthwindConnectionString, b => b.ApplyConfiguration()).Options)) { Assert.Equal(91, await context.Customers.CountAsync()); } } }
protected override void CreateAndSeedDatabase(string databaseName, Func <MonsterContext> createContext, Action <MonsterContext> seed) { _testStore = SqlCeTestStore.GetOrCreateShared(databaseName, () => { using (var context = createContext()) { context.Database.EnsureCreated(); seed(context); } }); }
public override DbContext CreateContext(SqlCeTestStore testStore) { var optionsBuilder = new DbContextOptionsBuilder() .UseSqlCe(testStore.Connection, b => b.ApplyConfiguration()) .UseInternalServiceProvider(_serviceProvider); var context = new FieldMappingContext(optionsBuilder.Options); context.Database.UseTransaction(testStore.Transaction); return(context); }
public async Task Can_query_with_implicit_services_and_explicit_config() { using (SqlCeTestStore.GetNorthwindStore()) { using (var context = new NorthwindContext( new DbContextOptionsBuilder() .UseSqlCe(SqlCeTestStore.NorthwindConnectionString, b => b.ApplyConfiguration()).Options)) { Assert.Equal(91, await context.Customers.CountAsync()); } } }
public void Empty_Migration_Creates_Database() { using (var testDatabase = SqlCeTestStore.CreateScratch(createDatabase: false)) { using (var context = CreateContext(testDatabase)) { context.Database.Migrate(); Assert.True(context.GetService <IRelationalDatabaseCreator>().Exists()); } } }
public override DbContext CreateContext(SqlCeTestStore testStore) { var optionsBuilder = new DbContextOptionsBuilder() .UseSqlCe(testStore.Connection) .UseInternalServiceProvider(_serviceProvider); var context = new AdvancedPatternsMasterContext(optionsBuilder.Options); context.Database.UseTransaction(testStore.Transaction); return(context); }
private static async Task RunDatabaseCreationTest(SqlCeTestStore testStore, bool async) { using (var context = new BloggingContext(testStore)) { var creator = context.GetService <IRelationalDatabaseCreator>(); if (async) { Assert.True(await creator.EnsureCreatedAsync()); } else { Assert.True(creator.EnsureCreated()); } Assert.Equal(ConnectionState.Closed, context.Database.GetDbConnection().State); if (testStore.Connection.State != ConnectionState.Open) { await testStore.Connection.OpenAsync(); } var tables = testStore.Query <string>("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES "); Assert.Equal(1, tables.Count()); Assert.Equal("Blogs", tables.Single()); var columns = (testStore.Query <string>( "SELECT TABLE_NAME + '.' + COLUMN_NAME + ' (' + DATA_TYPE + ')' FROM INFORMATION_SCHEMA.COLUMNS ORDER BY TABLE_NAME, COLUMN_NAME")).ToArray(); Assert.Equal(15, columns.Length); Assert.Equal( new[] { "Blogs.AndChew (varbinary)", "Blogs.AndRow (rowversion)", "Blogs.Cheese (nvarchar)", "Blogs.CupOfChar (int)", "Blogs.ErMilan (int)", "Blogs.Fuse (smallint)", "Blogs.George (bit)", "Blogs.Key1 (nvarchar)", "Blogs.Key2 (varbinary)", "Blogs.NotFigTime (datetime)", "Blogs.On (real)", "Blogs.OrNothing (float)", "Blogs.TheGu (uniqueidentifier)", "Blogs.ToEat (tinyint)", "Blogs.WayRound (bigint)" }, columns); } }
public async Task Can_register_context_and_configuration_with_DI_container_and_have_both_injected() { var serviceProvider = new ServiceCollection() .AddTransient <MyController>() .AddTransient <NorthwindContext>() .AddSingleton(new DbContextOptionsBuilder() .UseSqlCe(SqlCeTestStore.NorthwindConnectionString, b => b.ApplyConfiguration()).Options).BuildServiceProvider(); using (SqlCeTestStore.GetNorthwindStore()) { await serviceProvider.GetRequiredService <MyController>().TestAsync(); } }
public FindSqlCeFixture() { var serviceProvider = new ServiceCollection() .AddEntityFrameworkSqlCe() .AddSingleton(TestModelSource.GetFactory(OnModelCreating)) .AddSingleton <ILoggerFactory>(TestSqlLoggerFactory) .BuildServiceProvider(); _options = new DbContextOptionsBuilder() .UseSqlCe(SqlCeTestStore.CreateConnectionString(DatabaseName), b => b.ApplyConfiguration()) .UseInternalServiceProvider(serviceProvider) .EnableSensitiveDataLogging() .Options; }
public async Task Can_query_with_explicit_services_and_OnConfiguring() { using (SqlCeTestStore.GetNorthwindStore()) { using (var context = new NorthwindContext( new DbContextOptionsBuilder().UseInternalServiceProvider( new ServiceCollection() .AddEntityFrameworkSqlCe() .BuildServiceProvider()).Options)) { Assert.Equal(91, await context.Customers.CountAsync()); } } }
public async Task Can_register_context_with_DI_container_and_have_it_injected() { var serviceProvider = new ServiceCollection() .AddEntityFrameworkSqlCe() .AddTransient <NorthwindContext>() .AddTransient <MyController>() .AddSingleton(p => new DbContextOptionsBuilder().UseInternalServiceProvider(p).Options) .BuildServiceProvider(); using (SqlCeTestStore.GetNorthwindStore()) { await serviceProvider.GetRequiredService <MyController>().TestAsync(); } }
private static async Task Exists_returns_true_when_database_exists_test(bool async) { using (var testDatabase = await SqlCeTestStore.CreateScratchAsync(createDatabase: true)) { using (var context = new BloggingContext(testDatabase)) { var creator = context.GetService <IRelationalDatabaseCreator>(); Assert.True(async ? await creator.ExistsAsync() : creator.Exists()); Assert.Equal(ConnectionState.Closed, context.Database.GetDbConnection().State); } } }
public void Throws_on_attempt_to_use_context_with_no_store() { using (SqlCeTestStore.GetNorthwindStore()) { Assert.Equal( CoreStrings.NoProviderConfigured, Assert.Throws <InvalidOperationException>(() => { using (var context = new NorthwindContext()) { Assert.Equal(91, context.Customers.Count()); } }).Message); } }
public override SqlCeTestStore CreateTestStore() { return(SqlCeTestStore.GetOrCreateShared(DatabaseName, () => { var optionsBuilder = new DbContextOptionsBuilder() .UseSqlCe(SqlCeTestStore.CreateConnectionString(DatabaseName)) .UseInternalServiceProvider(_serviceProvider); using (var context = new AdvancedPatternsMasterContext(optionsBuilder.Options)) { context.Database.EnsureClean(); Seed(context); } })); }
private static async Task HasTables_throws_when_database_doesnt_exist_test(bool async) { using (var testDatabase = SqlCeTestStore.CreateScratch(createDatabase: false)) { var creator = GetDatabaseCreator(testDatabase); var errorNumber = async ? (await Assert.ThrowsAsync <SqlCeException>(() => ((TestDatabaseCreator)creator).HasTablesAsyncBase())).NativeError : Assert.Throws <SqlCeException>(() => ((TestDatabaseCreator)creator).HasTablesBase()).NativeError; Assert.Equal( 25046, // The database file cannot be found. Check the path to the database. errorNumber); } }
public NullKeysSqlCeFixture() { var name = "StringsContext"; var connectionString = SqlCeTestStore.CreateConnectionString(name); _options = new DbContextOptionsBuilder() .UseSqlCe(connectionString, b => b.ApplyConfiguration()) .UseInternalServiceProvider(new ServiceCollection() .AddEntityFrameworkSqlCe() .AddSingleton(TestModelSource.GetFactory(OnModelCreating)) .BuildServiceProvider()) .Options; _testStore = SqlCeTestStore.GetOrCreateShared(name, EnsureCreated); }