public void Can_depend_on_EntityOptions_with_default_service_provider()
{
using (SqlServerNorthwindContext.GetSharedStore())
{
using (var context = new OptionsContext(
new EntityOptions <OptionsContext>(),
new SqlConnection(SqlServerNorthwindContext.ConnectionString)))
{
Assert.True(context.Customers.Any());
}
}
}
public async Task Can_pass_context_options_to_constructor_and_use_in_builder()
{
using (await SqlServerNorthwindContext.GetSharedStoreAsync())
{
var optionsBuilder = new DbContextOptionsBuilder();
optionsBuilder.UseSqlServer(SqlServerNorthwindContext.ConnectionString);
using (var context = new NorthwindContext(optionsBuilder.Options))
{
Assert.Equal(91, await context.Customers.CountAsync());
}
}
}
public async Task Can_query_with_implicit_services_and_explicit_config()
{
using (await SqlServerNorthwindContext.GetSharedStoreAsync())
{
var optionsBuilder = new DbContextOptionsBuilder();
optionsBuilder.UseSqlServer(SqlServerNorthwindContext.ConnectionString);
using (var context = new NorthwindContext(optionsBuilder.Options))
{
Assert.Equal(91, await context.Customers.CountAsync());
}
}
}
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()
.UseSqlServer(SqlServerNorthwindContext.ConnectionString, b => b.ApplyConfiguration()).Options).BuildServiceProvider();
using (SqlServerNorthwindContext.GetSharedStore())
{
await serviceProvider.GetRequiredService <MyController>().TestAsync();
}
}
public void Can_select_appropriate_provider_when_multiple_registered()
{
var serviceProvider
= new ServiceCollection()
.AddScoped <SomeService>()
.AddDbContext <MultipleProvidersContext>()
.BuildServiceProvider();
using (SqlServerNorthwindContext.GetSharedStore())
{
MultipleProvidersContext context1;
MultipleProvidersContext context2;
using (var serviceScope = serviceProvider.GetRequiredService <IServiceScopeFactory>().CreateScope())
{
using (context1 = serviceScope.ServiceProvider.GetRequiredService <MultipleProvidersContext>())
{
context1.UseSqlServer = true;
Assert.True(context1.Customers.Any());
}
using (var context1B = serviceScope.ServiceProvider.GetRequiredService <MultipleProvidersContext>())
{
Assert.Same(context1, context1B);
}
var someService = serviceScope.ServiceProvider.GetRequiredService <SomeService>();
Assert.Same(context1, someService.Context);
}
using (var serviceScope = serviceProvider.GetRequiredService <IServiceScopeFactory>().CreateScope())
{
using (context2 = serviceScope.ServiceProvider.GetRequiredService <MultipleProvidersContext>())
{
context2.UseSqlServer = false;
Assert.False(context2.Customers.Any());
}
using (var context2B = serviceScope.ServiceProvider.GetRequiredService <MultipleProvidersContext>())
{
Assert.Same(context2, context2B);
}
var someService = serviceScope.ServiceProvider.GetRequiredService <SomeService>();
Assert.Same(context2, someService.Context);
}
Assert.NotSame(context1, context2);
}
}
public async Task Can_register_context_with_DI_container_and_have_it_injected()
{
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkSqlServer()
.AddTransient <NorthwindContext>()
.AddTransient <MyController>()
.AddSingleton(p => new DbContextOptionsBuilder().UseInternalServiceProvider(p).Options)
.BuildServiceProvider();
using (SqlServerNorthwindContext.GetSharedStore())
{
await serviceProvider.GetRequiredService <MyController>().TestAsync();
}
}
public async Task Can_query_with_explicit_services_and_OnConfiguring()
{
using (SqlServerNorthwindContext.GetSharedStore())
{
using (var context = new NorthwindContext(
new DbContextOptionsBuilder().UseInternalServiceProvider(
new ServiceCollection()
.AddEntityFrameworkSqlServer()
.BuildServiceProvider()).Options))
{
Assert.Equal(91, await context.Customers.CountAsync());
}
}
}
public void Can_specify_connection_in_OnConfiguring()
{
var serviceProvider
= new ServiceCollection()
.AddScoped(p => new SqlConnection(SqlServerNorthwindContext.ConnectionString))
.AddDbContext <ConnectionInOnConfiguringContext>().BuildServiceProvider();
using (SqlServerNorthwindContext.GetSharedStore())
{
using (var context = serviceProvider.GetRequiredService <ConnectionInOnConfiguringContext>())
{
Assert.True(context.Customers.Any());
}
}
}
public void Can_depend_on_non_generic_options_when_only_one_context()
{
var serviceProvider
= new ServiceCollection()
.AddDbContext <NonGenericOptionsContext>()
.BuildServiceProvider();
using (SqlServerNorthwindContext.GetSharedStore())
{
using (var context = serviceProvider.GetRequiredService <NonGenericOptionsContext>())
{
Assert.True(context.Customers.Any());
}
}
}
public MappingQuerySqlServerFixture()
{
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkSqlServer()
.AddSingleton <ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider();
_testDatabase = SqlServerNorthwindContext.GetSharedStore();
_options = new DbContextOptionsBuilder()
.UseModel(CreateModel())
.UseSqlServer(_testDatabase.ConnectionString, b => b.ApplyConfiguration())
.UseInternalServiceProvider(serviceProvider)
.Options;
}
public MappingQueryFixture()
{
_serviceProvider = new ServiceCollection()
.AddEntityFramework()
.AddSqlServer()
.ServiceCollection
.AddInstance <ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider();
_testDatabase = SqlServerNorthwindContext.GetSharedStoreAsync().Result;
_options = new DbContextOptions()
.UseModel(CreateModel())
.UseSqlServer(_testDatabase.Connection.ConnectionString);
}
public async void Can_register_multiple_context_types_with_default_service_provider()
{
using (await SqlServerNorthwindContext.GetSharedStoreAsync())
{
using (var context = new MultipleContext1(new DbContextOptions <MultipleContext1>()))
{
Assert.True(context.Customers.Any());
}
using (var context = new MultipleContext2(new DbContextOptions <MultipleContext2>()))
{
Assert.False(context.Customers.Any());
}
}
}
public void Throws_on_attempt_to_use_context_with_no_store()
{
using (SqlServerNorthwindContext.GetSharedStore())
{
Assert.Equal(
CoreStrings.NoProviderConfigured,
Assert.Throws <InvalidOperationException>(() =>
{
using (var context = new NorthwindContext())
{
Assert.Equal(91, context.Customers.Count());
}
}).Message);
}
}
public SqlServerNorthwindQueryFixture()
{
_testStore = SqlServerNorthwindContext.GetSharedStoreAsync().Result;
_serviceProvider = new ServiceCollection()
.AddEntityFramework()
.AddSqlServer()
.ServiceCollection
.AddTestModelSource(OnModelCreating)
.AddInstance <ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider();
_options = new DbContextOptions();
_options.UseSqlServer(_testStore.Connection.ConnectionString);
}
public async Task Can_use_one_context_nested_inside_another_of_a_different_type()
{
using (await SqlServerNorthwindContext.GetSharedStoreAsync())
{
var serviceCollection = new ServiceCollection();
serviceCollection
.AddEntityFramework()
.AddSqlServer()
.AddInMemoryStore();
var serviceProvider = serviceCollection.BuildServiceProvider();
await NestedContextTest(() => new BlogContext(serviceProvider), () => new NorthwindContext(serviceProvider));
}
}
public void Can_depend_on_DbContextOptions()
{
var serviceProvider
= new ServiceCollection()
.AddScoped(p => new SqlConnection(SqlServerNorthwindContext.ConnectionString))
.AddDbContext <OptionsContext>()
.BuildServiceProvider();
using (SqlServerNorthwindContext.GetSharedStore())
{
using (var context = serviceProvider.GetRequiredService <OptionsContext>())
{
Assert.True(context.Customers.Any());
}
}
}
public async Task Tracking_entities_asynchronously_returns_tracked_entities_back()
{
using (SqlServerNorthwindContext.GetSharedStore())
{
using (var db = new NorthwindContext(_fixture.ServiceProvider))
{
var customer = await db.Customers.FirstOrDefaultAsync();
var trackedCustomerEntry = db.ChangeTracker.Entries().Single();
Assert.Same(trackedCustomerEntry.Entity, customer);
// if references are different this will throw
db.Customers.Remove(customer);
}
}
}
public MappingQuerySqlServerFixture()
{
_serviceProvider = new ServiceCollection()
.AddEntityFramework()
.AddSqlServer()
.ServiceCollection()
.AddSingleton <ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider();
_testDatabase = SqlServerNorthwindContext.GetSharedStore();
var optionsBuilder = new DbContextOptionsBuilder().UseModel(CreateModel());
optionsBuilder.UseSqlServer(_testDatabase.ConnectionString);
_options = optionsBuilder.Options;
}
public async Task Can_query_with_explicit_services_and_OnConfiguring()
{
using (await SqlServerNorthwindContext.GetSharedStoreAsync())
{
var serviceCollection = new ServiceCollection();
serviceCollection
.AddEntityFramework()
.AddSqlServer();
var serviceProvider = serviceCollection.BuildServiceProvider();
using (var context = new NorthwindContext(serviceProvider))
{
Assert.Equal(91, await context.Customers.CountAsync());
}
}
}
public NorthwindSprocQuerySqlServerFixture()
{
_testStore = SqlServerNorthwindContext.GetSharedStore();
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkSqlServer()
.AddSingleton(TestSqlServerModelSource.GetFactory(OnModelCreating))
.AddSingleton <ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider();
_options = new DbContextOptionsBuilder()
.EnableSensitiveDataLogging()
.UseInternalServiceProvider(serviceProvider)
.UseSqlServer(_testStore.ConnectionString).Options;
serviceProvider.GetRequiredService <ILoggerFactory>();
}
public void Throws_on_attempt_to_use_SQL_Server_without_providing_connection_string()
{
using (SqlServerNorthwindContext.GetSharedStore())
{
Assert.Equal(
CoreStrings.NoProviderConfigured,
Assert.Throws <InvalidOperationException>(() =>
{
using (var context = new NorthwindContext(
new DbContextOptionsBuilder().UseInternalServiceProvider(new ServiceCollection()
.AddEntityFrameworkSqlServer()
.BuildServiceProvider()).Options))
{
Assert.Equal(91, context.Customers.Count());
}
}).Message);
}
}
public async Task Can_register_context_with_DI_container_and_have_it_injected()
{
var serviceCollection = new ServiceCollection();
serviceCollection
.AddEntityFramework()
.AddSqlServer();
var serviceProvider = serviceCollection
.AddTransient <NorthwindContext>()
.AddTransient <MyController>()
.BuildServiceProvider();
using (await SqlServerNorthwindContext.GetSharedStoreAsync())
{
await serviceProvider.GetRequiredService <MyController>().TestAsync();
}
}
public async void Can_specify_connection_string_in_OnConfiguring()
{
var serviceCollection = new ServiceCollection();
serviceCollection
.AddEntityFramework()
.AddSqlServer()
.AddDbContext<StringInOnConfiguringContext>();
var serviceProvider = serviceCollection.BuildServiceProvider();
using (await SqlServerNorthwindContext.GetSharedStoreAsync())
{
using (var context = serviceProvider.GetRequiredService<StringInOnConfiguringContext>())
{
Assert.True(context.Customers.Any());
}
}
}
public async Task Can_use_actual_connection_string_in_OnConfiguring()
{
var serviceCollection = new ServiceCollection();
serviceCollection
.AddEntityFramework()
.AddSqlServer();
var serviceProvider = serviceCollection.BuildServiceProvider();
using (await SqlServerNorthwindContext.GetSharedStoreAsync())
{
using (var context = new NorthwindContext(serviceProvider, SqlServerNorthwindContext.ConnectionString))
{
Assert.Equal(91, await context.Customers.CountAsync());
}
}
}
public void Can_enumerate_entity_set()
{
using (SqlServerNorthwindContext.GetSharedStore())
{
using (var db = new NorthwindContext(_fixture.ServiceProvider))
{
var results = new List <Customer>();
foreach (var item in db.Customers)
{
results.Add(item);
}
Assert.Equal(91, results.Count);
Assert.Equal("ALFKI", results[0].CustomerID);
Assert.Equal("Alfreds Futterkiste", results[0].CompanyName);
}
}
}
public async void Can_depend_on_DbContextOptions()
{
var serviceCollection = new ServiceCollection();
serviceCollection
.AddScoped<SqlConnection>(p => new SqlConnection(SqlServerNorthwindContext.ConnectionString))
.AddEntityFramework()
.AddSqlServer()
.AddDbContext<OptionsContext>();
var serviceProvider = serviceCollection.BuildServiceProvider();
using (await SqlServerNorthwindContext.GetSharedStoreAsync())
{
using (var context = serviceProvider.GetRequiredService<OptionsContext>())
{
Assert.True(context.Customers.Any());
}
}
}
public async void Can_select_appropriate_provider_when_multiple_registered_with_default_service_provider()
{
using (await SqlServerNorthwindContext.GetSharedStoreAsync())
{
using (var context = new MultipleProvidersContext())
{
context.UseSqlServer = true;
Assert.True(context.Customers.Any());
}
using (var context = new MultipleProvidersContext())
{
context.UseSqlServer = false;
Assert.False(context.Customers.Any());
}
}
}
public async void Can_depend_on_non_generic_options_when_only_one_context()
{
var serviceCollection = new ServiceCollection();
serviceCollection
.AddEntityFramework()
.AddSqlServer()
.AddInMemoryStore()
.AddDbContext <NonGenericOptionsContext>();
var serviceProvider = serviceCollection.BuildServiceProvider();
using (await SqlServerNorthwindContext.GetSharedStoreAsync())
{
using (var context = serviceProvider.GetRequiredService <NonGenericOptionsContext>())
{
Assert.True(context.Customers.Any());
}
}
}
public void Can_register_multiple_context_types()
{
var serviceProvider = new ServiceCollection()
.AddDbContext <MultipleContext1>()
.AddDbContext <MultipleContext2>()
.BuildServiceProvider();
using (SqlServerNorthwindContext.GetSharedStore())
{
using (var context = serviceProvider.GetRequiredService <MultipleContext1>())
{
Assert.True(context.Customers.Any());
}
using (var context = serviceProvider.GetRequiredService <MultipleContext2>())
{
Assert.False(context.Customers.Any());
}
}
}
public async Task Can_query_with_explicit_services_and_explicit_config()
{
using (SqlServerNorthwindContext.GetSharedStore())
{
var serviceCollection = new ServiceCollection();
serviceCollection
.AddEntityFramework()
.AddSqlServer();
var serviceProvider = serviceCollection.BuildServiceProvider();
var optionsBuilder = new DbContextOptionsBuilder();
optionsBuilder.UseSqlServer(SqlServerNorthwindContext.ConnectionString);
using (var context = new NorthwindContext(serviceProvider, optionsBuilder.Options))
{
Assert.Equal(91, await context.Customers.CountAsync());
}
}
}
