private static void CreateTestStore <TContext>(
string databaseName,
IServiceProvider serviceProvider,
Func <IServiceProvider, EntityOptions, TContext> contextCreator,
Action <TContext> contextInitializer)
where TContext : DbContext, IDisposable
{
var connectionString = SqlServerTestStore.CreateConnectionString(databaseName);
SqlServerTestStore.GetOrCreateShared(databaseName, () =>
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(connectionString);
using (var context = contextCreator(serviceProvider, optionsBuilder.Options))
{
if (context.Database.EnsureCreated())
{
contextInitializer(context);
}
TestSqlLoggerFactory.SqlStatements.Clear();
}
});
}
protected override void OnConfiguring(EntityOptionsBuilder optionsBuilder)
{
var connString = Startup.Configuration["Data:WorldContextConnection"];
optionsBuilder.UseSqlServer(connString);
base.OnConfiguring(optionsBuilder);
}
private static SqlServerOptionsExtension GetOrCreateExtension(EntityOptionsBuilder optionsBuilder)
{
var existing = optionsBuilder.Options.FindExtension<SqlServerOptionsExtension>();
return existing != null
? new SqlServerOptionsExtension(existing)
: new SqlServerOptionsExtension();
}
public void Can_save_and_query_with_implicit_services_and_explicit_config()
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseInMemoryStore();
using (var context = new ImplicitServicesExplicitConfigBlogContext(optionsBuilder.Options))
{
context.Blogs.Add(new Blog {
Name = "The Waffle Cart"
});
context.SaveChanges();
}
using (var context = new ImplicitServicesExplicitConfigBlogContext(optionsBuilder.Options))
{
var blog = context.Blogs.SingleOrDefault();
Assert.NotEqual(0, blog.Id);
Assert.Equal("The Waffle Cart", blog.Name);
context.Blogs.RemoveRange(context.Blogs);
context.SaveChanges();
Assert.Empty(context.Blogs);
}
}
public void Cannot_inject_different_configurations_into_different_contexts_both_as_base_type_without_constructor()
{
var blogOptions = new EntityOptionsBuilder <InjectDifferentConfigurationsNoConstructorBlogContext>();
blogOptions.UseInMemoryStore();
var accountOptions = new EntityOptionsBuilder <InjectDifferentConfigurationsNoConstructorAccountContext>();
accountOptions.UseInMemoryStore();
var services = new ServiceCollection();
services.AddTransient <InjectDifferentConfigurationsNoConstructorBlogContext>()
.AddTransient <InjectDifferentConfigurationsNoConstructorAccountContext>()
.AddTransient <InjectDifferentConfigurationsNoConstructorBlogController>()
.AddTransient <InjectDifferentConfigurationsNoConstructorAccountController>()
.AddInstance <EntityOptions>(blogOptions.Options)
.AddInstance <EntityOptions>(accountOptions.Options)
.AddEntityFramework()
.AddInMemoryStore();
var serviceProvider = services.BuildServiceProvider();
Assert.Equal(
CoreStrings.NonGenericOptions,
Assert.Throws <InvalidOperationException>(
() => serviceProvider.GetRequiredService <InjectDifferentConfigurationsNoConstructorBlogController>().Test()).Message);
}
protected override void OnConfiguring(EntityOptionsBuilder optionsBuilder)
{
if (!string.IsNullOrWhiteSpace(_connectionString))
{
optionsBuilder.UseSqlServer(_connectionString);
}
}
public void Can_save_and_query_with_explicit_services_and_explicit_config()
{
var services = new ServiceCollection();
services.AddEntityFramework().AddInMemoryStore();
var serviceProvider = services.BuildServiceProvider();
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseInMemoryStore();
using (var context = new ExplicitServicesAndConfigBlogContext(serviceProvider, optionsBuilder.Options))
{
context.Blogs.Add(new Blog {
Name = "The Waffle Cart"
});
context.SaveChanges();
}
using (var context = new ExplicitServicesAndConfigBlogContext(serviceProvider, optionsBuilder.Options))
{
var blog = context.Blogs.SingleOrDefault();
Assert.NotEqual(0, blog.Id);
Assert.Equal("The Waffle Cart", blog.Name);
context.Blogs.RemoveRange(context.Blogs);
context.SaveChanges();
Assert.Empty(context.Blogs);
}
}
public void Can_inject_different_configurations_into_different_contexts_without_declaring_in_constructor()
{
var blogOptions = new EntityOptionsBuilder <InjectDifferentConfigurationsNoConstructorBlogContext>();
blogOptions.UseInMemoryStore();
var accountOptions = new EntityOptionsBuilder <InjectDifferentConfigurationsNoConstructorAccountContext>();
accountOptions.UseInMemoryStore();
var services = new ServiceCollection();
services.AddTransient <InjectDifferentConfigurationsNoConstructorBlogContext>()
.AddTransient <InjectDifferentConfigurationsNoConstructorAccountContext>()
.AddTransient <InjectDifferentConfigurationsNoConstructorBlogController>()
.AddTransient <InjectDifferentConfigurationsNoConstructorAccountController>()
.AddInstance(blogOptions.Options)
.AddInstance(accountOptions.Options)
.AddEntityFramework()
.AddInMemoryStore();
var serviceProvider = services.BuildServiceProvider();
serviceProvider.GetRequiredService <InjectDifferentConfigurationsNoConstructorBlogController>().Test();
serviceProvider.GetRequiredService <InjectDifferentConfigurationsNoConstructorAccountController>().Test();
}
public static IEntityOptions CreateOptions()
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(@"Server=(localdb)\MSSQLLocalDB;Database=SqlServerConnectionTest;Trusted_Connection=True;");
return optionsBuilder.Options;
}
public void Is_configured_when_configuration_contains_associated_extension()
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseInMemoryStore();
Assert.True(new InMemoryDataStoreSource().IsConfigured(optionsBuilder.Options));
}
public OneToOneQuerySqlServerFixture()
{
_serviceProvider
= new ServiceCollection()
.AddEntityFramework()
.AddSqlServer()
.ServiceCollection()
.AddSingleton(TestSqlServerModelSource.GetFactory(OnModelCreating))
.AddInstance <ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider();
var database = SqlServerTestStore.CreateScratch();
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(database.Connection.ConnectionString);
_options = optionsBuilder.Options;
using (var context = new DbContext(_serviceProvider, _options))
{
context.Database.EnsureCreated();
AddTestData(context);
}
}
public void Batches_are_divided_correctly_with_two_inserted_columns()
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(_testStore.Connection);
using (var context = new BloggingContext(_serviceProvider, optionsBuilder.Options))
{
context.Database.EnsureCreated();
for (var i = 1; i < 1101; i++)
{
var blog = new Blog {
Id = i, Name = "Foo" + i
};
context.Blogs.Add(blog);
}
context.SaveChanges();
}
using (var context = new BloggingContext(_serviceProvider, optionsBuilder.Options))
{
Assert.Equal(1100, context.Blogs.Count());
}
}
private static IInMemoryDataStore CreateStore(IServiceProvider serviceProvider, bool persist)
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseInMemoryStore(persist: persist);
return InMemoryTestHelpers.Instance.CreateContextServices(serviceProvider, optionsBuilder.Options).GetRequiredService<IInMemoryDataStore>();
}
public void Is_configured_when_configuration_contains_associated_extension()
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer("Database=Crunchie");
Assert.True(new SqlServerDataStoreSource().IsConfigured(optionsBuilder.Options));
}
protected override void OnConfiguring(EntityOptionsBuilder options)
{
//options.UseInMemoryStore(persist: true);
//options.UseSqlServer();
//options.UseSqlServer(@"Server=.\SQLEXPRESS;Database=Blogging;integrated security=True;");
}
public void Model_can_be_set_explicitly_in_options()
{
var model = new Model();
var optionsBuilder = new EntityOptionsBuilder().UseModel(model);
Assert.Same(model, optionsBuilder.Options.FindExtension <CoreOptionsExtension>().Model);
}
public EntityOptions CreateOptions()
{
var optionsBuilder = new EntityOptionsBuilder();
UseProviderOptions(optionsBuilder);
return(optionsBuilder.Options);
}
protected override void OnConfiguring(EntityOptionsBuilder optionsBuilder)
{
Assert.Same(_options, optionsBuilder.Options);
optionsBuilder.UseInMemoryStore();
Assert.NotSame(_options, optionsBuilder.Options);
}
public static IEntityOptions CreateOptions()
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(@"Server=(localdb)\MSSQLLocalDB;Database=SqlServerConnectionTest;Trusted_Connection=True;");
return(optionsBuilder.Options);
}
protected override void OnConfiguring(EntityOptionsBuilder optionsBuilder)
{
Assert.Same(_options, optionsBuilder.Options);
optionsBuilder.UseSqlServer(SqlServerNorthwindContext.ConnectionString);
Assert.NotSame(_options, optionsBuilder.Options);
}
public override DbContext CreateContext(DbConnection connection)
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(connection);
return(new DbContext(_serviceProvider, optionsBuilder.Options));
}
public EntityOptions CreateOptions(IModel model)
{
var optionsBuilder = new EntityOptionsBuilder();
UseProviderOptions(optionsBuilder.UseModel(model));
return(optionsBuilder.Options);
}
public override DbContext CreateContext(SqlServerTestStore testStore)
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(testStore.Connection.ConnectionString);
return(new DbContext(_serviceProvider, optionsBuilder.Options));
}
protected override void OnConfiguring(EntityOptionsBuilder optionsBuilder)
{
Assert.Same(_options, optionsBuilder.Options);
optionsBuilder.UseSqlServer(_connection);
Assert.NotSame(_options, optionsBuilder.Options);
}
protected override EntityOptions CreateOptions(string databaseName)
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(CreateConnectionString(databaseName));
return(optionsBuilder.Options);
}
public void Is_configured_when_configuration_contains_associated_extension()
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseInMemoryStore();
Assert.True(new InMemoryDataStoreSource().IsConfigured(optionsBuilder.Options));
}
protected override EntityOptions CreateOptions(string databaseName)
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseInMemoryStore();
return(optionsBuilder.Options);
}
private static IInMemoryDataStore CreateStore(IServiceProvider serviceProvider, bool persist)
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseInMemoryStore(persist: persist);
return(InMemoryTestHelpers.Instance.CreateContextServices(serviceProvider, optionsBuilder.Options).GetRequiredService <IInMemoryDataStore>());
}
public void Model_can_be_set_explicitly_in_options()
{
var model = new Model();
var optionsBuilder = new EntityOptionsBuilder().UseModel(model);
Assert.Same(model, optionsBuilder.Options.FindExtension<CoreOptionsExtension>().Model);
}
public void Is_configured_when_configuration_contains_associated_extension()
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer("Database=Crunchie");
Assert.True(new SqlServerDataStoreSource().IsConfigured(optionsBuilder.Options));
}
public async Task Can_save_changes_in_tracked_entities()
{
using (var testDatabase = await SqlServerTestStore.CreateScratchAsync())
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(testDatabase.Connection.ConnectionString);
int updatedId;
int deletedId;
int addedId;
using (var db = new BloggingContext(_fixture.ServiceProvider, optionsBuilder.Options))
{
var blogs = await CreateBlogDatabaseAsync <Blog>(db);
var toAdd = db.Blogs.Add(new Blog
{
Name = "Blog to Insert",
George = true,
TheGu = new Guid("0456AEF1-B7FC-47AA-8102-975D6BA3A9BF"),
NotFigTime = new DateTime(1973, 9, 3, 0, 10, 33, 777),
ToEat = 64,
OrNothing = 0.123456789,
Fuse = 777,
WayRound = 9876543210,
Away = 0.12345f,
AndChew = new byte[16]
}).Entity;
db.Entry(toAdd).State = EntityState.Detached;
var toUpdate = blogs[0];
toUpdate.Name = "Blog is Updated";
updatedId = toUpdate.Id;
var toDelete = blogs[1];
toDelete.Name = "Blog to delete";
deletedId = toDelete.Id;
db.Remove(toDelete);
db.Entry(toAdd).State = EntityState.Added;
await db.SaveChangesAsync();
addedId = toAdd.Id;
Assert.NotEqual(0, addedId);
Assert.Equal(EntityState.Unchanged, db.Entry(toUpdate).State);
Assert.Equal(EntityState.Unchanged, db.Entry(toAdd).State);
Assert.DoesNotContain(toDelete, db.ChangeTracker.Entries().Select(e => e.Entity));
}
using (var db = new BloggingContext(_fixture.ServiceProvider, optionsBuilder.Options))
{
var toUpdate = db.Blogs.Single(b => b.Id == updatedId);
Assert.Equal("Blog is Updated", toUpdate.Name);
Assert.Equal(0, db.Blogs.Count(b => b.Id == deletedId));
Assert.Equal("Blog to Insert", db.Blogs.Single(b => b.Id == addedId).Name);
}
}
}
private static IServiceProvider CreateContextServices(IModel model)
{
var optionsBuilder = new EntityOptionsBuilder()
.UseModel(model);
optionsBuilder.UseInMemoryStore(persist: false);
return(((IAccessor <IServiceProvider>) new DbContext(optionsBuilder.Options)).Service);
}
protected override void OnConfiguring(EntityOptionsBuilder optionsBuilder)
{
var sqlBuilder = optionsBuilder.UseSqlServer(_connectionString);
if (_disableBatching)
{
sqlBuilder.MaxBatchSize(1);
}
}
//protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
//{
// base.OnConfiguring(optionsBuilder);
// optionsBuilder.UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=EFGetStarted.ConsoleApp;Trusted_Connection=True;");
//}
//EntityOptionsBuilder
protected override void OnConfiguring(EntityOptionsBuilder optionsBuilder)
{
//var connectionStringBuilder = new SqliteConnectionStringBuilder { DataSource = "test.db" };
//var connectionString = connectionStringBuilder.ToString();
//var connection = new SqliteConnection(connectionString);
//optionsBuilder.UseSqlite(connection);
optionsBuilder.UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=EFGetStarted.ConsoleApp;Trusted_Connection=True;");
}
protected override void OnConfiguring(EntityOptionsBuilder optionsBuilder)
{
var sqlBuilder = optionsBuilder.UseSqlServer(_connectionString);
if (_disableBatching)
{
sqlBuilder.MaxBatchSize(1);
}
}
protected override void OnConfiguring(EntityOptionsBuilder optionsBuilder)
{
// TODO GitHubIssue#57: Complete EF7 to EDM model mapping
// Seems for now EF7 can't support named connection string like "name=NorthwindConnection",
// find an equivalent approach when it's ready.
optionsBuilder.UseSqlServer(@"data source=(LocalDB)\v11.0;attachdbfilename=|DataDirectory|\Northwind.mdf;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework");
base.OnConfiguring(optionsBuilder);
}
public void Can_add_extension_with_connection_string_using_generic_builder()
{
var optionsBuilder = new EntityOptionsBuilder<DbContext>();
optionsBuilder.UseInMemoryStore(persist: false);
var extension = (InMemoryOptionsExtension)optionsBuilder.Options.Extensions.Single();
Assert.False(extension.Persist);
}
public void Can_add_extension_with_max_batch_size()
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer("Database=Crunchie").MaxBatchSize(123);
var extension = optionsBuilder.Options.Extensions.OfType<SqlServerOptionsExtension>().Single();
Assert.Equal(123, extension.MaxBatchSize);
}
public void Can_add_extension_with_ambient_transaction_warning_suppressed()
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer("Database=Crunchie").SuppressAmbientTransactionWarning();
var extension = optionsBuilder.Options.Extensions.OfType<SqlServerOptionsExtension>().Single();
Assert.Equal(false, extension.ThrowOnAmbientTransaction);
}
public void Can_be_auto_configured()
{
var optionsBuilder = new EntityOptionsBuilder();
var dataStoreSource = new InMemoryDataStoreSource();
dataStoreSource.AutoConfigure(optionsBuilder);
Assert.True(dataStoreSource.IsConfigured(optionsBuilder.Options));
}
private static EntityOptions CreateOptions(Action <EntityFrameworkServicesBuilder> builderAction)
{
var optionsBuilder = new EntityOptionsBuilder();
((IOptionsBuilderExtender)optionsBuilder).AddOrUpdateExtension(new FakeEntityOptionsExtension {
BuilderAction = builderAction
});
return(optionsBuilder.Options);
}
protected override void OnConfiguring(EntityOptionsBuilder optionsBuilder)
{
// TODO GitHubIssue#57: Complete EF7 to EDM model mapping
// Seems for now EF7 can't support named connection string like "name=NorthwindConnection",
// find an equivalent approach when it's ready.
optionsBuilder.UseSqlServer(@"data source=(LocalDB)\v11.0;attachdbfilename=|DataDirectory|\Northwind.mdf;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework");
base.OnConfiguring(optionsBuilder);
}
public void Can_add_extension_using_persist_true()
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseInMemoryStore(persist: true);
var extension = (InMemoryOptionsExtension)optionsBuilder.Options.Extensions.Single();
Assert.True(extension.Persist);
}
public void Can_add_extension_with_command_timeout()
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer("Database=Crunchie").CommandTimeout(30);
var extension = optionsBuilder.Options.Extensions.OfType<SqlServerOptionsExtension>().Single();
Assert.Equal(30, extension.CommandTimeout);
}
public void Can_not_be_auto_configured()
{
var optionsBuilder = new EntityOptionsBuilder();
var dataStoreSource = new SqlServerDataStoreSource();
dataStoreSource.AutoConfigure(optionsBuilder);
Assert.False(dataStoreSource.IsConfigured(optionsBuilder.Options));
}
public void Can_not_be_auto_configured()
{
var optionsBuilder = new EntityOptionsBuilder();
var dataStoreSource = new SqlServerDataStoreSource();
dataStoreSource.AutoConfigure(optionsBuilder);
Assert.False(dataStoreSource.IsConfigured(optionsBuilder.Options));
}
protected override void OnConfiguring(EntityOptionsBuilder optionsBuilder)
{
//var connString = Startup.Configuration["Data:ClaimContextConnection"];
//var connString = "Server=(localdb)\\ProjectsV12;Database=ClaimDB;Trusted_Connection=;MultipleActiveResultSets=true;";
var connString = "Server=(localdb)\\v11.0;Database=ClaimDB2;Trusted_Connection=true;MultipleActiveResultSets=true;";
optionsBuilder.UseSqlServer(connString);
base.OnConfiguring(optionsBuilder);
}
public void Can_add_extension_with_connection_string()
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer("Database=Crunchie");
var extension = optionsBuilder.Options.Extensions.OfType<SqlServerOptionsExtension>().Single();
Assert.Equal("Database=Crunchie", extension.ConnectionString);
Assert.Null(extension.Connection);
}
public InMemoryGraphUpdatesTestStore(IServiceProvider serviceProvider)
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseInMemoryStore(persist: true);
Context = new GraphUpdatesContext(serviceProvider, optionsBuilder.Options);
Context.Database.EnsureCreated();
}
public void IsConfigured_returns_true_if_any_extensions_have_been_added()
{
var optionsBuilder = new EntityOptionsBuilder();
Assert.False(optionsBuilder.IsConfigured);
((IOptionsBuilderExtender)optionsBuilder).AddOrUpdateExtension(new FakeEntityOptionsExtension2());
Assert.True(optionsBuilder.IsConfigured);
}
public void Can_add_extension_using_persist_true()
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseInMemoryStore(persist: true);
var extension = (InMemoryOptionsExtension)optionsBuilder.Options.Extensions.Single();
Assert.True(extension.Persist);
}
public void Can_add_extension_with_connection_string_using_generic_options()
{
var optionsBuilder = new EntityOptionsBuilder<DbContext>();
optionsBuilder.UseSqlServer("Database=Whisper");
var extension = optionsBuilder.Options.Extensions.OfType<SqlServerOptionsExtension>().Single();
Assert.Equal("Database=Whisper", extension.ConnectionString);
Assert.Null(extension.Connection);
}
public virtual ISqlServerConnection CreateMasterConnection()
{
var builder = new SqlConnectionStringBuilder { ConnectionString = ConnectionString, InitialCatalog = "master" };
// TODO use clone connection method once implimented see #1406
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(builder.ConnectionString).CommandTimeout(CommandTimeout);
return new SqlServerConnection(optionsBuilder.Options, _loggerFactory);
}
protected override void OnConfiguring(EntityOptionsBuilder optionsBuilder)
{
// Visual Studio 2015 | Use the LocalDb 12 instance created by Visual Studio
optionsBuilder.UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=EFGetStarted.ConsoleApp;Trusted_Connection=True;");
// Visual Studio 2013 | Use the LocalDb 11 instance created by Visual Studio
// optionsBuilder.UseSqlServer(@"Server=(localdb)\v11.0;Database=EFGetStarted.ConsoleApp;Trusted_Connection=True;");
// Visual Studio 2012 | Use the SQL Express instance created by Visual Studio
// optionsBuilder.UseSqlServer(@"Server=.\SQLEXPRESS;Database=EFGetStarted.ConsoleApp;Trusted_Connection=True;");
}
public void Music_store_project_to_mapped_entity()
{
var serviceProvider
= new ServiceCollection()
.AddEntityFramework()
.AddInMemoryStore()
.ServiceCollection()
.BuildServiceProvider();
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseInMemoryStore(persist: true);
using (var db = new MusicStoreContext(serviceProvider, optionsBuilder.Options))
{
var albums = GetAlbums("~/Images/placeholder.png", Genres, Artists);
db.Genres.AddRange(Genres.Values);
db.Artists.AddRange(Artists.Values);
db.Albums.AddRange(albums);
db.SaveChanges();
}
using (var db = new MusicStoreContext(serviceProvider, optionsBuilder.Options))
{
var q = from album in db.Albums
join genre in db.Genres on album.GenreId equals genre.GenreId
join artist in db.Artists on album.ArtistId equals artist.ArtistId
select new Album
{
ArtistId = album.ArtistId,
AlbumArtUrl = album.AlbumArtUrl,
AlbumId = album.AlbumId,
GenreId = album.GenreId,
Price = album.Price,
Title = album.Title,
Artist = new Artist
{
ArtistId = album.ArtistId,
Name = artist.Name
},
Genre = new Genre
{
GenreId = album.GenreId,
Name = genre.Name
}
};
var albums = q.ToList();
Assert.Equal(462, albums.Count);
}
}
public void SqlServerOptionsExtension_is_optional()
{
var factory = new SqlServerModificationCommandBatchFactory(new SqlServerSqlGenerator());
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer("Database=Crunchie");
var batch = factory.Create(optionsBuilder.Options, new SqlServerMetadataExtensionProvider());
Assert.True(factory.AddCommand(batch, new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.SqlServer(), new UntypedValueBufferFactoryFactory())));
Assert.True(factory.AddCommand(batch, new ModificationCommand("T1", null, new ParameterNameGenerator(), p => p.SqlServer(), new UntypedValueBufferFactoryFactory())));
}
public void Can_add_extension_with_connection_using_generic_options()
{
var optionsBuilder = new EntityOptionsBuilder<DbContext>();
var connection = new SqlConnection();
optionsBuilder.UseSqlServer(connection);
var extension = optionsBuilder.Options.Extensions.OfType<SqlServerOptionsExtension>().Single();
Assert.Same(connection, extension.Connection);
Assert.Null(extension.ConnectionString);
}
public void Can_add_extension_with_connection()
{
var optionsBuilder = new EntityOptionsBuilder();
var connection = new SqliteConnection();
optionsBuilder.UseSqlite(connection);
var extension = optionsBuilder.Options.Extensions.OfType<SqliteOptionsExtension>().Single();
Assert.Same(connection, extension.Connection);
Assert.Null(extension.ConnectionString);
}
public async Task Can_query_with_implicit_services_and_explicit_config()
{
using (await SqlServerNorthwindContext.GetSharedStoreAsync())
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(SqlServerNorthwindContext.ConnectionString);
using (var context = new NorthwindContext(optionsBuilder.Options))
{
Assert.Equal(91, await context.Customers.CountAsync());
}
}
}
private void EnsureDeleted()
{
if (!PlatformHelper.IsMono)
{
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(_connectionString);
using (var db = new DbContext(optionsBuilder.Options))
{
db.Database.EnsureDeleted();
}
}
}
