public async Task SaveCustomersAndNewOrder() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery<Customer>("Customers").Where(c => c.CompanyName.StartsWith("A")); var custs = await q.Execute(em1); Assert.IsTrue(custs.Count() > 0, "should be some results"); custs.ForEach(c => c.Fax = TestFns.MorphString(c.Fax)); var cust1 = em1.CreateEntity<Customer>(); cust1.CompanyName = "Test001"; var cust1Key = cust1.EntityAspect.EntityKey; var order1 = em1.CreateEntity<Order>(); var order1Key = order1.EntityAspect.EntityKey; order1.Customer = cust1; var custCount = em1.GetEntities<Customer>().Count(); Assert.IsTrue(em1.HasChanges(), "hasChanges should be true"); Assert.IsTrue(em1.GetChanges().Count() > 0, "should have changes"); var saveResult = await em1.SaveChanges(); Assert.IsTrue(saveResult.Entities.Count == custs.Count() + 2, "should have returned the correct number of entities"); Assert.IsTrue(order1Key != order1.EntityAspect.EntityKey, "order1 entityKey should have changed"); Assert.IsTrue(cust1Key != cust1.EntityAspect.EntityKey, "cust1 entityKey should have changed"); Assert.IsTrue(order1.Customer == cust1, "cust attachment should be the same"); Assert.IsTrue(cust1.Orders.Contains(order1), "order attachment should be the same"); Assert.IsTrue(saveResult.KeyMappings[order1Key] == order1.EntityAspect.EntityKey, "keyMapping for order should be avail"); Assert.IsTrue(saveResult.KeyMappings[cust1Key] == cust1.EntityAspect.EntityKey, "keyMapping for order should be avail"); Assert.IsTrue(em1.GetEntities<Customer>().Count() == custCount, "should be the same number of custs"); Assert.IsTrue(order1.EntityAspect.EntityState.IsUnchanged()); Assert.IsTrue(cust1.EntityAspect.EntityState.IsUnchanged()); Assert.IsTrue(em1.HasChanges() == false, "hasChanges should be false"); Assert.IsTrue(em1.GetChanges().Count() == 0, "should be no changes left"); }
public async Task NullForeignKey() { await _emTask; var prod1 = new Product(); _em1.AttachEntity(prod1); prod1.ProductName = "Test"; prod1.SupplierID = null; var q0 = new EntityQuery<Product>().Where(p => p.Supplier != null).Take(2).Expand(p => p.Supplier); var r0 = (await q0.Execute(_em1)).ToList(); Assert.IsTrue(r0.Count() == 2); Assert.IsTrue(r0.All(p => p.Supplier != null)); var p0 = r0[0]; var p1 = r0[1]; var s0 = p0.Supplier; var s1 = p1.Supplier; Assert.IsTrue(s0.Products.Contains(p0)); p0.Supplier = null; Assert.IsTrue(p0.SupplierID == null); Assert.IsTrue(!s0.Products.Contains(p0)); Assert.IsTrue(s1.Products.Contains(p1)); p1.SupplierID = null; Assert.IsTrue(p1.Supplier == null); Assert.IsTrue(!s1.Products.Contains(p1)); }
public async Task CustomersStartingWith() { await _emTask; var q = new EntityQuery<Customer>("CustomersStartingWith").WithParameter("companyName", "A"); var rp = q.GetResourcePath(); var customers = await q.Execute(_em1); Assert.IsTrue(customers.Count() > 0, "should be some results"); Assert.IsTrue(customers.All(c => c.CompanyName.StartsWith("A"))); }
public async Task LoadNavigationPropertyNonscalar() { var em1 = await TestFns.NewEm(_serviceName); TestFns.RunInWpfSyncContext( async () => { var q0 = new EntityQuery<Customer>().Where(c => c.Orders.Any()).Take(3); var r0 = await q0.Execute(em1); // Task.WaitAll(r0.Select(c => c.EntityAspect.LoadNavigationProperty("Orders")).ToArray()); await Task.WhenAll(r0.Select(c => c.EntityAspect.LoadNavigationProperty("Orders"))); Assert.IsTrue(r0.All(c => c.Orders.Count() > 0)); }); }
public async Task CustomersStartingWith() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery<Customer>("CustomersStartingWith").WithParameter("companyName", "A"); var rp = q.GetResourcePath(em1.MetadataStore); var customers = await q.Execute(em1); Assert.IsTrue(customers.Count() > 0, "should be some results"); Assert.IsTrue(customers.All(c => c.CompanyName.StartsWith("A"))); }
public async Task NestedExpand() { var em1 = await TestFns.NewEm(_serviceName); var q0 = new EntityQuery <OrderDetail>().Take(5).Expand(od => od.Order.Customer); var r0 = await q0.Execute(em1); Assert.IsTrue(r0.Count() > 0, "should have returned some orderDetails"); Assert.IsTrue(r0.All(od => od.Order != null && od.Order.Customer != null)); }
public async Task ExpandNested3Levels() { var em1 = await TestFns.NewEm(_serviceName); var q0 = new EntityQuery <Order>().Take(5).Expand("OrderDetails.Product.Category"); var r0 = await q0.Execute(em1); Assert.IsTrue(r0.Count() > 0, "should have returned some orders"); Assert.IsTrue(r0.All(o => o.OrderDetails.Any(od => od.Product.Category != null))); }
public async Task WhereAnyNested() { var em1 = await TestFns.NewEm(_serviceName); var query1 = new EntityQuery <Customer>() .Where(c => c.Orders.Any(o => o.OrderDetails.All(od => od.UnitPrice > 200))); var results = await query1.Execute(em1); Assert.IsTrue(results.Any()); }
public async Task CustomersStartingWith() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Customer>("CustomersStartingWith").WithParameter("companyName", "A"); var rp = q.GetResourcePath(); var customers = await q.Execute(em1); Assert.IsTrue(customers.Count() > 0, "should be some results"); Assert.IsTrue(customers.All(c => c.CompanyName.StartsWith("A"))); }
public async Task SimpleAnonEntityCollectionSelect() { await _emTask; var q1 = new EntityQuery<Customer>().Where(c => c.CompanyName.StartsWith("C")).Select(c => new { c.Orders }); var r1 = await q1.Execute(_em1); Assert.IsTrue(r1.Count() > 0); var ok = r1.All(r => r.Orders.Count() > 0); Assert.IsTrue(ok); }
public async Task SimpleSelect2() { await _emTask; var q1 = new EntityQuery<Customer>().Where(c => c.CompanyName.StartsWith("C")).Expand("Orders").Select(c => c.Orders); var r1 = await q1.Execute(_em1); Assert.IsTrue(r1.Count() > 0); //var ok = r1.All(c => c.GetType() == typeof(Customer)); //Assert.IsTrue(ok); }
public async Task SimpleSelect() { await _emTask; var q1 = new EntityQuery<Order>().Select(o => o.Customer).Take(5); var r1 = await q1.Execute(_em1); Assert.IsTrue(r1.Count() == 5); var ok = r1.All(c => c.GetType() == typeof(Customer)); Assert.IsTrue(ok); }
public async Task LoadNavigationPropertyScalar() { var em1 = await TestFns.NewEm(_serviceName); TestFns.RunInWpfSyncContext(async() => { var q0 = new EntityQuery <Order>().Where(o => o.Customer != null).Take(3); var r0 = await q0.Execute(em1); // Task.WaitAll(r0.Select(o => o.EntityAspect.LoadNavigationProperty("Customer")).ToArray()); await Task.WhenAll(r0.Select(o => o.EntityAspect.LoadNavigationProperty("Customer"))); Assert.IsTrue(r0.All(o => o.Customer != null)); }); }
public async Task SimpleEntitySelect() { Assert.Inconclusive("Known issue with OData - use an anon projection instead"); await _emTask; var q1 = new EntityQuery<Order>().Where(o => true).Select(o => o.Customer).Take(5); var r1 = await q1.Execute(_em1); Assert.IsTrue(r1.Count() == 5); var ok = r1.All(r => r.GetType() == typeof(Customer)); Assert.IsTrue(ok); }
public async Task SelectSimpleAnonEntity() { var em1 = await TestFns.NewEm(_serviceName); var q1 = new EntityQuery <Order>().Select(o => new { o.Customer }).Take(5); var r1 = await q1.Execute(em1); Assert.IsTrue(r1.Count() == 5); var ok = r1.All(r => r.Customer.GetType() == typeof(Customer)); Assert.IsTrue(ok); }
public async Task SelectAnonSingleDp() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Customer>("Customers") .Where(c => c.CompanyName.StartsWith("C")) .Select(c => new { c.CompanyName }); var results = await q.Execute(em1); Assert.IsTrue(results.Any()); }
public async Task SelectSimpleAnonEntityCollection() { var em1 = await TestFns.NewEm(_serviceName); var q1 = new EntityQuery <Customer>().Where(c => c.CompanyName.StartsWith("C")).Select(c => new { c.Orders }); var r1 = await q1.Execute(em1); Assert.IsTrue(r1.Count() > 0); var ok = r1.All(r => r.Orders.Count() > 0); Assert.IsTrue(ok); }
public async Task CompanyNamesAndIds() { await _emTask; var q = new EntityQuery<Object>("CompanyNamesAndIds"); var rp = q.GetResourcePath(); var companyNamesAndIds = await q.Execute(_em1); Assert.IsTrue(companyNamesAndIds.Count() > 0, "should be some results"); // each item is a JObject var companyNamesAndIdObjects = companyNamesAndIds.Cast<JObject>(); var item = companyNamesAndIdObjects.First(); var companyName = item["CompanyName"].ToObject<String>(); var id = item["CustomerID"].ToObject<Guid>(); }
public async Task LoadNavigationPropertyNonscalar() { var em1 = await TestFns.NewEm(_serviceName); TestFns.RunInWpfSyncContext(async() => { var q0 = new EntityQuery <Customer>().Where(c => c.Orders.Any()).Take(3); var r0 = await q0.Execute(em1); // Task.WaitAll(r0.Select(c => c.EntityAspect.LoadNavigationProperty("Orders")).ToArray()); await Task.WhenAll(r0.Select(c => c.EntityAspect.LoadNavigationProperty("Orders"))); Assert.IsTrue(r0.All(c => c.Orders.Count() > 0)); }); }
public async Task SimpleAnonEntityCollectionSelect() { await _emTask; var q1 = new EntityQuery <Customer>().Where(c => c.CompanyName.StartsWith("C")).Select(c => new { c.Orders }); var r1 = await q1.Execute(_em1); Assert.IsTrue(r1.Count() > 0); var ok = r1.All(r => r.Orders.Count() > 0); Assert.IsTrue(ok); }
public async Task SimpleAnonEntitySelect() { await _emTask; var q1 = new EntityQuery <Order>().Select(o => new { o.Customer }).Take(5); var r1 = await q1.Execute(_em1); Assert.IsTrue(r1.Count() == 5); var ok = r1.All(r => r.Customer.GetType() == typeof(Customer)); Assert.IsTrue(ok); }
public async Task QueryWithYearFn() { var em1 = await TestFns.NewEm(_serviceName); var q0 = new EntityQuery <Employee>().Where(e => e.HireDate.Value.Year > 1993); var r0 = await q0.Execute(em1); Assert.IsTrue(r0.Count() > 0); Assert.IsTrue(r0.All(r => r.HireDate.Value.Year > 1993)); var r1 = q0.ExecuteLocally(em1); Assert.IsTrue(r1.Count() == r0.Count()); }
public async Task SimpleEntitySelect() { Assert.Inconclusive("Known issue with OData - use an anon projection instead"); await _emTask; var q1 = new EntityQuery <Order>().Where(o => true).Select(o => o.Customer).Take(5); var r1 = await q1.Execute(_em1); Assert.IsTrue(r1.Count() == 5); var ok = r1.All(r => r.GetType() == typeof(Customer)); Assert.IsTrue(ok); }
public async Task Take0WithInlineCount() { await _emTask; var q0 = new EntityQuery <Customer>().Take(0).InlineCount(); var r0 = await q0.Execute(_em1); Assert.IsTrue(r0.Count() == 0); var count = ((IHasInlineCount)r0).InlineCount; Assert.IsTrue(count > 0); }
public async Task QueryWithAddFn() { await _emTask; var q0 = new EntityQuery <Employee>().Where(e => e.EmployeeID + e.ReportsToEmployeeID.Value > 3); var r0 = await q0.Execute(_em1); Assert.IsTrue(r0.Count() > 0); Assert.IsTrue(r0.All(e => e.EmployeeID + e.ReportsToEmployeeID > 3)); var r1 = q0.ExecuteLocally(_em1); Assert.IsTrue(r1.Count() == r0.Count()); }
public async Task QueryWithMonthFn() { await _emTask; var q0 = new EntityQuery <Employee>().Where(e => e.HireDate.Value.Month > 6 && e.HireDate.Value.Month < 11); var r0 = await q0.Execute(_em1); Assert.IsTrue(r0.Count() > 0); Assert.IsTrue(r0.All(e => e.HireDate.Value.Month > 6 && e.HireDate.Value.Month < 11)); var r1 = q0.ExecuteLocally(_em1); Assert.IsTrue(r1.Count() == r0.Count()); }
public async Task QueryWithYearFn() { await _emTask; var q0 = new EntityQuery <Employee>().Where(e => e.HireDate.Value.Year > 1993); var r0 = await q0.Execute(_em1); Assert.IsTrue(r0.Count() > 0); Assert.IsTrue(r0.All(r => r.HireDate.Value.Year > 1993)); var r1 = q0.ExecuteLocally(_em1); Assert.IsTrue(r1.Count() == r0.Count()); }
public async Task ExpEntities() { await _emTask; var q = new EntityQuery<Foo.Customer>("Customers").Take(5); var results = await q.Execute(_em1); Assert.IsTrue(results.Count() > 0); var exportedEntities = _em1.ExportEntities(); File.WriteAllText("c:/temp/emExport.txt", exportedEntities); }
public async Task SaveModifiedCustomers() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Customer>("Customers").Where(c => c.CompanyName.StartsWith("A")); var custs = await q.Execute(em1); Assert.IsTrue(custs.Count() > 0, "should be some results"); custs.ForEach(c => c.Fax = TestFns.MorphString(c.Fax)); var saveResult = await em1.SaveChanges(); Assert.IsTrue(saveResult.Entities.Count == custs.Count()); }
public async Task ExpEntities() { await _emTask; var q = new EntityQuery <Foo.Customer>("Customers").Take(5); var results = await q.Execute(_em1); Assert.IsTrue(results.Count() > 0); var exportedEntities = _em1.ExportEntities(); File.WriteAllText("c:/temp/emExport.txt", exportedEntities); }
public async Task EmployeesFilteredByCountryAndBirthDate() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Employee>().From("EmployeesFilteredByCountryAndBirthdate") .WithParameter("birthDate", "1/1/1960") .WithParameter("country", "USA"); var rp = q.GetResourcePath(em1.MetadataStore); var results = await q.Execute(em1); Assert.IsTrue(results.Any()); }
public async Task ExpEntities() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Foo.Customer>("Customers").Take(5); var results = await q.Execute(em1); Assert.IsTrue(results.Count() > 0); var exportedEntities = em1.ExportEntities(); File.WriteAllText("c:/temp/emExport.txt", exportedEntities); }
public async Task ExpEntities() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery<Foo.Customer>("Customers").Take(5); var results = await q.Execute(em1); Assert.IsTrue(results.Count() > 0); var exportedEntities = em1.ExportEntities(); File.WriteAllText("c:/temp/emExport.txt", exportedEntities); }
public async Task Take0WithInlineCount() { var em1 = await TestFns.NewEm(_serviceName); var q0 = new EntityQuery <Customer>().Take(0).InlineCount(); var r0 = await q0.Execute(em1); Assert.IsTrue(r0.Count() == 0); var count = ((IHasInlineCount)r0).InlineCount; Assert.IsTrue(count > 0); }
public async Task SelectScalarNpNoAnon() { Assert.Inconclusive("Known issue with OData - use an anon projection instead"); var em1 = await TestFns.NewEm(_serviceName); var q1 = new EntityQuery <Order>().Where(o => true).Select(o => o.Customer).Take(5); var r1 = await q1.Execute(em1); Assert.IsTrue(r1.Count() == 5); var ok = r1.All(r => r.GetType() == typeof(Customer)); Assert.IsTrue(ok); }
public async Task WhereFnAdd() { var em1 = await TestFns.NewEm(_serviceName); var q0 = new EntityQuery <Employee>().Where(e => e.EmployeeID + e.ReportsToEmployeeID.Value > 3); var r0 = await q0.Execute(em1); Assert.IsTrue(r0.Count() > 0); Assert.IsTrue(r0.All(e => e.EmployeeID + e.ReportsToEmployeeID > 3)); var r1 = q0.ExecuteLocally(em1); Assert.IsTrue(r1.Count() == r0.Count()); }
public async Task WhereFnMonth() { var em1 = await TestFns.NewEm(_serviceName); var q0 = new EntityQuery <Employee>().Where(e => e.HireDate.Value.Month > 6 && e.HireDate.Value.Month < 11); var r0 = await q0.Execute(em1); Assert.IsTrue(r0.Count() > 0); Assert.IsTrue(r0.All(e => e.HireDate.Value.Month > 6 && e.HireDate.Value.Month < 11)); var r1 = q0.ExecuteLocally(em1); Assert.IsTrue(r1.Count() == r0.Count()); }
public async Task QueryWithBadResourceName() { var em1 = await TestFns.NewEm(_serviceName); var q0 = new EntityQuery <Customer>("Error").Where(c => c.CompanyName.StartsWith("P")); try { var r0 = await q0.Execute(em1); Assert.Fail("shouldn't get here"); } catch (Exception e) { Assert.IsTrue(e.Message.ToLower().Contains("not found"), "should be the right message"); } }
public async Task CompanyNamesAndIds() { await _emTask; var q = new EntityQuery <Object>("CompanyNamesAndIds"); var rp = q.GetResourcePath(); var companyNamesAndIds = await q.Execute(_em1); Assert.IsTrue(companyNamesAndIds.Count() > 0, "should be some results"); // each item is a JObject var companyNamesAndIdObjects = companyNamesAndIds.Cast <JObject>(); var item = companyNamesAndIdObjects.First(); var companyName = item["CompanyName"].ToObject <String>(); var id = item["CustomerID"].ToObject <Guid>(); }
public async Task CompanyNames() { await _emTask; var q = new EntityQuery<String>("CompanyNames"); var rp = q.GetResourcePath(); var companyNames = await q.Execute(_em1); Assert.IsTrue(companyNames.Count() > 0, "should be some results"); var q2 = new EntityQuery<Object>("CompanyNames"); rp = q2.GetResourcePath(); var companyNames2 = await q2.Execute(_em1); Assert.IsTrue(companyNames2.Count() > 0, "should be some results"); Assert.IsTrue(companyNames.SequenceEqual(companyNames2.Cast<String>())); }
public async Task CustomersAndOrders() { await _emTask; var q = new EntityQuery <Customer>("CustomersAndOrders").Where(c => c.CompanyName.StartsWith("A")); var rp = q.GetResourcePath(); var results = await q.Execute(_em1); Assert.IsTrue(results.Count() > 0, "should be some results"); Assert.IsTrue(_em1.GetEntities <Customer>().Count() > 0, "should have some customers"); Assert.IsTrue(_em1.GetEntities <Order>().Count() > 0, "should have some orders"); Assert.IsTrue(results.All(c => c.CompanyName.StartsWith("A"))); }
public async Task CustomersAndOrders() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Customer>("CustomersAndOrders").Where(c => c.CompanyName.StartsWith("A")); var rp = q.GetResourcePath(em1.MetadataStore); var results = await q.Execute(em1); Assert.IsTrue(results.Count() > 0, "should be some results"); Assert.IsTrue(em1.GetEntities <Customer>().Count() > 0, "should have some customers"); Assert.IsTrue(em1.GetEntities <Order>().Count() > 0, "should have some orders"); Assert.IsTrue(results.All(c => c.CompanyName.StartsWith("A"))); }
private async Task <IEnumerable <T> > QueryBillingBase <T>(EntityManager em, String typeName) where T : IBillingDetail { var q0 = new EntityQuery <T>(typeName + "s").With(em); var r0 = await q0.Execute(); if (r0.Count() == 0) { Assert.Inconclusive("Please restart the server - inheritance data was deleted by prior tests"); } Assert.IsTrue(r0.All(r => typeof(T).IsAssignableFrom(r.GetType()))); Assert.IsTrue(r0.All(r => r.Owner == r.Owner.ToUpper()), "all owners should be uppercase (from initializer)"); Assert.IsTrue(r0.All(r => r.MiscData == "asdf"), "all 'MiscData' should be 'asdf' (from initializer)"); return(r0); }
public async Task ExpEntitiesWithChanges() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery<Foo.Customer>("Customers").Take(5); var results = await q.Execute(em1); Assert.IsTrue(results.Count() > 0); var custs = results.Take(2); custs.ForEach(c => c.City = "Paris"); var emp1 = em1.CreateEntity<Employee>(); var exportedEntities = em1.ExportEntities(); File.WriteAllText("c:/temp/emExportWithChanges.txt", exportedEntities); }
public async Task ExpImpEntitiesWithEnum() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery<Foo.Role>("Roles").Take(5); var results = await q.Execute(em1); Assert.IsTrue(results.Any()); var exportedEntities = em1.ExportEntities(); File.WriteAllText("c:/temp/emExportWithEnum.txt", exportedEntities); var em2 = new EntityManager(em1); em2.ImportEntities(exportedEntities); var roleTypes = em2.GetEntities<Role>().Select(x => x.RoleType).ToList(); Assert.IsTrue(roleTypes.Count == 5, "should have imported 5 entities"); }
public async Task GetChanges() { await _emTask; var customer = new Customer(); var q = new EntityQuery<Customer>().Take(2); var custs = await q.Execute(_em1); custs.First().City = "XXX"; var q2 = new EntityQuery<Employee>().Take(3); var emps = await q2.Execute(_em1); emps.Take(2).ForEach(emp => emp.LastName = "XXX"); var newCust1 = _em1.CreateEntity<Customer>(); var newEmp1 = _em1.CreateEntity<Employee>(); var changedEntities = _em1.GetChanges(); Assert.IsTrue(changedEntities.Count() == 5, "should be 5 changes"); var changedCusts = _em1.GetChanges(typeof(Customer)); Assert.IsTrue(changedCusts.Count() == 2, "should be 2 changed custs"); var changedEmps = _em1.GetChanges(typeof(Employee)); Assert.IsTrue(changedEmps.Count() == 3, "should be 3 changed emps"); var changedEntities2 = _em1.GetChanges(typeof(Employee), typeof(Customer)); Assert.IsTrue(changedEntities2.Count() == 5, "should be 5 changes"); }
public async Task OriginalValues() { await _emTask; var q = new EntityQuery<Foo.Supplier>("Suppliers").Where(s => s.CompanyName.StartsWith("P")); var suppliers = await q.Execute(_em1); suppliers.ForEach((s, i) => s.Location.Address = "Foo:" + s.Location.Address); Assert.IsTrue(suppliers.All(s => s.EntityAspect.EntityState.IsModified())); Assert.IsTrue(suppliers.All(s => s.EntityAspect.OriginalValuesMap.Count() == 0), "supplier originalValuesMap should be empty"); suppliers.ForEach(s => { var location = s.Location; Assert.IsTrue(location.Address.StartsWith("Foo"), "address should start with 'Foo'"); Assert.IsTrue(location.ComplexAspect.OriginalValuesMap.ContainsKey("Address"), "ComplexAspect originalValues should contain address"); var oldAddress = (String) location.ComplexAspect.OriginalValuesMap["Address"]; if (oldAddress == null) { Assert.IsTrue(location.Address == "Foo:", "should have a null old address"); } else { Assert.IsTrue(location.Address.Substring(4) == oldAddress, "should have the right old address"); } }); }
public async Task SaveModifiedCustomers() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery<Customer>("Customers").Where(c => c.CompanyName.StartsWith("A")); var custs = await q.Execute(em1); Assert.IsTrue(custs.Count() > 0, "should be some results"); custs.ForEach(c => c.Fax = TestFns.MorphString(c.Fax)); var saveResult = await em1.SaveChanges(); Assert.IsTrue(saveResult.Entities.Count == custs.Count()); }
public async Task ExpImpComplexType() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery<Foo.Supplier>("Suppliers").Where(s => s.CompanyName.StartsWith("P")); var suppliers = await q.Execute(em1); suppliers.ForEach((s, i) => s.Location.Address = "Foo:" + i.ToString()); Assert.IsTrue(suppliers.All(s => s.EntityAspect.EntityState.IsModified())); var exportedEm = em1.ExportEntities(); var em2 = new EntityManager(em1); var impResult = em2.ImportEntities(exportedEm); Assert.IsTrue(impResult.ImportedEntities.Count == suppliers.Count()); impResult.ImportedEntities.Cast<Supplier>().ForEach(s => { Assert.IsTrue(s.EntityAspect.OriginalValuesMap.Count == 0, "supplierOriginalValuesMap should be empty"); var location = s.Location; Assert.IsTrue(location.Address.StartsWith("Foo"), "address should start with 'Foo'"); Assert.IsTrue(location.ComplexAspect.OriginalValuesMap.ContainsKey("Address"), "ComplexAspect originalValues should contain address"); }); }
public async Task ExpImpTempKeyFixup2() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery<Foo.Supplier>("Suppliers").Where(s => s.CompanyName.StartsWith("P")); var suppliers = await q.Execute(em1); Assert.IsTrue(suppliers.Count() > 0, "should be some suppliers"); var orderIdProp = MetadataStore.Instance.GetEntityType("Order").KeyProperties[0]; em1.KeyGenerator.GetNextTempId(orderIdProp); var order1 = new Order(); var emp1 = new Employee(); em1.AddEntity(order1); em1.AddEntity(emp1); emp1.LastName = "bar"; var cust1 = new Customer() { CompanyName = "Foo" }; order1.Employee = emp1; order1.Customer = cust1; var exportedEm = em1.ExportEntities(null, false); var em2 = new EntityManager(em1); em2.ImportEntities(exportedEm); var suppliers2 = em2.GetEntities<Supplier>().ToList(); Assert.IsTrue(suppliers.Count() == suppliers2.Count, "should be the same number of suppliers"); var addedOrders = em2.GetEntities<Order>(EntityState.Added); Assert.IsTrue(addedOrders.Count() == 1, "should be 1 added order"); var order1x = addedOrders.First(); var cust1x = order1x.Customer; Assert.IsTrue(cust1x.CompanyName == "Foo", "customer company name should be 'Foo'"); var emp1x = order1x.Employee; Assert.IsTrue(emp1x.LastName == "bar", "lastName should be 'bar'"); }
public async Task CustomersWithHttpError() { await _emTask; var q = new EntityQuery<Customer>("CustomersWithHttpError"); var rp = q.GetResourcePath(); try { var results = await q.Execute(_em1); Assert.Fail("shouldn't get here"); } catch (HttpRequestException e) { Assert.IsTrue(e.Message.Contains("Custom Reason")); Assert.IsTrue(e.Message.Contains("404")); } }
public async Task SearchCustomersWithParameters() { await _emTask; //var query = EntityQuery.from("SearchCustomers") // .withParameters( { CompanyName: "A", ContactNames: ["B", "C"] , City: "Los Angeles" } ); var q = new EntityQuery<Customer>("SearchCustomers") .WithParameters(new Dictionary<String, Object> { { "CompanyName", "A" }, { "ContactNames", new String[] { "B", "C" }}, { "City", "LosAngeles" } }); var rp = q.GetResourcePath(); var results = await q.Execute(_em1); Assert.IsTrue(results.Count() == 3, "should be 3 results"); Assert.IsTrue(_em1.GetEntities<Customer>().Count() > 0, "should have some customers"); }
public async Task CustomersAndOrders() { await _emTask; var q = new EntityQuery<Customer>("CustomersAndOrders").Where(c => c.CompanyName.StartsWith("A")); var rp = q.GetResourcePath(); var results = await q.Execute(_em1); Assert.IsTrue(results.Count() > 0, "should be some results"); Assert.IsTrue(_em1.GetEntities<Customer>().Count() > 0, "should have some customers"); Assert.IsTrue(_em1.GetEntities<Order>().Count() > 0, "should have some orders"); Assert.IsTrue(results.All(c => c.CompanyName.StartsWith("A"))); }
public async Task ExpImpTempKeyFixup1() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery<Foo.Employee>("Employees").Take(3); var results = await q.Execute(em1); Assert.IsTrue(results.Count() > 0); var emp1 = new Employee(); var order1 = new Order(); var order2 = new Order(); em1.AddEntity(emp1); emp1.Orders.Add(order1); emp1.Orders.Add(order2); var exportedEntities = em1.ExportEntities(null, false); // custs1 and 2 shouldn't be imported because of default preserveChanges // emps1 and 2 should cause the creation of NEW emps with new temp ids; // tempKeys should cause creation of new entities; var impResult = em1.ImportEntities(exportedEntities); var allEntities = em1.GetEntities(); Assert.IsTrue(allEntities.Count() == 9, "should have 9 (3 orig, 3 added, 3 imported (new) entities in the cache"); Assert.IsTrue(allEntities.OfType<Order>().Count() == 4, "should be 4 orders (2 + 2)"); Assert.IsTrue(allEntities.OfType<Employee>().Count() == 5, "should be 5 emps (3 + 1 + 1) "); Assert.IsTrue(allEntities.OfType<Employee>().Count(c => c.EntityAspect.EntityState.IsAdded()) == 2, "should only be 2 added emps"); Assert.IsTrue(allEntities.OfType<Order>().All(c => c.EntityAspect.EntityState.IsAdded())); Assert.IsTrue(impResult.ImportedEntities.Count == 6, "should have imported 6 entities - 3 orig + 3 new"); Assert.IsTrue(impResult.ImportedEntities.OfType<Order>().Count() == 2, "should have imported 2 orders"); Assert.IsTrue(impResult.ImportedEntities.OfType<Employee>().Count(e => e.EntityAspect.EntityState.IsAdded()) == 1, "should have imported 1 added emp"); Assert.IsTrue(impResult.ImportedEntities.OfType<Employee>().Count(e => e.EntityAspect.EntityState.IsUnchanged()) == 3, "should have imported 3 unchanged emps"); Assert.IsTrue(impResult.TempKeyMap.Count == 3, "tempKeyMap should be of length 3"); Assert.IsTrue(impResult.TempKeyMap.All(kvp => kvp.Key != kvp.Value), "imported entities should not have same key values"); var newOrders = impResult.ImportedEntities.OfType<Order>(); var newEmp = impResult.ImportedEntities.OfType<Employee>().First(e => e.EntityAspect.EntityState.IsAdded()); Assert.IsTrue(newOrders.All(no => no.EmployeeID == newEmp.EmployeeID), "should have updated order empId refs"); }
public async Task SaveModifiedCpAndNonCp() { await _emTask; var q0 = EntityQuery.From<Supplier>().Where(s => s.CompanyName.StartsWith("P")); var r0 = await q0.With(_em1).Execute(); Assert.IsTrue(r0.Count() > 0); var supplier = r0.First(); var val = "foo-" + TestFns.RandomSuffix(5); var oldVal = supplier.Location.PostalCode; Assert.IsTrue(val != oldVal); supplier.Location.PostalCode = val; var oldCompanyName = supplier.CompanyName; supplier.CompanyName = TestFns.MorphString(supplier.CompanyName); var newCompanyName = supplier.CompanyName; var sr = await _em1.SaveChanges(); Assert.IsTrue(sr.Entities.Count == 1); var _em2 = new EntityManager(_em1); var q1 = new EntityQuery<Supplier>().Where(s => s.Location.PostalCode == val); var r1 = await q1.Execute(_em2); Assert.IsTrue(r1.Count() == 1); Assert.IsTrue(r1.First().CompanyName == newCompanyName, "should have changed the companyName"); }
public async Task CaptureAddlSavesDoneOnServer() { var em1 = await TestFns.NewEm(_serviceName); // ok(true, "Skipped test - OData does not support server interception or alt resources"); // ok(true, "N/A for Mongo - test not yet implemented - requires server side async call"); var q = new EntityQuery<Category>().Where(c => c.CategoryName.StartsWith("Beverage")).Expand("Products"); var r = await q.Execute(em1); var category = r.First(); var products = category.Products; var prices = products.Select(p => p.UnitPrice).ToList(); category.CategoryName = TestFns.MorphString(category.CategoryName); var so = new SaveOptions(tag: "increaseProductPrice"); var sr = await em1.SaveChanges(null, so); Assert.IsTrue(sr.Entities.Count == 13, "should have saved 13 entities + 1 category + 12 products"); Assert.IsTrue(sr.Entities.OfType<Product>().Count() == 12, "should be 12 products"); var ek = category.EntityAspect.EntityKey; var em2 = new EntityManager(em1); var r2 = await em2.ExecuteQuery(ek.ToQuery<Category>().Expand("Products")); var cat2 = r2.First(); var products2 = cat2.Products; var newPrices = products2.Select(p => p.UnitPrice).ToList(); Assert.IsTrue(!prices.SequenceEqual(newPrices), "prices should have changed"); }
public async Task SaveModifiedCpOnly() { await _emTask; var q0 = EntityQuery.From<Supplier>().Where(s => s.CompanyName.StartsWith("P")); var r0 = await q0.With(_em1).Execute(); Assert.IsTrue(r0.Count() > 0); var supplier = r0.First(); var val = "foo-" + TestFns.RandomSuffix(5); var oldVal = supplier.Location.PostalCode; Assert.IsTrue(val != oldVal); supplier.Location.PostalCode = val; var sr = await _em1.SaveChanges(); Assert.IsTrue(sr.Entities.Count == 1); _em1.Clear(); var q1 = new EntityQuery<Supplier>().Where(s => s.Location.PostalCode == val); var r1 = await q1.Execute(_em1); Assert.IsTrue(r1.Count() == 1); }
public async Task CustomersWithBigOrders2() { await _emTask; var q = new EntityQuery<CustomerAndBigOrders>("CustomersWithBigOrders"); var rp = q.GetResourcePath(); var results = await q.Execute(_em1); Assert.IsTrue(results.Count() > 0, "should be some results"); Assert.IsTrue(_em1.GetEntities<Customer>().Count() > 0, "should have some customers"); Assert.IsTrue(_em1.GetEntities<Order>().Count() > 0, "should have some orders"); Assert.IsTrue(results.All(r => r.Customer.GetType() == typeof(Customer) && r.BigOrders.GetType() == typeof(List<Order>) )); }
public async Task AnonSelectEntity() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery<Order>().Take(5); var r0 = await q.Execute(em1); Assert.IsTrue(r0.Count() == 5); var q1 = new EntityQuery<Order>().Select(o => new { o.Customer }).Take(5); var r1 = await q1.Execute(em1); Assert.IsTrue(r1.Count() == 5); var ok = r1.All(r => r.Customer.GetType() == typeof(Customer)); Assert.IsTrue(ok); // This only works because we insure that the order exists in cache before the query var r1Local = q1.ExecuteLocally(em1); Assert.IsTrue(r1Local.Count() == r1.Count()); ok = r1Local.All(r => r.Customer.Orders.Count == 1); Assert.IsTrue(ok, "Order's per customer should be only one for now because that's all we cached"); ok = r1Local.All(r => r.Customer.GetType() == typeof(Customer)); Assert.IsTrue(ok ); }
public async Task LoadNavigationPropertyScalar() { var em1 = await TestFns.NewEm(_serviceName); TestFns.RunInWpfSyncContext(async () => { var q0 = new EntityQuery<Order>().Where(o => o.Customer != null).Take(3); var r0 = await q0.Execute(em1); // Task.WaitAll(r0.Select(o => o.EntityAspect.LoadNavigationProperty("Customer")).ToArray()); await Task.WhenAll(r0.Select(o => o.EntityAspect.LoadNavigationProperty("Customer"))); Assert.IsTrue(r0.All(o => o.Customer != null)); }); }