public BatchingTest()
{
_testStore = SqlServerTestStore.CreateScratch();
_serviceProvider = new ServiceCollection()
.AddEntityFramework()
.AddSqlServer()
.ServiceCollection()
.BuildServiceProvider();
}
private static BloggingContext CreateContext(SqlServerTestStore testStore)
{
var serviceProvider =
new ServiceCollection()
.AddEntityFrameworkSqlServer()
.BuildServiceProvider();
var optionsBuilder = new DbContextOptionsBuilder()
.UseSqlServer(testStore.ConnectionString)
.UseInternalServiceProvider(serviceProvider);
return new BloggingContext(optionsBuilder.Options);
}
private static BloggingContext CreateContext(SqlServerTestStore testStore)
{
var serviceProvider =
new ServiceCollection()
.AddEntityFramework()
.AddSqlServer()
.ServiceCollection()
.BuildServiceProvider();
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(testStore.Connection.ConnectionString);
return new BloggingContext(serviceProvider, optionsBuilder.Options);
}
public MappingQuerySqlServerFixture()
{
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkSqlServer()
.AddSingleton<ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider();
_testDatabase = SqlServerNorthwindContext.GetSharedStore();
_options = new DbContextOptionsBuilder()
.UseModel(CreateModel())
.UseSqlServer(_testDatabase.ConnectionString)
.UseInternalServiceProvider(serviceProvider)
.Options;
}
public MappingQuerySqlServerFixture()
{
_serviceProvider = new ServiceCollection()
.AddEntityFramework()
.AddSqlServer()
.ServiceCollection()
.AddInstance<ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider();
_testDatabase = SqlServerNorthwindContext.GetSharedStore();
var optionsBuilder = new DbContextOptionsBuilder().UseModel(CreateModel());
optionsBuilder.UseSqlServer(_testDatabase.Connection.ConnectionString);
_options = optionsBuilder.Options;
}
public NorthwindSprocQuerySqlServerFixture()
{
_testStore = SqlServerNorthwindContext.GetSharedStore();
_serviceProvider = new ServiceCollection()
.AddEntityFramework()
.AddSqlServer()
.ServiceCollection()
.AddSingleton(TestSqlServerModelSource.GetFactory(OnModelCreating))
.AddInstance<ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider();
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(_testStore.Connection.ConnectionString);
_options = optionsBuilder.Options;
_serviceProvider.GetRequiredService<ILoggerFactory>()
.MinimumLevel = LogLevel.Debug;
}
public OneToOneQuerySqlServerFixture()
{
_testStore = SqlServerTestStore.CreateScratch();
_options = new DbContextOptionsBuilder()
.UseSqlServer(_testStore.ConnectionString)
.UseInternalServiceProvider(new ServiceCollection()
.AddEntityFrameworkSqlServer()
.AddSingleton(TestSqlServerModelSource.GetFactory(OnModelCreating))
.AddSingleton<ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider())
.Options;
using (var context = new DbContext(_options))
{
context.Database.EnsureCreated();
AddTestData(context);
}
}
public BuiltInDataTypesSqlServerFixture()
{
_testStore = SqlServerTestStore.CreateScratch();
_serviceProvider = new ServiceCollection()
.AddEntityFramework()
.AddSqlServer()
.ServiceCollection()
.AddSingleton(TestSqlServerModelSource.GetFactory(OnModelCreating))
.BuildServiceProvider();
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(_testStore.Connection);
_options = optionsBuilder.Options;
using (var context = new DbContext(_serviceProvider, _options))
{
context.Database.EnsureCreated();
}
}
public InheritanceSqlServerFixture()
{
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkSqlServer()
.AddSingleton(TestSqlServerModelSource.GetFactory(OnModelCreating))
.AddSingleton<ILoggerFactory>(new TestSqlLoggerFactory())
.BuildServiceProvider();
_testStore = SqlServerTestStore.CreateScratch();
_options = new DbContextOptionsBuilder()
.EnableSensitiveDataLogging()
.UseSqlServer(_testStore.Connection)
.UseInternalServiceProvider(serviceProvider)
.Options;
using (var context = CreateContext())
{
context.Database.EnsureCreated();
SeedData(context);
}
}
public async System.Threading.Tasks.Task Stream_Generate_For_DML()
{
using (var testDatabase = SqlServerTestStore.Create(DatabaseName))
{
var loggingFactory = new TestSqlLoggerFactory();
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkSqlServer()
.AddSingleton <ILoggerFactory>(loggingFactory)
.BuildServiceProvider();
var optionsBuilder = new DbContextOptionsBuilder()
.EnableSensitiveDataLogging()
.UseSqlServer(testDatabase.ConnectionString, b => b.ApplyConfiguration())
.UseInternalServiceProvider(serviceProvider);
using (var db = new BloggingContext(optionsBuilder.Options))
{
await CreateBlogDatabaseAsync <Blog>(db);
}
loggingFactory.Clear();
using (var db = new BloggingContext(optionsBuilder.Options))
{
var toUpdate = db.Blogs.Single(b => b.Name == "Blog1");
toUpdate.Name = "Blog is Updated";
var updatedId = toUpdate.Id;
var toDelete = db.Blogs.Single(b => b.Name == "Blog2");
toDelete.Name = "Blog to delete";
var deletedId = toDelete.Id;
db.Entry(toUpdate).State = EntityState.Modified;
db.Entry(toDelete).State = EntityState.Deleted;
var toAdd = db.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;
var statement = "";
using (var stream = new MemoryStream())
{
db.Generate(stream);
stream.Seek(0, SeekOrigin.Begin);
var streamReader = new StreamReader(stream);
statement = await streamReader.ReadToEndAsync();
Assert.IsTrue(!string.IsNullOrEmpty(statement));
}
var reader = new StringReader(statement);
IList <ParseError> errors;
var parser = new TSql140Parser(false);
var parseResult = parser.Parse(reader, out errors);
Assert.IsFalse(errors.Any());
//var expectedStatement = "EXECUTE sp_executesql N'INSERT INTO Blog ([AndChew], [Away], [Fuse], [George], [Name], [NotFigTime], [OrNothing], [TheGu], [ToEat], [WayRound]) VALUES (@p0,@p1,@p2,@p3,@p4,@p5,@p6,@p7,@p8,@p9)', N'@p0 varbinary(max),@p1 real,@p2 smallint,@p3 bit,@p4 nvarchar(max),@p5 datetime2,@p6 float,@p7 uniqueidentifier,@p8 tinyint,@p9 bigint', @p0 = 0x00000000000000000000000000000000,@p1 = 0.12345,@p2 = 777,@p3 = True,@p4 = 'Blog to Insert',@p5 = '9/3/1973 12:10:33 AM',@p6 = 0.123456789,@p7 = '0456aef1-b7fc-47aa-8102-975d6ba3a9bf',@p8 = 64,@p9 = 9876543210";
//Assert.AreEqual(expectedStatement, statement);
}
}
}
public async System.Threading.Tasks.Task Stream_Generate_Insert_For_Multiple_Entities()
{
using (var testDatabase = SqlServerTestStore.Create(DatabaseName))
{
var loggingFactory = new TestSqlLoggerFactory();
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkSqlServer()
.AddSingleton <ILoggerFactory>(loggingFactory)
.BuildServiceProvider();
var optionsBuilder = new DbContextOptionsBuilder()
.EnableSensitiveDataLogging()
.UseSqlServer(testDatabase.ConnectionString, b => b.ApplyConfiguration())
.UseInternalServiceProvider(serviceProvider);
using (var db = new BloggingContext(optionsBuilder.Options))
{
await CreateBlogDatabaseAsync <Blog>(db);
}
loggingFactory.Clear();
using (var db = new BloggingContext(optionsBuilder.Options))
{
var toAdd = db.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;
var recordTwo = db.Add(new Blog
{
Name = "Another Blog to Insert",
George = true,
TheGu = new Guid("0456AEF1-B7FC-47AA-8102-975D6BA3A9BE"),
NotFigTime = new DateTime(1974, 9, 3, 0, 10, 33, 777),
ToEat = 65,
OrNothing = 0.123456789,
Fuse = 777,
WayRound = 9876543210,
Away = 0.12345f,
AndChew = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
}).Entity;
var statement = "";
using (var stream = new MemoryStream())
{
db.Generate(stream);
stream.Seek(0, SeekOrigin.Begin);
var streamReader = new StreamReader(stream);
statement = await streamReader.ReadToEndAsync();
Assert.IsTrue(!string.IsNullOrEmpty(statement));
}
var reader = new StringReader(statement);
IList <ParseError> errors;
var parser = new TSql140Parser(false);
var parseResult = parser.Parse(reader, out errors);
Assert.IsFalse(errors.Any());
}
}
}
private static IServiceProvider CreateContextServices(SqlServerTestStore testStore)
{
var serviceCollection = new ServiceCollection();
serviceCollection
.AddEntityFramework()
.AddSqlServer();
var optionsBuilder = new EntityOptionsBuilder();
optionsBuilder.UseSqlServer(testStore.Connection.ConnectionString);
return ((IAccessor<IServiceProvider>)new DbContext(
serviceCollection.BuildServiceProvider(),
optionsBuilder.Options))
.Service;
}
public E2EFixture()
{
SqlServerTestStore.CreateDatabase(
"SqlServerReverseEngineerTestE2E", @"ReverseEngineering\E2E.sql", true);
}
public SqlServerDatabaseModelFixture()
{
TestStore = SqlServerTestStore.CreateScratch();
}
private static IServiceProvider CreateContextServices(SqlServerTestStore testStore)
{
var serviceCollection = new ServiceCollection();
serviceCollection
.AddEntityFramework()
.AddSqlServer();
serviceCollection.AddScoped<SqlServerDatabaseCreator, TestDatabaseCreator>();
var optionsBuilder = new DbContextOptionsBuilder();
optionsBuilder.UseSqlServer(testStore.Connection.ConnectionString);
return ((IInfrastructure<IServiceProvider>)new BloggingContext(
serviceCollection.BuildServiceProvider(),
optionsBuilder.Options))
.Instance;
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) => optionsBuilder .UseInternalServiceProvider(_serviceProvider) .UseSqlServer(SqlServerTestStore.CreateConnectionString(_databaseName), b => b.ApplyConfiguration());
public BusinessCriticalContext(SqlServerTestStore testStore)
: base()
{
_connectionString = testStore.ConnectionString;
}
public void Insert_and_update_with_computed_column_with_querying_function()
{
using var testStore = SqlServerTestStore.CreateInitialized(DatabaseName);
using (var context = new BlogContextComputedColumn(testStore.Name))
{
context.GetService <IRelationalDatabaseCreator>().CreateTables();
context.Database.ExecuteSqlRaw("ALTER TABLE dbo.FullNameBlogs DROP COLUMN FullName;");
context.Database.ExecuteSqlRaw(
@"CREATE FUNCTION [dbo].[GetFullName](@Id int)
RETURNS nvarchar(max) WITH SCHEMABINDING AS
BEGIN
DECLARE @FullName nvarchar(max);
SELECT @FullName = [FirstName] + [LastName] FROM [dbo].[FullNameBlogs] WHERE [Id] = @Id;
RETURN @FullName
END");
context.Database.ExecuteSqlRaw("ALTER TABLE dbo.FullNameBlogs ADD FullName AS [dbo].[GetFullName]([Id]); ");
}
try
{
using (var context = new BlogContextComputedColumn(testStore.Name))
{
var blog = context.Add(
new FullNameBlog {
FirstName = "One", LastName = "Unicorn"
}).Entity;
context.SaveChanges();
Assert.Equal("OneUnicorn", blog.FullName);
}
using (var context = new BlogContextComputedColumn(testStore.Name))
{
var blog = context.FullNameBlogs.Single();
Assert.Equal("OneUnicorn", blog.FullName);
blog.LastName = "Pegasus";
context.SaveChanges();
Assert.Equal("OnePegasus", blog.FullName);
}
using (var context = new BlogContextComputedColumn(testStore.Name))
{
var blog1 = context.Add(
new FullNameBlog {
FirstName = "Hank", LastName = "Unicorn"
}).Entity;
var blog2 = context.Add(
new FullNameBlog {
FirstName = "Jeff", LastName = "Unicorn"
}).Entity;
context.SaveChanges();
Assert.Equal("HankUnicorn", blog1.FullName);
Assert.Equal("JeffUnicorn", blog2.FullName);
}
}
finally
{
using var context = new BlogContextComputedColumn(testStore.Name);
context.Database.ExecuteSqlRaw("ALTER TABLE dbo.FullNameBlogs DROP COLUMN FullName;");
context.Database.ExecuteSqlRaw("DROP FUNCTION [dbo].[GetFullName];");
}
}
public void Can_create_database_with_alias_columns()
{
using var testDatabase = SqlServerTestStore.CreateInitialized(DatabaseName);
var options = Fixture.CreateOptions(testDatabase);
using (var context = new TypeAliasContext(options))
{
context.Database.ExecuteSqlRaw(
@"
CREATE TYPE datetimeAlias FROM datetime2(6);
CREATE TYPE datetimeoffsetAlias FROM datetimeoffset(6);
CREATE TYPE decimalAlias FROM decimal(10, 6);
CREATE TYPE doubleAlias FROM float(26);
CREATE TYPE floatAlias FROM real;
CREATE TYPE binaryAlias FROM varbinary(50);
CREATE TYPE stringAlias FROM nvarchar(50);");
var model = context.Model;
var aliasEntityType = model.FindEntityType(typeof(TypeAliasEntity));
Assert.Equal("datetimeAlias", GetColumnType(aliasEntityType !, nameof(TypeAliasEntity.DateTimeAlias)));
Assert.Equal("datetimeoffsetAlias", GetColumnType(aliasEntityType !, nameof(TypeAliasEntity.DateTimeOffsetAlias)));
Assert.Equal("decimalAlias", GetColumnType(aliasEntityType !, nameof(TypeAliasEntity.DecimalAlias)));
Assert.Equal("doubleAlias", GetColumnType(aliasEntityType !, nameof(TypeAliasEntity.DoubleAlias)));
Assert.Equal("floatAlias", GetColumnType(aliasEntityType !, nameof(TypeAliasEntity.FloatAlias)));
Assert.Equal("binaryAlias", GetColumnType(aliasEntityType !, nameof(TypeAliasEntity.BinaryAlias)));
Assert.Equal("stringAlias", GetColumnType(aliasEntityType !, nameof(TypeAliasEntity.StringAlias)));
var facetedAliasEntityType = model.FindEntityType(typeof(TypeAliasEntityWithFacets));
Assert.Equal("datetimeAlias", GetColumnType(facetedAliasEntityType !, nameof(TypeAliasEntityWithFacets.DateTimeAlias)));
Assert.Equal(
"datetimeoffsetAlias", GetColumnType(facetedAliasEntityType !, nameof(TypeAliasEntityWithFacets.DateTimeOffsetAlias)));
Assert.Equal("decimalAlias", GetColumnType(facetedAliasEntityType !, nameof(TypeAliasEntityWithFacets.DecimalAlias)));
Assert.Equal("doubleAlias", GetColumnType(facetedAliasEntityType !, nameof(TypeAliasEntityWithFacets.DoubleAlias)));
Assert.Equal("floatAlias", GetColumnType(facetedAliasEntityType !, nameof(TypeAliasEntityWithFacets.FloatAlias)));
Assert.Equal("binaryAlias", GetColumnType(facetedAliasEntityType !, nameof(TypeAliasEntityWithFacets.BinaryAlias)));
Assert.Equal("stringAlias", GetColumnType(facetedAliasEntityType !, nameof(TypeAliasEntityWithFacets.StringAlias)));
context.Database.EnsureCreatedResiliently();
context.AddRange(
new TypeAliasEntity
{
DateTimeAlias = new DateTime(),
DateTimeOffsetAlias = new DateTimeOffset(),
DecimalAlias = 3.14159m,
DoubleAlias = 3.14159,
FloatAlias = 3.14159f,
BinaryAlias = new byte[] { 0, 1, 2, 3 },
StringAlias = "Rodrigo y Gabriela"
},
new TypeAliasEntityWithFacets
{
DateTimeAlias = new DateTime(),
DateTimeOffsetAlias = new DateTimeOffset(),
DecimalAlias = 3.14159m,
DoubleAlias = 3.14159,
FloatAlias = 3.14159f,
BinaryAlias = new byte[] { 0, 1, 2, 3 },
StringAlias = "Mettavolution"
});
context.SaveChanges();
}
using (var context = new TypeAliasContext(options))
{
var entity = context.Set <TypeAliasEntity>().OrderByDescending(e => e.Id).First();
Assert.Equal(new DateTime(), entity.DateTimeAlias);
Assert.Equal(new DateTimeOffset(), entity.DateTimeOffsetAlias);
Assert.Equal(3.14m, entity.DecimalAlias);
Assert.Equal(3.14159, entity.DoubleAlias);
Assert.Equal(3.14159f, entity.FloatAlias);
Assert.Equal(new byte[] { 0, 1, 2, 3 }, entity.BinaryAlias);
Assert.Equal("Rodrigo y Gabriela", entity.StringAlias);
var entityWithFacets = context.Set <TypeAliasEntityWithFacets>().OrderByDescending(e => e.Id).First();
Assert.Equal(new DateTime(), entityWithFacets.DateTimeAlias);
Assert.Equal(new DateTimeOffset(), entityWithFacets.DateTimeOffsetAlias);
Assert.Equal(3.14159m, entityWithFacets.DecimalAlias);
Assert.Equal(3.14159, entityWithFacets.DoubleAlias);
Assert.Equal(3.14159f, entityWithFacets.FloatAlias);
Assert.Equal(new byte[] { 0, 1, 2, 3 }, entityWithFacets.BinaryAlias);
Assert.Equal("Mettavolution", entityWithFacets.StringAlias);
}
string GetColumnType(IEntityType entityType, string propertyName)
=> entityType !.FindProperty(propertyName) !.GetColumnType(new StoreObjectIdentifier());
}
public void Insert_with_non_key_default_value()
{
using var testStore = SqlServerTestStore.CreateInitialized(DatabaseName);
using (var context = new BlogContextNonKeyDefaultValue(testStore.Name))
{
context.Database.EnsureCreatedResiliently();
var blogs = new List <Blog>
{
new() { Name = "One Unicorn" },
new()
{
Name = "Two Unicorns",
CreatedOn = new DateTime(1969, 8, 3, 0, 10, 0),
NeedsConverter = new NeedsConverter(111),
GeometryCollection = GeometryFactory.CreateGeometryCollection(
new Geometry[] { GeometryFactory.CreatePoint(new Coordinate(1, 3)) })
}
};
context.AddRange(blogs);
context.SaveChanges();
Assert.NotEqual(new DateTime(), blogs[0].CreatedOn);
Assert.NotEqual(new DateTime(), blogs[1].CreatedOn);
Assert.Equal(111, blogs[1].NeedsConverter.Value);
var point = ((Point)blogs[1].GeometryCollection.Geometries[0]);
Assert.Equal(1, point.X);
Assert.Equal(3, point.Y);
}
using (var context = new BlogContextNonKeyDefaultValue(testStore.Name))
{
var blogs = context.Blogs.OrderBy(e => e.Name).ToList();
Assert.Equal(3, blogs.Count);
Assert.NotEqual(new DateTime(), blogs[0].CreatedOn);
Assert.Equal(new DateTime(1969, 8, 3, 0, 10, 0), blogs[1].CreatedOn);
Assert.Equal(new DateTime(1974, 8, 3, 0, 10, 0), blogs[2].CreatedOn);
var point1 = ((Point)blogs[1].GeometryCollection.Geometries[0]);
Assert.Equal(1, point1.X);
Assert.Equal(3, point1.Y);
var point2 = ((Point)blogs[2].GeometryCollection.Geometries[0]);
Assert.Equal(1, point2.X);
Assert.Equal(2, point2.Y);
blogs[0].CreatedOn = new DateTime(1973, 9, 3, 0, 10, 0);
blogs[1].Name = "X Unicorns";
blogs[1].NeedsConverter = new NeedsConverter(222);
blogs[1].GeometryCollection.Geometries[0] = GeometryFactory.CreatePoint(new Coordinate(1, 11));
blogs[2].Name = "Y Unicorns";
blogs[2].NeedsConverter = new NeedsConverter(333);
blogs[2].GeometryCollection.Geometries[0] = GeometryFactory.CreatePoint(new Coordinate(1, 22));
context.SaveChanges();
}
using (var context = new BlogContextNonKeyDefaultValue(testStore.Name))
{
var blogs = context.Blogs.OrderBy(e => e.Name).ToList();
Assert.Equal(3, blogs.Count);
Assert.Equal(new DateTime(1973, 9, 3, 0, 10, 0), blogs[0].CreatedOn);
Assert.Equal(new DateTime(1969, 8, 3, 0, 10, 0), blogs[1].CreatedOn);
Assert.Equal(222, blogs[1].NeedsConverter.Value);
Assert.Equal(new DateTime(1974, 8, 3, 0, 10, 0), blogs[2].CreatedOn);
Assert.Equal(333, blogs[2].NeedsConverter.Value);
var point1 = ((Point)blogs[1].GeometryCollection.Geometries[0]);
Assert.Equal(1, point1.X);
Assert.Equal(11, point1.Y);
var point2 = ((Point)blogs[2].GeometryCollection.Geometries[0]);
Assert.Equal(1, point2.X);
Assert.Equal(22, point2.Y);
}
}
public static SqlServerTestStore GetSharedStore()
{
return(SqlServerTestStore.GetOrCreateShared(
DatabaseName,
() => SqlServerTestStore.CreateDatabase(DatabaseName, scriptPath: @"Northwind.sql")));
}
/// <summary>
/// A transactional test database, pre-populated with Northwind schema/data
/// </summary>
public static Task <SqlServerTestStore> GetSharedStoreAsync()
{
return(SqlServerTestStore.GetOrCreateSharedAsync(
DatabaseName,
() => SqlServerTestStore.CreateDatabaseAsync(DatabaseName, scriptPath: @"Northwind.sql")));
}
public BasicContext(SqlServerTestStore testStore)
: base()
{
_connectionString = testStore.ConnectionString;
}
public ScratchDatabaseFixture()
{
_testStore = new Lazy <SqlServerTestStore>(() => SqlServerTestStore.CreateScratch());
}
public ElasticPoolContext(SqlServerTestStore testStore)
: base()
{
_connectionString = testStore.ConnectionString;
}
private static async Task RunDatabaseCreationTest(SqlServerTestStore testStore, bool async)
{
using (var context = new BloggingContext(testStore))
{
var creator = context.GetService<IRelationalDatabaseCreator>();
Assert.Equal(ConnectionState.Closed, context.Database.GetDbConnection().State);
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 = await testStore.QueryAsync<string>("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'");
Assert.Equal(1, tables.Count());
Assert.Equal("Blog", tables.Single());
var columns = (await testStore.QueryAsync<string>(
"SELECT TABLE_NAME + '.' + COLUMN_NAME + ' (' + DATA_TYPE + ')' FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = 'Blog' ORDER BY TABLE_NAME, COLUMN_NAME")).ToArray();
Assert.Equal(19, columns.Length);
Assert.Equal(
new[]
{
"Blog.AndChew (varbinary)",
"Blog.AndRow (timestamp)",
"Blog.Cheese (nvarchar)",
"Blog.CupOfChar (int)",
"Blog.ErMilan (int)",
"Blog.Fuse (smallint)",
"Blog.George (bit)",
"Blog.Key1 (nvarchar)",
"Blog.Key2 (varbinary)",
"Blog.NotFigTime (datetime2)",
"Blog.NotToEat (smallint)",
"Blog.On (real)",
"Blog.OrNothing (float)",
"Blog.OrULong (int)",
"Blog.OrUShort (numeric)",
"Blog.OrUSkint (bigint)",
"Blog.TheGu (uniqueidentifier)",
"Blog.ToEat (tinyint)",
"Blog.WayRound (bigint)"
},
columns);
}
}
/// <summary>
/// A transactional test database, pre-populated with Northwind schema/data
/// </summary>
public static Task <SqlServerTestStore> GetSharedStoreAsync()
{
return(SqlServerTestStore.GetOrCreateSharedAsync(
DatabaseName,
() => SqlServerTestStore.CreateDatabaseIfNotExistsAsync(DatabaseName, scriptPath: @"..\..\Northwind.sql"))); // relative from bin/<config>
}
private static IServiceProvider CreateContextServices(SqlServerTestStore testStore)
=> ((IInfrastructure<IServiceProvider>)new BloggingContext(
new DbContextOptionsBuilder()
.UseSqlServer(testStore.ConnectionString)
.UseInternalServiceProvider(new ServiceCollection()
.AddEntityFrameworkSqlServer()
.AddScoped<SqlServerDatabaseCreator, TestDatabaseCreator>().BuildServiceProvider()).Options))
.Instance;
private static ISqlServerDataStoreCreator GetDataStoreCreator(SqlServerTestStore testStore)
{
return CreateContextServices(testStore).GetRequiredService<ISqlServerDataStoreCreator>();
}
public void Inserts_and_updates_are_batched_correctly()
{
using (var testStore = SqlServerTestStore.Create(DatabaseName))
{
var options = new DbContextOptionsBuilder()
.UseSqlServer(testStore.Connection, b => b.ApplyConfiguration())
.UseInternalServiceProvider(
new ServiceCollection()
.AddEntityFrameworkSqlServer()
.BuildServiceProvider())
.Options;
var expectedBlogs = new List <Blog>();
using (var context = new BloggingContext(options))
{
context.Database.EnsureClean();
var owner1 = new Owner {
Name = "0"
};
var owner2 = new Owner {
Name = "1"
};
context.Owners.Add(owner1);
context.Owners.Add(owner2);
var blog1 = new Blog
{
Id = Guid.NewGuid(),
Owner = owner1,
Order = 1
};
context.Blogs.Add(blog1);
expectedBlogs.Add(blog1);
context.SaveChanges();
owner2.Name = "2";
blog1.Order = 0;
var blog2 = new Blog
{
Id = Guid.NewGuid(),
Owner = owner1,
Order = 1
};
context.Blogs.Add(blog2);
expectedBlogs.Add(blog2);
var blog3 = new Blog
{
Id = Guid.NewGuid(),
Owner = owner2,
Order = 2
};
context.Blogs.Add(blog3);
expectedBlogs.Add(blog3);
context.SaveChanges();
}
AssertDatabaseState(true, expectedBlogs, options);
}
}
public BloggingContext(SqlServerTestStore testStore)
{
_testStore = testStore;
}
public BloggingContext(SqlServerTestStore testStore)
: this(testStore.ConnectionString)
{
}
public SequenceEndToEndTest()
{
TestStore = SqlServerTestStore.CreateInitialized("SequenceEndToEndTest");
}
public override TestStore GetOrCreate(string storeName) => SqlServerTestStore.GetOrCreate(Name, "Northwind.sql", multipleActiveResultSets: true);
public void Sequences()
{
using (var scratch = SqlServerTestStore.CreateScratch())
{
scratch.ExecuteNonQuery(@"
CREATE SEQUENCE CountByTwo
START WITH 1
INCREMENT BY 2;
CREATE SEQUENCE CyclicalCountByThree
START WITH 6
INCREMENT BY 3
MAXVALUE 27
MINVALUE 0
CYCLE;
CREATE SEQUENCE TinyIntSequence
AS tinyint
START WITH 1;
CREATE SEQUENCE SmallIntSequence
AS smallint
START WITH 1;
CREATE SEQUENCE IntSequence
AS int
START WITH 1;
CREATE SEQUENCE DecimalSequence
AS decimal;
CREATE SEQUENCE NumericSequence
AS numeric;");
var configuration = new ReverseEngineeringConfiguration
{
ConnectionString = scratch.Connection.ConnectionString,
ProjectPath = TestProjectDir + Path.DirectorySeparatorChar,
ProjectRootNamespace = TestNamespace,
ContextClassName = "SequenceContext",
};
var expectedFileSet = new FileSet(new FileSystemFileService(),
Path.Combine("ReverseEngineering", "ExpectedResults"),
contents => contents.Replace("{{connectionString}}", scratch.Connection.ConnectionString))
{
Files = new List <string> {
"SequenceContext.expected"
}
};
var filePaths = Generator.GenerateAsync(configuration).GetAwaiter().GetResult();
var actualFileSet = new FileSet(InMemoryFiles, Path.GetFullPath(TestProjectDir))
{
Files = new[] { filePaths.ContextFile }.Concat(filePaths.EntityTypeFiles).Select(Path.GetFileName).ToList()
};
AssertLog(new LoggerMessages
{
Warn =
{
RelationalDesignStrings.BadSequenceType("DecimalSequence", "decimal"),
RelationalDesignStrings.BadSequenceType("NumericSequence", "numeric")
}
});
AssertEqualFileContents(expectedFileSet, actualFileSet);
AssertCompile(actualFileSet);
}
}
public SqlServerE2EFixture()
{
_testStore = SqlServerTestStore.GetOrCreateShared(
"SqlServerReverseEngineerTestE2E",
() => SqlServerTestStore.ExecuteScript("SqlServerReverseEngineerTestE2E", "ReverseEngineering/E2E.sql"));
}
public BloggingContext(SqlServerTestStore testStore)
: base(CreateServiceProvider())
{
_testStore = testStore;
}
public static TestDatabaseCreator GetDatabaseCreator(SqlServerTestStore testStore)
{
return(GetDatabaseCreator(testStore.ConnectionString));
}
private static IRelationalDatabaseCreator GetDatabaseCreator(SqlServerTestStore testStore)
=> CreateContextServices(testStore).GetRequiredService<IRelationalDatabaseCreator>();
public ComputedColumnTest()
{
TestStore = SqlServerTestStore.CreateInitialized("ComputedColumnTest");
}
