public OneToOneQuerySqlCeFixture()
{
_serviceProvider
= new ServiceCollection()
.AddEntityFramework()
.AddSqlCe()
.ServiceCollection()
.AddSingleton(TestSqlCeModelSource.GetFactory(OnModelCreating))
.AddSingleton <ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider();
var database = SqlCeTestStore.CreateScratch(createDatabase: true);
var optionsBuilder = new DbContextOptionsBuilder();
optionsBuilder.UseSqlCe(database.Connection.ConnectionString);
_options = optionsBuilder.Options;
using (var context = new DbContext(_serviceProvider, _options))
{
context.Database.EnsureCreated();
AddTestData(context);
}
}
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());
}
}
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).HasTablesAsync() : ((TestDatabaseCreator)creator).HasTables());
}
}
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).HasTablesAsync() : ((TestDatabaseCreator)creator).HasTables());
}
}
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());
}
}
}
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).HasTablesAsync())).NativeError
: Assert.Throws <SqlCeException>(() => ((TestDatabaseCreator)creator).HasTables()).NativeError;
Assert.Equal(
25046, // The database file cannot be found. Check the path to the database.
errorNumber);
}
}
private static async Task Create_throws_if_database_already_exists_test(bool async)
{
using (var testDatabase = SqlCeTestStore.CreateScratch(createDatabase: true))
{
var creator = GetDatabaseCreator(testDatabase);
var errorNumber =
async
? (await Assert.ThrowsAsync <SqlCeException>(() => creator.CreateAsync())).NativeError
: Assert.Throws <SqlCeException>(() => creator.Create()).NativeError;
Assert.Equal(
25114, // File already exists. Try using a different database name.
errorNumber);
}
}
private static async Task Delete_throws_when_database_doesnt_exist_test(bool async)
{
using (var testDatabase = SqlCeTestStore.CreateScratch(createDatabase: false))
{
var creator = GetDatabaseCreator(testDatabase);
if (async)
{
await Assert.ThrowsAsync <SqlCeException>(() => creator.DeleteAsync());
}
else
{
Assert.Throws <SqlCeException>(() => creator.Delete());
}
}
}
private static async Task CreateTables_creates_schema_in_existing_database_test(bool async)
{
using (var testDatabase = SqlCeTestStore.CreateScratch(createDatabase: true))
{
var serviceCollection = new ServiceCollection();
serviceCollection
.AddEntityFramework()
.AddSqlCe();
var serviceProvider = serviceCollection.BuildServiceProvider();
var optionsBuilder = new DbContextOptionsBuilder();
optionsBuilder.UseSqlCe(testDatabase.Connection.ConnectionString);
using (var context = new BloggingContext(serviceProvider, 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 = testDatabase.Query <string>("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES");
Assert.Equal(1, tables.Count());
Assert.Equal("Blog", tables.Single());
var columns = testDatabase.Query <string>("SELECT TABLE_NAME + '.' + COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS");
Assert.Equal(2, columns.Count());
Assert.True(columns.Any(c => c == "Blog.Id"));
Assert.True(columns.Any(c => c == "Blog.Name"));
}
}
}
public BuiltInDataTypesSqlCeFixture()
{
_testStore = SqlCeTestStore.CreateScratch(createDatabase: true);
_serviceProvider = new ServiceCollection()
.AddEntityFramework()
.AddSqlCe()
.ServiceCollection()
.AddSingleton(TestSqlCeModelSource.GetFactory(OnModelCreating))
.BuildServiceProvider();
var optionsBuilder = new DbContextOptionsBuilder();
optionsBuilder.UseSqlCe(_testStore.Connection);
_options = optionsBuilder.Options;
using (var context = new DbContext(_serviceProvider, _options))
{
context.Database.EnsureCreated();
}
}
private static async Task Delete_will_delete_database_test(bool async)
{
using (var testDatabase = SqlCeTestStore.CreateScratch(createDatabase: 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 InheritanceSqlCeFixture()
{
_serviceProvider
= new ServiceCollection()
.AddEntityFramework()
.AddSqlCe()
.ServiceCollection()
.AddSingleton(TestSqlCeModelSource.GetFactory(OnModelCreating))
.AddSingleton <ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider();
var testStore = SqlCeTestStore.CreateScratch(createDatabase: true);
var optionsBuilder = new DbContextOptionsBuilder();
optionsBuilder
.EnableSensitiveDataLogging()
.UseSqlCe(testStore.Connection);
_options = optionsBuilder.Options;
// TODO: Do this via migrations
testStore.ExecuteNonQuery(@"
CREATE TABLE Country (
Id int NOT NULL PRIMARY KEY,
Name nvarchar(100) NOT NULL
);");
testStore.ExecuteNonQuery(@"
CREATE TABLE Animal (
Species nvarchar(100) NOT NULL PRIMARY KEY,
Name nvarchar(100) NOT NULL,
CountryId int NOT NULL,
IsFlightless bit NOT NULL,
EagleId nvarchar(100),
[Group] int,
FoundOn tinyint,
Discriminator nvarchar(255) NOT NULL
);");
testStore.ExecuteNonQuery(@"
ALTER TABLE [Animal]
ADD CONSTRAINT[EagleId_FK]
FOREIGN KEY ([EagleId])
REFERENCES[Animal]([Species])
ON DELETE NO ACTION ON UPDATE NO ACTION;");
testStore.ExecuteNonQuery(@"
ALTER TABLE [Animal]
ADD CONSTRAINT[CountryId_FK]
FOREIGN KEY ([CountryId])
REFERENCES[Country]([Id])
ON DELETE NO ACTION ON UPDATE NO ACTION;");
testStore.ExecuteNonQuery(@"
CREATE TABLE Plant(
Genus int NOT NULL,
Species nvarchar(100) NOT NULL PRIMARY KEY,
Name nvarchar(100) NOT NULL,
CountryId int NULL,
HasThorns bit
);");
testStore.ExecuteNonQuery(@"
ALTER TABLE [Plant]
ADD CONSTRAINT[PlantCountryId_FK]
FOREIGN KEY ([CountryId])
REFERENCES[Country]([Id])
ON DELETE NO ACTION ON UPDATE NO ACTION;");
using (var context = CreateContext())
{
SeedData(context);
}
}
