public async Task SingleConditions() {
try {
var entityManager = await TestFns.NewEm(_serviceName);
// Customers starting w/ 'A' (string comparison)
var query1 = new EntityQuery<Customer>().Where(c => c.CompanyName.StartsWith("A"))
.OrderBy(c => c.CompanyName);
var customers = await entityManager.ExecuteQuery(query1);
Assert.IsTrue(customers.Any(), "There should be customers whose name begins with A");
// Orders with freight cost over 100.
var query2 = new EntityQuery<Order>().Where(o => o.Freight > 100);
var orders = await entityManager.ExecuteQuery(query2);
Assert.IsTrue(orders.Any(), "There should be orders with freight cost > 100");
// Orders placed on or after 1/1/1998.
var testDate = new DateTime(1998, 1, 3);
var query3 = new EntityQuery<Order>().Where(o => o.OrderDate >= testDate);
orders = await entityManager.ExecuteQuery(query3);
Assert.IsTrue(orders.Any(), "There should be orders placed after 1/1/1998");
// Orders placed on 1/1/1998.
var query4 = new EntityQuery<Order>().Where(o => o.OrderDate == testDate);
orders = await entityManager.ExecuteQuery(query4);
Assert.IsTrue(!orders.Any(), "There should no orders placed on 1/2/1998. There are " + orders.Count());
} catch (Exception e) {
var message = TestFns.FormatException(e);
Assert.Fail(message);
}
}
public async Task Projection() {
try {
var entityManager = await TestFns.NewEm(_serviceName);
// Next line does not work because of MS OData restrictions.
// var productNames = await new EntityQuery<Product>().Select(p => p.ProductName).Execute(entityManager);
var productNames = await new EntityQuery<Product>().Select(p => new { p.ProductName }).Execute(entityManager);
Assert.IsTrue(productNames.Any(), "Projection query should return items");
} catch (Exception e) {
var message = TestFns.FormatException(e);
Assert.Fail(message);
}
}
public async Task AnonymousProjection()
{
try {
var entityManager = await TestFns.NewEm(_serviceName);
// Anonymous projection of single property
// Use anonymous type due to raw property projection not supported by OData
var productNames = await new EntityQuery <Product>().Select(p => new { p.ProductName }).Execute(entityManager);
Assert.IsTrue(productNames.Any(), "Projection query should return items");
// Projection of multiple properties with filter condition and ordering
var query1 = new EntityQuery <Customer>().Where(c => c.CompanyName.StartsWith("C"))
.OrderBy(obj => obj.CompanyName)
.Select(c => new {
CustomerID = c.CustomerID,
CompanyName = c.CompanyName,
ContactName = c.ContactName,
});
var results1 = await entityManager.ExecuteQuery(query1);
Assert.IsTrue(results1.Any(), "Orojection query should produce data");
Assert.IsTrue(results1.Select(obj => obj.CustomerID).OfType <Guid>().Any(), "resulting CustomerIDs should be Guids");
Assert.IsTrue(results1.Select(obj => obj.CompanyName).OfType <string>().Any(), "resulting CompanyNames should be strings");
Assert.IsTrue(results1.Select(obj => obj.ContactName).OfType <string>().Any(), "resulting ContactNames should be strings");
var customersInCache = entityManager.GetEntities <Customer>();
Assert.IsFalse(customersInCache.Any(), "projection query should not have retrieved customers into cache");
// Projection containing a collection
// Note that orders are in cache because they are whole entities
// Customer names are not entities and are not in cache.
var query2 = new EntityQuery <Customer>().Where(c => c.CompanyName.StartsWith("C"))
.OrderBy(obj => obj.CompanyName)
.Select(c => new {
CompanyName = c.CompanyName,
Orders = c.Orders
});
var results2 = await entityManager.ExecuteQuery(query2);
Assert.IsTrue(results2.Any(), "projection query should produce data");
Assert.IsTrue(results2.Select(obj => obj.CompanyName).OfType <string>().Any(), "resulting CompanyNames should be strings");
var ordersInCache = entityManager.GetEntities <Order>();
Assert.IsTrue(ordersInCache.Any(), "projection containing orders should have retrieved orders into cache");
} catch (Exception e) {
var message = TestFns.FormatException(e);
Assert.Fail(message);
}
}
public async Task EntityWithEnumProperty()
{
try {
var entityManager = await TestFns.NewEm(_serviceName);
var roles = await EntityQuery.From <Role>().Execute(entityManager);
var roleTypes = roles.Where(r => r.RoleType != null).Select(r => r.RoleType).ToList();
var isEnum = roleTypes.First().GetType().IsEnum;
Assert.IsTrue(isEnum);
} catch (Exception e) {
var message = TestFns.FormatException(e);
Assert.Fail(message);
}
}
public async Task Expansions()
{
try {
var entityManager = await TestFns.NewEm(_serviceName);
EntityQuery <Order> query;
IEnumerable <Order> orders;
// Alfreds orders expanded with their OrderDetails
query = new EntityQuery <Order>().Where(o => o.CustomerID == _alfredsID).Expand("OrderDetails");
orders = await entityManager.ExecuteQuery(query);
AssertGotOrderDetails(entityManager, orders);
// Alfreds orders expanded with their parent Customers and OrderDetails
query = new EntityQuery <Order>().Where(o => o.CustomerID == _alfredsID).Expand("Customer").Expand("OrderDetails");
orders = await entityManager.ExecuteQuery(query);
AssertGotOrderDetails(entityManager, orders);
AssertGotCustomerByExpand(entityManager, orders);
// Alfreds orders, including their OrderDetails, and the Products of those details,
query = new EntityQuery <Order>().Where(o => o.CustomerID == _alfredsID).Expand("Customer").Expand("OrderDetails.Product");
orders = await entityManager.ExecuteQuery(query);
AssertGotOrderDetails(entityManager, orders);
AssertGotCustomerByExpand(entityManager, orders);
AssertGotProductsByExpand(entityManager, orders);
} catch (Exception e) {
var message = TestFns.FormatException(e);
Assert.Fail(message);
}
// Products with related Supplier entity with complex type,
try {
var entityManager = await TestFns.NewEm(_serviceName);
var query = new EntityQuery <Product>().Take(1).Expand("Supplier");
var products = await entityManager.ExecuteQuery(query);
Assert.IsTrue(products.Any(), "A product should be returned");
var product = products.First();
Assert.IsNotNull(product.Supplier, "A product should have a supplier");
} catch (Exception e) {
var message = TestFns.FormatException(e);
Assert.Fail(message);
}
}
public async Task AllCustomers_Exceptions() {
var entityManager = new EntityManager(_serviceName);
// All instances of Customer
var query = new EntityQuery<Customer>();
// Capture result using try-catch
try {
var results = await entityManager.ExecuteQuery(query);
var count = results.Count();
Assert.IsTrue(count > 0, "Customer query returned " + count + " customers");
} catch (Exception e) {
var message = TestFns.FormatException(e);
Assert.Fail(message);
}
}
public async Task ComplexType() {
try {
var entityManager = await TestFns.NewEm(_serviceName);
// Query an entity (Supplier) which holds a complex type (Location)
var suppliers = await EntityQuery.From<Supplier>().Take(1).Execute(entityManager);
var supplier = suppliers.FirstOrDefault();
Assert.IsNotNull(supplier, "Supplier should be non-null");
Assert.IsNotNull(supplier.Location, "Supplier location should be non-null");
Assert.IsFalse(string.IsNullOrEmpty(supplier.Location.Address), "Supplier address should be non-null and not empty");
} catch (Exception e) {
var message = TestFns.FormatException(e);
Assert.Fail(message);
}
}
public async Task AllCustomers_Task() {
var entityManager = new EntityManager(_serviceName);
// All instances of Customer
var query = new EntityQuery<Customer>(); // Alternate way to create a basic EntityQuery
// Handle async Task results explicitly
await entityManager.ExecuteQuery(query).ContinueWith(task => {
if (task.IsFaulted) {
var message = TestFns.FormatException(task.Exception);
Assert.Fail(message);
} else {
var count = task.Result.Count();
Assert.IsTrue(count > 0, "Customer query returned " + count + " customers");
}
});
}
public async Task SpecializedMethods() {
try {
var entityManager = await TestFns.NewEm(_serviceName);
// CustomersAsHRM returns an HTTPResponseMessage
// can filter, select, and expand
var query = EntityQuery.From<Customer>("CustomersAsHRM")
.Where(c => c.CustomerID == _alfredsID)
.Select(c => new {
CustomerID = c.CustomerID,
CompanyName = c.CompanyName,
});
var items = await entityManager.ExecuteQuery(query);
Assert.IsTrue(items.Count() == 1, "Should return one customer projection item");
var item = items.FirstOrDefault();
} catch (Exception e) {
var message = TestFns.FormatException(e);
Assert.Fail(message);
}
}
public async Task OrderingAndPaging() {
var entityManager = await TestFns.NewEm(_serviceName);
EntityQuery<Product> query;
IEnumerable<Product> products;
try {
// Products sorted by name
query = new EntityQuery<Product>().Expand("Category").OrderBy(p => p.ProductName);
products = await entityManager.ExecuteQuery(query);
VerifyProductResults(products);
// Products sorted by name in descending order
query = new EntityQuery<Product>().Expand("Category").OrderByDescending(p => p.ProductName);
products = await entityManager.ExecuteQuery(query);
VerifyProductResults(products);
// Products sorted by price descending, then name ascending
query = new EntityQuery<Product>().Expand("Category").OrderBy(p => p.ProductName).OrderByDescending(p => p.ProductName);
products = await entityManager.ExecuteQuery(query);
VerifyProductResults(products);
// look in results for ...
// (27) 'Schoggi Schokolade' at $43.9 in 'Confections',
// (63) 'Vegie-spread' at $43.9 in 'Condiments',...
// Products sorted by related category descending
query = new EntityQuery<Product>().Expand("Category").OrderByDescending(p => p.Category.CategoryName);
products = await entityManager.ExecuteQuery(query);
VerifyProductResults(products);
// First 5 of products ordered by product name, then expanded to related category
query = new EntityQuery<Product>().OrderBy(p => p.ProductName).Take(5).Expand("Category");
products = await entityManager.ExecuteQuery(query);
VerifyProductResults(products);
// Skip first 10 of products ordered by product name, then expanded to related category
query = new EntityQuery<Product>().OrderBy(p => p.ProductName).Skip(10).Expand("Category");
products = await entityManager.ExecuteQuery(query);
VerifyProductResults(products);
// Products paging with skip and take
query = new EntityQuery<Product>().OrderBy(p => p.ProductName).Skip(10).Take(5).Expand("Category");
products = await entityManager.ExecuteQuery(query);
VerifyProductResults(products);
// Inline count of paged products
var productQuery = new EntityQuery<Product>().Where(p => p.ProductName.StartsWith("C"));
var pagedQuery = productQuery.OrderBy(p => p.ProductName).Skip(5).Take(5).InlineCount();
// Execute in parallel and verify products received
var productTask = entityManager.ExecuteQuery(productQuery);
var pagedTask = entityManager.ExecuteQuery(pagedQuery);
await Task.WhenAll(productTask, pagedTask);
var productCount = productTask.Result.Count();
var pageCount = pagedTask.Result.Count();
var pagedQueryResult = pagedTask.Result as QueryResult<Product>;
var inlineCount = pagedQueryResult.InlineCount;
Assert.AreEqual(productCount, inlineCount, "Inline count should return item count excluding skip/take");
Assert.IsTrue(pageCount <= productCount, "Paged query should return subset of total query");
} catch (Exception e) {
var message = TestFns.FormatException(e);
Assert.Fail(message);
}
}
