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); } }