public async Task GraphAttachParent() { var em1 = await TestFns.NewEm(_serviceName); var cust1 = new Customer(); var order1 = new Order(); cust1.Orders.Add(order1); em1.AddEntity(cust1); Assert.IsTrue(order1.EntityAspect.EntityState.IsAdded()); Assert.IsTrue(cust1.EntityAspect.EntityState.IsAdded()); var orders = cust1.Orders; Assert.IsTrue(orders.Contains(order1), "should contain both orders"); Assert.IsTrue(order1.Customer == cust1, "Customer should be cust2"); Assert.IsTrue(order1.CustomerID == cust1.CustomerID, "CustomerID should be cust2's id"); }
public async Task EntityKeyQuery() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Customer>().Take(1); var r = await em1.ExecuteQuery(q); var customer = r.First(); var q1 = new EntityQuery <Customer>().Where(c => c.CustomerID == customer.CustomerID); var r1 = await em1.ExecuteQuery(q1); Assert.IsTrue(r1.First() == customer); var ek = customer.EntityAspect.EntityKey; var q2 = ek.ToQuery(); var r2 = await em1.ExecuteQuery(q2); Assert.IsTrue(r2.Cast <Customer>().First() == customer); }
public async Task AttachRecursive() { var em1 = await TestFns.NewEm(_serviceName); var emp1 = new Employee(); var emp2 = new Employee(); var emp3 = new Employee(); emp2.Manager = emp1; emp3.Manager = emp2; em1.AddEntity(emp3); Assert.IsTrue(emp3.EntityAspect.IsAttached); Assert.IsTrue(emp2.EntityAspect.IsAttached); Assert.IsTrue(emp1.EntityAspect.IsAttached); Assert.IsTrue(emp1.DirectReports.Contains(emp2), "emp1 manages emp2"); Assert.IsTrue(emp2.DirectReports.Contains(emp3), "emp2 manages emp3"); Assert.IsTrue(emp2.Manager == emp1, "emp2 manager is emp1"); Assert.IsTrue(emp3.Manager == emp2, "emp3 mamager is emp2"); }
public async Task SearchCustomersWithParameters() { var em1 = await TestFns.NewEm(_serviceName); //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 ExpMetadata() { var em1 = await TestFns.NewEm(_serviceName); var metadata = MetadataStore.Instance.ExportMetadata(); File.WriteAllText("c:/temp/metadata.txt", metadata); var ms = MetadataStore.Instance; MetadataStore.__Reset(); Assert.IsTrue(ms != MetadataStore.Instance); MetadataStore.Instance.ImportMetadata(metadata); var metadata2 = MetadataStore.Instance.ExportMetadata(); File.WriteAllText("c:/temp/metadata2.txt", metadata2); Assert.IsTrue(metadata == metadata2); }
public async Task PkUpdateError() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Territory>().OrderByDescending(t => t.TerritoryID).Take(1); var terrs = await em1.ExecuteQuery(q); Assert.IsTrue(terrs.Count() == 1, "count should be 1"); var terr = terrs.First(); terr.TerritoryID = terr.TerritoryID + 1; try { var sr = await em1.SaveChanges(); Assert.Fail("should not get here"); } catch (SaveException e) { Assert.IsTrue(e.Message.Contains("part of the entity's key"), "message should mention entity's key"); } }
public async Task AddToNavSet() { var em1 = await TestFns.NewEm(_serviceName); var customer = new Customer(); var order = new Order(); em1.AttachEntity(customer); var origOrders = customer.Orders; Assert.IsTrue(origOrders.Count == 0); origOrders.Add(order); // next line won't compile - this is good! // customer.Orders = new NavigationSet<Order>(); Assert.IsTrue(origOrders.Count == 1); Assert.IsTrue(customer.Orders == origOrders, "should be same collection"); Assert.IsTrue(order.EntityAspect.IsAttached, "should be attached"); Assert.IsTrue(order.Customer == customer, "order.Customer should = customer"); }
public async Task WithOverwriteChanges() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Foo.Customer>("Customers"); var q2 = q.Where(c => c.CompanyName.StartsWith("C")); var q3 = q2.OrderBy(c => c.CompanyName).Take(2); var results = await q3.Execute(em1); Assert.IsTrue(results.Count() == 2); results.ForEach(r => { r.City = "xxx"; r.CompanyName = "xxx"; }); var results2 = await q3.With(MergeStrategy.OverwriteChanges).Execute(em1); // contents of results2 should be exactly the same as results Assert.IsTrue(results.Count() == 2); }
public async Task WhereAnyOrderBy2() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Foo.Customer>("Customers"); // just to fill up some extra custs var rBase = await q.Take(10).Execute(em1); var q2 = q.Where(c => c.CompanyName.StartsWith("C") && c.Orders.Any(o => o.Freight > 10)); var q3 = q2.OrderBy(c => c.City).Expand("Orders"); var r = await q3.Execute(em1); Assert.IsTrue(r.Count() > 0); Assert.IsTrue(r.All(r1 => r1.GetType() == typeof(Foo.Customer)), "should all get customers"); var rLocal = q3.ExecuteLocally(em1); Assert.IsTrue(rLocal.Count() == r.Count()); Assert.IsTrue(r.SequenceEqual(rLocal), "should be in the same order"); }
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 ValidationErrorsChanged() { var em1 = await TestFns.NewEm(_serviceName); var supplier = new Supplier(); var valErrors = supplier.EntityAspect.ValidationErrors; var errors = new List <DataErrorsChangedEventArgs>(); ((INotifyDataErrorInfo)supplier).ErrorsChanged += (se, e) => { errors.Add(e); }; em1.AddEntity(supplier); Assert.IsTrue(errors.Count == 1); Assert.IsTrue(valErrors.Count == 1); var s = "very long involved value"; s = s + s + s + s + s + s + s + s + s + s + s + s + s; supplier.CompanyName = s; Assert.IsTrue(errors.Count == 3); // setting the companyName will remove the requiredError but add the maxLenght error Assert.IsTrue(errors.Last().PropertyName == "CompanyName"); Assert.IsTrue(valErrors.Count == 1); Assert.IsTrue(((INotifyDataErrorInfo)supplier).HasErrors); var location = supplier.Location; location.City = s; Assert.IsTrue(errors.Last().PropertyName == "Location.City", "location.city should have been the propertyName"); Assert.IsTrue(errors.Count == 4); Assert.IsTrue((String)valErrors.Last().Context.PropertyPath == "Location.City"); Assert.IsTrue(valErrors.Count == 2); // companyName_required and location.city_maxLength Assert.IsTrue(((INotifyDataErrorInfo)supplier).HasErrors); location.City = "much shorter"; Assert.IsTrue(errors.Last().PropertyName == "Location.City", "location.city should have changed again"); Assert.IsTrue(errors.Count == 5); Assert.IsTrue(valErrors.Count == 1); Assert.IsTrue(((INotifyDataErrorInfo)supplier).HasErrors); supplier.CompanyName = "shortName"; Assert.IsTrue(errors.Count == 6); Assert.IsTrue(valErrors.Count == 0); Assert.IsTrue(((INotifyDataErrorInfo)supplier).HasErrors == false); }
public async Task SelectAnonWithScalarSelf() { Assert.Inconclusive("OData doesn't support this kind of query (I think)"); return; // Pretty sure this is an issue with OData not supporting this syntax. var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Foo.Customer>("Customers"); var q2 = q.Where(c => c.CompanyName.StartsWith("C")); var q3 = q2.Select(c => new { c.CompanyName, c }); var results = await q3.Execute(em1); Assert.IsTrue(results.Count() > 0); var ok = results.All(r1 => r1.CompanyName.Length > 0); Assert.IsTrue(ok, "anon type should have a populated company name"); ok = results.All(r1 => r1.c.GetType() == typeof(Foo.Customer)); Assert.IsTrue(ok, "anon type should have a populated 'Customer'"); }
public async Task AssignComplexObjectWithInitializer() { var em1 = await TestFns.NewEm(_serviceName); var supplier = em1.CreateEntity <Supplier>(); var initLocation = supplier.Location; supplier.Location.City = "San Francisco"; Assert.IsTrue(supplier.Location.City == "San Francisco", "city should be set"); var newLocation = new Location() { City = "Seattle", PostalCode = "11111" }; supplier.Location = newLocation; Assert.IsTrue(supplier.Location == initLocation, "location ref should not have changed"); Assert.IsTrue(supplier.Location.City == "Seattle", "city should have changed"); Assert.IsTrue(supplier.Location.ComplexAspect.Parent == supplier, "parent should be set"); Assert.IsTrue(supplier.Location.ComplexAspect.ParentEntityProperty.Name == "Location", "parentEntityProperty should be set"); }
public async Task RejectChanges() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Supplier>().Where(s => s.CompanyName.StartsWith("P")).Take(2); var suppliers = await em1.ExecuteQuery(q); Assert.IsTrue(suppliers.Count() > 0, "should be some suppliers"); var s0 = suppliers.First(); var s1 = suppliers.ElementAt(1); var origCity = s0.Location.City; s0.Location.City = "bar"; s0.Location.Country = "Foo"; Assert.IsTrue(s0.EntityAspect.EntityState.IsModified(), "should be modified"); Assert.IsTrue(s0.Location.City == "bar", "should have changed value"); s0.EntityAspect.RejectChanges(); Assert.IsTrue(s0.EntityAspect.EntityState.IsUnchanged(), "should be unchanged"); Assert.IsTrue(s0.Location.City == origCity, "should be back to original value"); }
public async Task UnattachedChildren() { var em1 = await TestFns.NewEm(_serviceName); var cust1 = new Customer(); var cust2 = new Customer(); var order1 = new Order(); cust1.CustomerID = Guid.NewGuid(); em1.AttachEntity(order1); Assert.IsTrue(order1.EntityAspect.EntityState.IsUnchanged()); order1.CustomerID = cust1.CustomerID; Assert.IsTrue(order1.EntityAspect.EntityState.IsModified()); Assert.IsTrue(order1.Customer == null, "customer should be null"); order1.EntityAspect.AcceptChanges(); Assert.IsTrue(order1.EntityAspect.EntityState.IsUnchanged()); em1.AttachEntity(cust1); Assert.IsTrue(order1.Customer == cust1, "customer should now be set"); Assert.IsTrue(order1.EntityAspect.EntityState.IsUnchanged(), "fixup should not change entityState"); }
public async Task ExpandNonScalar() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Foo.Customer>("Customers"); var q2 = q.Where(c => c.CompanyName.StartsWith("C")); var q3 = q2.Expand(c => c.Orders); var results = await q3.Execute(em1); Assert.IsTrue(results.Count() > 0); var ok = results.All(r1 => r1.GetType() == typeof(Foo.Customer) && r1.Orders.Count() > 0 && r1.Orders.All(o => o.GetType() == typeof(Foo.Order)) && r1.Orders.All(o => o.Customer == r1)); Assert.IsTrue(ok, "every Customer should contain a collection of Orders"); ok = results.All(r1 => r1.CompanyName.Length > 0); Assert.IsTrue(ok, "and should have a populated company name"); }
public async Task AttachEmViaDetach() { var em1 = await TestFns.NewEm(_serviceName); var cust = new Customer(); cust.EntityAspect.SetValue(TestFns.CustomerKeyName, Guid.NewGuid()); Assert.IsTrue(cust.EntityAspect.IsDetached, "should be detached"); em1.AttachEntity(cust); Assert.IsTrue(cust.EntityAspect.IsAttached, "should be attached"); em1.Clear(); // will detach cust Assert.IsTrue(cust.EntityAspect.IsDetached, "should be detached - again"); Assert.IsTrue(cust.EntityAspect.EntityManager == em1, "should still be associated with em1"); // therefore this should be ok var em2 = new EntityManager(em1); em2.AttachEntity(cust); Assert.IsTrue(cust.EntityAspect.EntityManager == em2, "should be on em2"); }
public async Task CustomPropertyValidator() { var em1 = await TestFns.NewEm(_serviceName); var custType = MetadataStore.Instance.GetEntityType(typeof(Customer)); var countryProp = custType.GetDataProperty("Country"); try { countryProp.Validators.Add(new CountryIsUsValidator()); var cust = new Customer(); var valErrors = cust.EntityAspect.ValidationErrors; Assert.IsTrue(valErrors.Count == 0); cust.CompanyName = "Test"; cust.Country = "Germany"; em1.AttachEntity(cust); Assert.IsTrue(valErrors.Count == 1); Assert.IsTrue(valErrors.First().Message.Contains("must start with")); } finally { countryProp.Validators.Remove(new CountryIsUsValidator()); } }
public async Task UnidirectionalAttach1ToN() { var em1 = await TestFns.NewEm(_serviceName); if (TestFns.DEBUG_MONGO || TestFns.DEBUG_ODATA) { Assert.Inconclusive("NA for Mongo or OData - TimeList and Timegroup not yet added"); } var tl1 = em1.CreateEntity <TimeLimit>(); var tl2 = em1.CreateEntity <TimeLimit>(); var tg1 = em1.CreateEntity <TimeGroup>(); var id1 = tg1.Id; tl1.TimeGroupId = id1; Assert.IsTrue(tg1.TimeLimits.Count == 1 && tg1.TimeLimits.Contains(tl1), "should be connected"); tl2.TimeGroupId = id1; Assert.IsTrue(tg1.TimeLimits.Count == 2 && tg1.TimeLimits.Contains(tl2), "another should be connected"); }
public async Task ErrorOnNavAttach() { var em1 = await TestFns.NewEm(_serviceName); var order = em1.CreateEntity <Order>(EntityState.Unchanged); var em2 = new EntityManager(em1); var cust = em2.CreateEntity <Customer>(EntityState.Unchanged); Assert.IsTrue(order.EntityAspect.EntityManager != cust.EntityAspect.EntityManager, "should not be the same manager"); try { order.Customer = cust; Assert.Fail("should not get here"); } catch (Exception e) { Assert.IsTrue(e.Message.Contains("EntityManager"), "message should mention 'EntityManager'"); } cust.EntityAspect.Detach(); order.Customer = cust; Assert.IsTrue(order.EntityAspect.EntityManager == cust.EntityAspect.EntityManager, "should be the same manager"); Assert.IsTrue(cust.Orders.Contains(order) && order.Customer == cust, "should be properly connected"); }
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 AssignComplexObject() { var em1 = await TestFns.NewEm(_serviceName); var supplier = em1.CreateEntity <Supplier>(); // set in ctor. Assert.IsTrue(supplier.Location.Country == "USA", "Country should be set"); var initLocation = supplier.Location; supplier.Location.City = "San Francisco"; Assert.IsTrue(supplier.Location.City == "San Francisco", "city should be set"); var newLocation = new Location(); newLocation.City = "Seatle"; supplier.Location = newLocation; Assert.IsTrue(supplier.Location == initLocation, "location ref should not have changed"); Assert.IsTrue(supplier.Location.City == "Seatle", "city should have changed"); Assert.IsTrue(supplier.Location.ComplexAspect.Parent == supplier, "parent should be set"); Assert.IsTrue(supplier.Location.ComplexAspect.ParentEntityProperty.Name == "Location", "parentEntityProperty should be set"); }
public async Task SingleConditions() { try { var entityManager = await TestFns.NewEm(_serviceName); var query0 = new EntityQuery <OrderDetail>().Where(od => od.Quantity > 3); var orderDetails = await entityManager.ExecuteQuery(query0); Assert.IsTrue(orderDetails.Any(), "There should be orders with freight cost > 100"); // 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 AttachDetachOriginalValues() { var em1 = await TestFns.NewEm(_serviceName); var cust1 = new Customer() { CustomerID = Guid.NewGuid() }; em1.AttachEntity(cust1); cust1.ContactName = "original contact name"; cust1.EntityAspect.AcceptChanges(); Assert.IsTrue(cust1.EntityAspect.IsAttached && cust1.EntityAspect.EntityState.IsUnchanged()); cust1.ContactName = "new contact name"; Assert.IsTrue(cust1.EntityAspect.IsAttached && cust1.EntityAspect.EntityState.IsModified()); em1.DetachEntity(cust1); Assert.IsTrue(cust1.EntityAspect.IsDetached); Assert.IsTrue(cust1.ContactName == "new contact name"); em1.AttachEntity(cust1, EntityState.Modified); Assert.IsTrue(cust1.ContactName == "new contact name"); Assert.IsTrue(cust1.EntityAspect.IsAttached && cust1.EntityAspect.EntityState.IsModified()); cust1.EntityAspect.RejectChanges(); Assert.IsTrue(cust1.EntityAspect.IsAttached && cust1.EntityAspect.EntityState.IsUnchanged()); Assert.IsTrue(cust1.ContactName == "original contact name"); cust1.ContactName = "new foo"; Assert.IsTrue(cust1.EntityAspect.IsAttached && cust1.EntityAspect.EntityState.IsModified()); em1.DetachEntity(cust1); Assert.IsTrue(cust1.EntityAspect.IsDetached); Assert.IsTrue(cust1.ContactName == "new foo"); em1.AttachEntity(cust1); Assert.IsTrue(cust1.ContactName == "new foo"); Assert.IsTrue(cust1.EntityAspect.IsAttached && cust1.EntityAspect.EntityState.IsUnchanged()); Assert.IsTrue(cust1.EntityAspect.OriginalValuesMap.Count == 0); cust1.EntityAspect.RejectChanges(); Assert.IsTrue(cust1.ContactName == "new foo"); Assert.IsTrue(cust1.EntityAspect.IsAttached && cust1.EntityAspect.EntityState.IsUnchanged()); }
public async Task RejectChangesAfterSave() { var em1 = await TestFns.NewEm(_serviceName); var supplier = new Supplier(); em1.AddEntity(supplier); supplier.CompanyName = "Test_" + TestFns.RandomSuffix(10); supplier.Location.City = "LA"; var sr1 = await em1.SaveChanges(); Assert.IsTrue(sr1.Entities.Count == 1); Assert.IsTrue(supplier.Location.City == "LA"); var r1 = await supplier.EntityAspect.EntityKey.ToQuery <Supplier>().Execute(em1); Assert.IsTrue(r1.Count() == 1); Assert.IsTrue(r1.First() == supplier); supplier.Location.City = "Fooo"; Assert.IsTrue(supplier.EntityAspect.HasChanges()); supplier.EntityAspect.RejectChanges(); Assert.IsTrue(supplier.Location.City == "LA"); }
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 InternValidators() { var em1 = await TestFns.NewEm(_serviceName); var vr2 = new RequiredValidator().Intern(); var vr3 = new RequiredValidator().Intern(); Assert.IsTrue(vr2 == vr3); Assert.IsTrue(vr2.Equals(vr3)); var mlVr2 = new MaxLengthValidator(17).Intern(); var mlVr3 = new MaxLengthValidator(17).Intern(); Assert.IsTrue(mlVr2 == mlVr3); Assert.IsTrue(mlVr2.Equals(mlVr3)); var slVr2 = new StringLengthValidator(3, 12).Intern(); var slVr3 = new StringLengthValidator(3, 12).Intern(); Assert.IsTrue(slVr2 == slVr3); Assert.IsTrue(slVr2.Equals(slVr3)); }
public async Task IEditableObjectNeverAttached() { var em1 = await TestFns.NewEm(_serviceName); var customer = new Customer(); Assert.IsTrue(customer.EntityAspect.EntityState.IsDetached()); ((IEditableObject)customer).BeginEdit(); try { customer.City = "Foo"; } finally { ((IEditableObject)customer).EndEdit(); } Assert.IsTrue(customer.City == "Foo"); ((IEditableObject)customer).BeginEdit(); try { customer.City = "Bar"; } finally { ((IEditableObject)customer).CancelEdit(); } Assert.IsTrue(customer.City == "Foo"); }
public async Task ExceptionThrownOnServer() { var em1 = await TestFns.NewEm(_serviceName); // ok(true, "Skipped test - OData does not support server interception or alt resources"); var q = new EntityQuery <Order>().Take(1); var orders = await em1.ExecuteQuery(q); var order = orders.First(); order.Freight = order.Freight + .5m; var so = new SaveOptions("SaveAndThrow", tag: "SaveAndThrow"); try { var sr = await em1.SaveChanges(null, so); Assert.Fail("should not get here"); } catch (SaveException se) { Assert.IsTrue(se.Message.Contains("Deliberately thrown"), "message should be correct"); } }
public async Task PartialSave() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Customer>("Customers").Where(c => c.CompanyName.StartsWith("A")); var custsx = await q.Execute(em1); var custs = custsx.ToList(); 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(new IEntity[] { custs[0], cust1, order1 }); Assert.IsTrue(custs[1].EntityAspect.EntityState.IsModified()); Assert.IsTrue(saveResult.Entities.Count == 3, "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(), "hasChanges should be true"); Assert.IsTrue(em1.GetChanges().Count() == custs.Count - 1, "should be some changes left"); }