private static void PerformanceCacheDbTest(SelectTestDefinition[] testDefinitions, int testCount)
{
var pool = new DbContextPool <OrderContext>(OrderContextOptions.Create(true, null));
Db.OeEntitySetAdapterCollection entitySetAdapters = new OrderDbDataAdapter(false, false, null).EntitySetAdapters;
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
var stopWatch = new Stopwatch();
stopWatch.Start();
for (int i = 0; i < testCount; i++)
{
foreach (SelectTestDefinition testDefinition in testDefinitions)
{
OrderContext dbContext = pool.Rent();
testDefinition.ExecutorDb(entitySetAdapters, dbContext);
pool.Return(dbContext);
}
}
stopWatch.Stop();
Console.WriteLine("Entity Framework " + stopWatch.Elapsed);
}
public async virtual Task Execute <T, TResult>(QueryParameters <T, TResult> parameters)
{
IList fromOe;
try
{
fromOe = await ExecuteOe <T, TResult>(parameters.Expression, parameters.PageSize);
}
catch (NotSupportedException e)
{
if (parameters.RequestUri.Contains("$apply="))
{
throw;
}
fromOe = await ExecuteOeViaHttpClient(parameters, null);
TestWriteException(e, ConsoleColor.Green);
}
IReadOnlyList <EfInclude> includes;
IList fromDb;
using (var dataContext = new OrderContext(OrderContextOptions.Create(true)))
fromDb = TestHelper.ExecuteDb(DataAdapter, dataContext, parameters.Expression, out includes);
TestHelper.Compare(fromDb, fromOe, includes);
}
private static void PerformanceCacheOeTest(SelectTestDefinition[] testDefinitions, int testCount, bool allowCache)
{
var dataAdapter = new OeEfCoreDataAdapter <OrderContext>(OrderContextOptions.Create(true), new Cache.OeQueryCache(allowCache));
IEdmModel edmModel = dataAdapter.BuildEdmModel();
var parser = new OeParser(new Uri("http://dummy"), edmModel);
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
var stopWatch = new Stopwatch();
stopWatch.Start();
for (int i = 0; i < testCount; i++)
{
foreach (SelectTestDefinition testDefinition in testDefinitions)
{
var uri = new Uri("http://dummy/" + testDefinition.Request);
using (var response = new MemoryStream())
parser.ExecuteGetAsync(uri, OeRequestHeaders.JsonDefault, response, CancellationToken.None).GetAwaiter().GetResult();
}
}
stopWatch.Stop();
Console.WriteLine("OdataToEntity cache = " + allowCache + " " + stopWatch.Elapsed);
}
public async virtual Task Execute <T, TResult>(QueryParametersScalar <T, TResult> parameters)
{
IList fromOe = await ExecuteOe <T, TResult>(parameters.Expression, 0);
IList fromDb;
using (var dataContext = new OrderContext(OrderContextOptions.Create(true, null)))
fromDb = TestHelper.ExecuteDb(DataAdapter.EntitySetAdapters, dataContext, parameters.Expression);
TestHelper.Compare(fromDb, fromOe, DataAdapter.EntitySetAdapters.EdmModelMetadataProvider, null);
}
public async override Task Initalize()
{
if (_initialized)
{
return;
}
_initialized = true;
using (var dbContext = new OrderContext(OrderContextOptions.Create(false)))
await dbContext.Database.ExecuteSqlRawAsync("dbo.InitializeManyColumns");
}
public DbFixtureInitDb(bool clear = false)
{
_clear = clear;
DataAdapter = new EfCore.OeEfCoreDataAdapter <OrderContext>(OrderContextOptions.Create(true));
var dbContext = (DbContext)DataAdapter.CreateDataContext();
MetadataProvider = new EfCore.OeEfCoreEdmModelMetadataProvider(dbContext.Model);
DataAdapter.CloseDataContext(dbContext);
var modelBuilder = new ModelBuilder.OeEdmModelBuilder(DataAdapter, MetadataProvider);
EdmModel = modelBuilder.BuildEdmModel();
}
public override OrderContext CreateContext()
{
Db.OeDataAdapter dataAdapter = OeEdmModel.GetDataAdapter(OeEdmModel.EntityContainer);
var dbContext = (DbContext)dataAdapter.CreateDataContext();
try
{
DbContextOptions options = OrderContextOptions.CreateOptions <OrderContext>(dbContext);
return(new OrderContext(options));
}
finally
{
dataAdapter.CloseDataContext(dbContext);
}
}
protected DbFixture(IEdmModel edmModel, ModelBoundTestKind modelBoundTestKind, bool useRelationalNulls)
{
OeEdmModel = edmModel;
if (modelBoundTestKind == ModelBoundTestKind.Attribute)
{
ModelBoundProvider = new Query.Builder.OeModelBoundAttributeBuilder(edmModel).BuildProvider();
}
else if (modelBoundTestKind == ModelBoundTestKind.Fluent)
{
ModelBoundProvider = CreateModelBoundProvider(edmModel);
}
DbEdmModel = OrderContextOptions.BuildDbEdmModel(OeEdmModel, useRelationalNulls);
}
public async Task CountQueryParameter()
{
int expectedCount;
using (var dbContext = new OrderContext(OrderContextOptions.Create(true)))
expectedCount = dbContext.Orders.Count();
String request = "Orders?&$count=true&$top=1";
var queryParameters = new QueryParameters <Order>()
{
RequestUri = request
};
IList fromOe = await Fixture.ExecuteOeViaHttpClient(queryParameters, expectedCount);
Assert.Equal(1, fromOe.Count);
}
public async Task BoundFunctionCollection()
{
List <int> expectedResult;
using (var dbContext = new OrderContext(OrderContextOptions.Create(true)))
expectedResult = dbContext.OrderItems.Where(i => i.Order.Name == "Order 1" || i.Order.Name == "Order 2").Select(i => i.Id).ToList();
String request = $"Customers/BoundFunctionCollection(orderNames=['Order 1','Order 2'])?$expand=Customer,Items&$select=Name";
var queryParameters = new QueryParameters <Customer, Order>()
{
RequestUri = request
};
IList fromOe = await Fixture.ExecuteOeViaHttpClient(queryParameters, null);
Assert.Equal(expectedResult, fromOe.Cast <Order>().SelectMany(c => c.Items).Select(i => i.Id).OrderBy(id => id));
}
public async Task BoundFunctionCollection()
{
List <int> expectedResult;
using (var dbContext = new OrderContext(OrderContextOptions.Create(true, null)))
expectedResult = dbContext.OrderItems.Where(i =>
i.Order.Customer.Name == "Natasha" ||
i.Order.Customer.Name == "Ivan" ||
i.Order.Customer.Name == "Sasha").Select(i => i.Id).ToList();
String request = "Orders/OdataToEntity.Test.Model.BoundFunctionCollection(customerNames=['Natasha','Ivan','Sasha'])";
var queryParameters = new QueryParameters <Order, OrderItem>()
{
RequestUri = request
};
IList fromOe = await Fixture.ExecuteOeViaHttpClient(queryParameters);
Assert.Equal(expectedResult, fromOe.Cast <OrderItem>().Select(i => i.Id).OrderBy(id => id));
}
public async virtual Task Execute <T, TResult>(QueryParameters <T, TResult> parameters)
{
IList fromOe = await ExecuteOe <T, TResult>(parameters.Expression, parameters.PageSize);
List <IncludeVisitor.Include> includes = GetIncludes(parameters.Expression);
if (typeof(TResult) == typeof(Object))
{
fromOe = TestHelper.ToOpenType(fromOe);
}
IList fromDb;
using (var dataContext = new OrderContext(OrderContextOptions.Create(true, null)))
{
fromDb = TestHelper.ExecuteDb(_entitySetAdapters, dataContext, parameters.Expression, out IReadOnlyList <IncludeVisitor.Include> includesDb);
includes.AddRange(includesDb);
}
TestHelper.Compare(fromDb, fromOe, includes);
}
public async virtual Task Execute <T, TResult>(QueryParameters <T, TResult> parameters)
{
IList fromOe;
try
{
fromOe = await ExecuteOe <T, TResult>(parameters.Expression, parameters.PageSize);
}
catch (NotSupportedException e)
{
if (parameters.RequestUri.Contains("$apply="))
{
throw;
}
if (parameters.RequestUri.Contains("$compute=") && (parameters.RequestUri.Contains("ceiling(") || parameters.RequestUri.Contains("hour(")))
{
throw new NotSupportedException("$compute and function not suported");
}
if (parameters.RequestUri.EndsWith("$expand=Items/$count") ||
parameters.RequestUri.EndsWith("$expand=Customer,Items/$count,AltCustomer"))
{
throw new NotSupportedException("$count in $expand not supported");
}
fromOe = await ExecuteOeViaHttpClient(parameters, null);
TestWriteException(e, ConsoleColor.Green);
}
IReadOnlyList <EfInclude> includes;
IList fromDb;
using (var dataContext = new OrderContext(OrderContextOptions.Create(true)))
fromDb = TestHelper.ExecuteDb(DataAdapter, dataContext, parameters.Expression, out includes);
TestHelper.Compare(fromDb, fromOe, includes);
}
public async virtual Task Execute <T, TResult>(QueryParameters <T, TResult> parameters)
{
IList fromOe;
try
{
fromOe = await ExecuteOe <T, TResult>(parameters.Expression, parameters.PageSize);
}
catch (NotSupportedException e)
{
if (parameters.RequestUri.Contains("$apply="))
{
throw;
}
fromOe = await ExecuteOeViaHttpClient(parameters);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(e.Message);
Console.ResetColor();
}
List <IncludeVisitor.Include> includes = GetIncludes(DataAdapter, parameters.Expression);
if (typeof(TResult) == typeof(Object))
{
fromOe = TestHelper.ToOpenType(fromOe);
}
IList fromDb;
using (var dataContext = new OrderContext(OrderContextOptions.Create(true, null)))
{
fromDb = TestHelper.ExecuteDb(DataAdapter, dataContext, parameters.Expression, out IReadOnlyList <IncludeVisitor.Include> includesDb);
includes.AddRange(includesDb);
}
TestHelper.Compare(fromDb, fromOe, DataAdapter.EntitySetAdapters.EdmModelMetadataProvider, includes);
}
public void FluentApi()
{
var ethalonDataAdapter = new OeEfCoreDataAdapter <OrderContext>(OrderContextOptions.Create(true));
EdmModel ethalonEdmModel = ethalonDataAdapter.BuildEdmModel();
String ethalonSchema = TestHelper.GetCsdlSchema(ethalonEdmModel);
if (ethalonSchema == null)
{
throw new InvalidOperationException("Invalid ethalon schema");
}
var testDataAdapter = new OrderDataAdapter(false, false);
EdmModel testEdmModel = testDataAdapter.BuildEdmModelFromEf6Model();
String testSchema = TestHelper.GetCsdlSchema(testEdmModel);
if (testSchema == null)
{
throw new InvalidOperationException("Invalid test schema");
}
String fixTestSchema = FixNamesInSchema(testSchema);
Assert.Equal(ethalonSchema, fixTestSchema);
}
private DbFixture(bool useRelationalNulls, String databaseName, Db.OeDataAdapter dataAdapter, ModelBuilder.OeEdmModelMetadataProvider metadataProvider)
: this(useRelationalNulls, databaseName, OrderContextOptions.BuildEdmModel(dataAdapter, metadataProvider), metadataProvider)
{
}
public OrderContext CreateContext()
{
return(new OrderContext(OrderContextOptions.Create(_useRelationalNulls, _databaseName)));
}
public OrderDataAdapter() :
base(OrderContextOptions.Create(OrderContext.GenerateDatabaseName()), new Cache.OeQueryCache(false))
{
}
public override OrderContext CreateContext()
{
return(new OrderContext(OrderContextOptions.Create(_useRelationalNulls)));;
}
