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 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 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 WhereEntityKey() { 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 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(em1.MetadataStore); 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 WhereOrderByPropertyPath() { var em1 = await TestFns.NewEm(_serviceName); // Products sorted by their Category names (in descending order) var query1 = EntityQuery.From <Product>() .OrderByDescending(p => p.Category.CategoryName); var r1 = await query1.Execute(em1); Assert.IsTrue(r1.Any()); // Products sorted by their Category names, then by Product name (in descending order) var query2 = EntityQuery.From <Product>() .OrderBy(p => p.Category.CategoryName) .ThenByDescending(p => p.ProductName); var r2 = await query2.Execute(em1); Assert.IsTrue(r2.Any()); }
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 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"); }
// [TestMethod] // This test can only be run standalone because of the __Reset call 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, "metadata should match between export and import"); }
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 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 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"); }
// [TestMethod] // This test can only be run standalone because of the __Reset call public async Task ExpMetadata() { var em1 = await TestFns.NewEm(_serviceName); var metadata = em1.MetadataStore.ExportMetadata(); File.WriteAllText("c:/temp/metadata.txt", metadata); var ms = Configuration.Instance; Assert.IsTrue(ms != Configuration.Instance); var ms2 = new MetadataStore(); ms2.ImportMetadata(metadata); var metadata2 = ms2.ExportMetadata(); File.WriteAllText("c:/temp/metadata2.txt", metadata2); Assert.IsTrue(metadata == metadata2, "metadata should match between export and import"); }
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 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 LookupsScalar() { var entityManager = await TestFns.NewEm(_serviceName); var query = EntityQuery.From("Lookups", new { Regions = Enumerable.Empty <Region>(), Territories = Enumerable.Empty <Territory>(), Categories = Enumerable.Empty <Category>(), }); //var query = EntityQuery.From("Lookups", new { // regions = new List<Region>(), // territories = new List<Territory>(), // categories = new List<Category>() //}); var data = await query.Execute(entityManager); Assert.IsTrue(data.Count() == 1, "Lookups query should return single item"); var lookups = data.First(); }
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 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 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 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 ExpandScalar() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Foo.Order>("Orders"); var q2 = q.Where(o => o.Freight > 500); var q3 = q2.Expand(o => o.Customer); var results = await q3.Execute(em1); // get rid of orders with null customers results = results.Where(r => r.Customer != null); Assert.IsTrue(results.Any()); var ok = results.All(r1 => r1.GetType() == typeof(Foo.Order) && r1.Customer.GetType() == typeof(Foo.Customer)); Assert.IsTrue(ok, "every Order should have a customer"); ok = results.All(r1 => r1.Freight > 500); Assert.IsTrue(ok, "and should have the right freight"); }
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 CustomersWithHttpError() { var em1 = await TestFns.NewEm(_serviceName); var q = new EntityQuery <Customer>("CustomersWithHttpError"); var rp = q.GetResourcePath(em1.MetadataStore); try { var results = await q.Execute(em1); Assert.Fail("shouldn't get here"); } catch (DataServiceRequestException e) { Assert.IsTrue(e.ResponseContent.Contains("Custom error message")); Assert.IsTrue(e.Message.ToLower().Contains("custom reason")); } catch (HttpRequestException) { Assert.Fail("should not get here"); } }
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 ErrorOnNavAttach() { var em1 = await TestFns.NewEm(_serviceName); var order = em1.CreateEntity <Order>(null, EntityState.Unchanged); var em2 = new EntityManager(em1); var cust = em2.CreateEntity <Customer>(null, 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 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 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 FkSetToNull() { var em1 = await TestFns.NewEm(_serviceName); var cust = em1.CreateEntity <Customer>(entityState: EntityState.Unchanged); var order1 = em1.CreateEntity <Order>(); order1.Customer = cust; Assert.IsTrue(order1.Customer == cust, "should be customer"); Assert.IsTrue(cust.Orders.Contains(order1), "should contain order1"); var order2 = new Order(); order2.Customer = cust; Assert.IsTrue(order2.EntityAspect.IsAttached && order2.EntityAspect.EntityState.IsAdded()); Assert.IsTrue(order2.Customer == cust, "should be customer - again"); Assert.IsTrue(cust.Orders.Contains(order2), "should contain order2"); order1.CustomerID = null; Assert.IsTrue(order1.Customer == null, "should be null"); Assert.IsTrue(!cust.Orders.Contains(order1), "should not contain order1"); }
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 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"); }