public async Task IEditableObjectAttachedUnchanged() { var em1 = await TestFns.NewEm(_serviceName); var customer = new Customer(); em1.AttachEntity(customer); Assert.IsTrue(customer.EntityAspect.EntityState.IsUnchanged()); ((IEditableObject)customer).BeginEdit(); try { customer.City = "Foo"; Assert.IsTrue(customer.EntityAspect.EntityState.IsModified()); } finally { ((IEditableObject)customer).EndEdit(); } Assert.IsTrue(customer.City == "Foo"); Assert.IsTrue(customer.EntityAspect.EntityState.IsModified()); customer.EntityAspect.AcceptChanges(); Assert.IsTrue(customer.EntityAspect.EntityState.IsUnchanged()); ((IEditableObject)customer).BeginEdit(); try { customer.City = "Bar"; Assert.IsTrue(customer.EntityAspect.EntityState.IsModified()); } finally { ((IEditableObject)customer).CancelEdit(); } Assert.IsTrue(customer.City == "Foo"); Assert.IsTrue(customer.EntityAspect.EntityState.IsUnchanged()); }
public async Task RejectChangesValidationFixup() { var em1 = await TestFns.NewEm(_serviceName); var cust1 = new Customer(); em1.AttachEntity(cust1); Assert.IsTrue(cust1.EntityAspect.ValidationErrors.Count == 1); cust1.CompanyName = "valid name"; Assert.IsTrue(cust1.EntityAspect.ValidationErrors.Count == 0); cust1.EntityAspect.RejectChanges(); Assert.IsTrue(cust1.EntityAspect.ValidationErrors.Count == 1); }
public async Task IEditableObjectNeverAttached() { await _emTask; 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 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 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 AddToNavSet() { await _emTask; 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 UnattachedChildren() { await _emTask; 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 CustomRegexValidator() { var em1 = await TestFns.NewEm(_serviceName); var custType = em1.MetadataStore.GetEntityType(typeof(Customer)); var validator = new RegexValidator("^[A-Z]{2}$", "US State"); var validators = custType.GetDataProperty("Address").Validators; try { validators.Add(validator); var cust = new Customer() { CompanyName = "Foo" }; em1.AddEntity(cust); var valErrors = cust.EntityAspect.ValidationErrors; CustPropValAssert(cust, "asdf", 1); Assert.IsTrue(valErrors.First().Message.Contains("US State")); CustPropValAssert(cust, "Pennsylvania 6500", 1); CustPropValAssert(cust, "5", 1); // missing '.com' CustPropValAssert(cust, "Ab", 1); // b is lowercase CustPropValAssert(cust, null, 0); CustPropValAssert(cust, "CA", 0); CustPropValAssert(cust, "AZ", 0); CustPropValAssert(cust, "WY", 0); } finally { validators.Remove(validator); } }
public async Task EmailValidator2() { var em1 = await TestFns.NewEm(_serviceName); var custType = em1.MetadataStore.GetEntityType(typeof(Customer)); var validator = new EmailValidator("special email type"); var validators = custType.GetDataProperty("Address").Validators; try { validators.Add(validator); var cust = new Customer() { CompanyName = "Foo" }; em1.AddEntity(cust); var valErrors = cust.EntityAspect.ValidationErrors; CustPropValAssert(cust, "asdf", 1); Assert.IsTrue(valErrors.First().Message.Contains("special email type")); CustPropValAssert(cust, "1234567", 1); CustPropValAssert(cust, "john.doe@abc", 1); // missing '.com' CustPropValAssert(cust, null, 0); CustPropValAssert(cust, "*****@*****.**", 0); } finally { validators.Remove(validator); } }
public async Task CustomPropertyValidator() { var em1 = await TestFns.NewEm(_serviceName); var custType = em1.MetadataStore.GetEntityType(typeof (Customer)); var countryProp = custType.GetDataProperty("Country"); try { countryProp.Validators.Add(new CountryValidator("US")); 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 CountryValidator("US")); } }
public async Task AddToNavCollection() { await _emTask; var cust1 = new Customer(); var order1 = new Order(); _em1.AttachEntity(cust1, EntityState.Added); Assert.IsTrue(cust1.EntityAspect.HasTemporaryKey, "should have a temp key"); var orders = cust1.Orders; Assert.IsTrue(orders.ParentEntity == cust1, "ParentEntity should be set"); Assert.IsTrue(orders.NavigationProperty == cust1.EntityAspect.EntityType.GetNavigationProperty("Orders"), "NavProperty should be set"); NotifyCollectionChangedEventArgs changeArgs = null; orders.CollectionChanged += (s, e) => { changeArgs = e; }; orders.Add(order1); Assert.IsTrue(order1.EntityAspect.EntityState.IsAdded(), "should be added"); Assert.IsTrue(orders.Contains(order1), "should contain order"); Assert.IsTrue(order1.Customer == cust1, "should be connected"); Assert.IsTrue(changeArgs != null, "changeArgs should not be null"); Assert.IsTrue(changeArgs.Action == NotifyCollectionChangedAction.Add); Assert.IsTrue(changeArgs.NewItems.Contains(order1), "change should mention order1"); }
public async Task AttachEmViaDetach() { await _emTask; 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 DeleteFromNavCollection() { var em1 = await TestFns.NewEm(_serviceName); var cust1 = new Customer(); var order1 = new Order(); var order2 = new Order(); em1.AddEntity(cust1); var orders = cust1.Orders; orders.Add(order1); orders.Add(order2); em1.AcceptChanges(); var collectionChangedList = new List<NotifyCollectionChangedEventArgs>(); orders.CollectionChanged += (s, e) => { collectionChangedList.Add(e); }; var propChangedList = new List<PropertyChangedEventArgs>(); ((INotifyPropertyChanged)order1).PropertyChanged += (s, e) => { propChangedList.Add(e); }; var entityChangedList = new List<EntityChangedEventArgs>(); em1.EntityChanged += (s, e) => { entityChangedList.Add(e); }; order1.EntityAspect.Delete(); Assert.IsTrue(collectionChangedList.Last().Action == NotifyCollectionChangedAction.Remove, "should have removed from collection"); Assert.IsTrue(collectionChangedList.Last().OldItems.Contains(order1), "change event should contain order1"); //Assert.IsTrue(propChangedList.Count == 0, "Deleting an entity will not create a propertyChange event"); Assert.IsTrue(!orders.Contains(order1), "order1 should have been removed"); Assert.IsTrue(order1.Customer == null, "Customer should be null"); Assert.IsTrue(order1.CustomerID == cust1.CustomerID, "customerID should NOT be cleared when detached - just the Customer"); Assert.IsTrue(order1.EntityAspect.EntityState.IsDeleted(), "state should be deleted"); Assert.IsTrue(orders.Count == 1, "count should be 1"); collectionChangedList.Clear(); propChangedList.Clear(); order1.EntityAspect.RejectChanges(); Assert.IsTrue(collectionChangedList.Last().Action == NotifyCollectionChangedAction.Add, "should have added to collection"); Assert.IsTrue(collectionChangedList.Last().NewItems.Contains(order1), "change event should contain order1"); Assert.IsTrue(propChangedList.Any(args => args.PropertyName == "Customer"), "propChange should mention Customer"); // Not needed because CustomerID is not cleared. // Assert.IsTrue(propChangedList.Any(args => args.PropertyName == "CustomerID"), "propChange should mention CustomerID"); Assert.IsTrue(orders.Contains(order1), "order1 should be back"); Assert.IsTrue(order1.Customer == cust1, "Customer should be back"); Assert.IsTrue(order1.CustomerID == cust1.CustomerID, "CustomerID should not have changed"); // null because not required. Assert.IsTrue(order1.EntityAspect.EntityState.IsUnchanged(), "State should be unchanged but is " + order1.EntityAspect.EntityState); Assert.IsTrue(orders.Count == 2, "count should be 2"); }
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 AttachDetachReattachNavProps() { var em1 = await TestFns.NewEm(_serviceName); var cust1 = new Customer() { CustomerID = Guid.NewGuid() }; em1.AttachEntity(cust1); var cust2 = new Customer() { CustomerID = Guid.NewGuid() }; em1.AttachEntity(cust2); var order = em1.CreateEntity<Order>(null, EntityState.Unchanged); Assert.IsTrue(order.EntityAspect.IsAttached && order.EntityAspect.EntityState.IsUnchanged()); cust1.Orders.Add(order); Assert.IsTrue(order.Customer == cust1); Assert.IsTrue(order.EntityAspect.IsAttached && order.EntityAspect.EntityState.IsModified()); em1.DetachEntity(order); Assert.IsTrue(order.EntityAspect.IsDetached); Assert.IsTrue(order.Customer == null); em1.AttachEntity(order); Assert.IsTrue(order.Customer == cust1); Assert.IsTrue(order.EntityAspect.IsAttached && order.EntityAspect.EntityState.IsUnchanged()); }
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 ExpImpDeleted() { var em1 = await TestFns.NewEm(_serviceName); var c1 = new Customer() { CompanyName = "Test_1", City = "Oakland", RowVersion = 13, Fax = "510 999-9999" }; var c2 = new Customer() { CompanyName = "Test_2", City = "Oakland", RowVersion = 13, Fax = "510 999-9999" }; em1.AddEntity(c1); em1.AddEntity(c2); var sr = await em1.SaveChanges(); Assert.IsTrue(sr.Entities.Count == 2); c1.EntityAspect.Delete(); c2.CompanyName = TestFns.MorphString(c2.CompanyName); var exportedEntities = em1.ExportEntities(null, false); var em2 = new EntityManager(em1); em2.ImportEntities(exportedEntities); var c1x = em2.FindEntityByKey<Customer>(c1.EntityAspect.EntityKey); Assert.IsTrue(c1x.EntityAspect.EntityState.IsDeleted(), "should be deleted"); var c2x = em2.FindEntityByKey<Customer>(c2.EntityAspect.EntityKey); Assert.IsTrue(c2x.CompanyName == c2.CompanyName, "company names should match"); }
public async Task DetachFromNavCollection() { await _emTask; var cust1 = new Customer(); var order1 = new Order(); var order2 = new Order(); _em1.AddEntity(cust1); var orders = cust1.Orders; orders.Add(order1); orders.Add(order2); var collectionChangedList = new List<NotifyCollectionChangedEventArgs>(); orders.CollectionChanged += (s, e) => { collectionChangedList.Add(e); }; var propChangedList = new List<PropertyChangedEventArgs>(); ((INotifyPropertyChanged)order1).PropertyChanged += (s, e) => { propChangedList.Add(e); }; order1.EntityAspect.Detach(); Assert.IsTrue(collectionChangedList.Last().Action == NotifyCollectionChangedAction.Remove); Assert.IsTrue(collectionChangedList.Last().OldItems.Contains(order1), "change event should contain order1"); Assert.IsTrue(propChangedList.Count == 0, "Detaching an entity will not create a propertyChange event"); Assert.IsTrue(!orders.Contains(order1), "order1 should have been removed"); Assert.IsTrue(order1.Customer == null, "Customer should be null"); Assert.IsTrue(order1.CustomerID == null); // null because not required. Assert.IsTrue(order1.EntityAspect.EntityState.IsDetached()); Assert.IsTrue(orders.Count == 1, "count should be 1"); collectionChangedList.Clear(); propChangedList.Clear(); order1.Customer = cust1; Assert.IsTrue(collectionChangedList.Last().Action == NotifyCollectionChangedAction.Add); Assert.IsTrue(collectionChangedList.Last().NewItems.Contains(order1), "change event should contain order1"); // Assert.IsTrue(propChangedList.Any(args => args.PropertyName == "Customer"), "propChange should mention Customer"); Assert.IsTrue(propChangedList.Any(args => args.PropertyName == "CustomerID"), "propChange should mention CustomerID"); Assert.IsTrue(orders.Contains(order1), "order1 should be back"); Assert.IsTrue(order1.Customer == cust1, "Customer should be back"); Assert.IsTrue(order1.CustomerID == cust1.CustomerID, "CustomerID should be back"); // null because not required. Assert.IsTrue(order1.EntityAspect.EntityState.IsAdded()); Assert.IsTrue(orders.Count == 2, "count should be 2"); }
private TwoCusts CreateParentAndChildren(EntityManager em) { var cust1 = new Customer(); cust1.CompanyName = "Test1_" + TestFns.RandomSuffix(8); cust1.City = "Oakland"; cust1.RowVersion = 13; cust1.Fax = "510 999-9999"; em.AddEntity(cust1); var cust2 = em.CreateEntity<Customer>(); cust2.CompanyName = "Test2_" + TestFns.RandomSuffix(8); cust2.City = "Emeryville"; cust2.RowVersion = 1; cust2.Fax = "510 888-8888"; var order1 = new Order(); order1.OrderDate = DateTime.Today; var order2 = em.CreateEntity<Order>(); order1.OrderDate = DateTime.Today; cust1.Orders.Add(order1); cust1.Orders.Add(order2); Assert.IsTrue(cust1.Orders.Count == 2); Assert.IsTrue(cust2.Orders.Count == 0); return new TwoCusts() { Cust1 = cust1, Cust2 = cust2 }; }
public async Task ChangeParent1ToN() { await _emTask; var cust1 = new Customer(); var cust2 = new Customer(); var order1 = new Order(); var order2 = new Order(); _em1.AddEntity(cust1); _em1.AddEntity(cust2); cust1.Orders.Add(order1); cust1.Orders.Add(order2); var cust1CollChangedList = new List<NotifyCollectionChangedEventArgs>(); cust1.Orders.CollectionChanged += (s, e) => { cust1CollChangedList.Add(e); }; var cust2CollChangedList = new List<NotifyCollectionChangedEventArgs>(); cust2.Orders.CollectionChanged += (s, e) => { cust2CollChangedList.Add(e); }; var propChangedList = new List<PropertyChangedEventArgs>(); ((INotifyPropertyChanged)order1).PropertyChanged += (s, e) => { propChangedList.Add(e); }; // move order cust2.Orders.Add(order1); Assert.IsTrue(cust1CollChangedList.Last().Action == NotifyCollectionChangedAction.Remove); Assert.IsTrue(cust1CollChangedList.Last().OldItems.Contains(order1), "change event should contain order1"); Assert.IsTrue(cust2CollChangedList.Last().Action == NotifyCollectionChangedAction.Add); Assert.IsTrue(cust2CollChangedList.Last().NewItems.Contains(order1), "change event should contain order1"); // TODO: this is not yet happening but it should // Assert.IsTrue(propChangedList.Any(args => args.PropertyName == "Customer"), "propChange should mention Customer"); Assert.IsTrue(propChangedList.Any(args => args.PropertyName == "CustomerID"), "propChange should mention CustomerID"); Assert.IsTrue(!cust1.Orders.Contains(order1), "order1 should have been removed"); Assert.IsTrue(cust2.Orders.Contains(order1), "order1 should have been removed"); Assert.IsTrue(order1.Customer == cust2, "Customer should be cust2"); Assert.IsTrue(order1.CustomerID == cust2.CustomerID, "CustomerID should be cust2's id"); Assert.IsTrue(order1.EntityAspect.EntityState.IsAdded()); Assert.IsTrue(cust1.Orders.Count == cust2.Orders.Count, "count should be 1"); cust1CollChangedList.Clear(); cust2CollChangedList.Clear(); propChangedList.Clear(); order1.Customer = cust1; Assert.IsTrue(cust1CollChangedList.Last().Action == NotifyCollectionChangedAction.Add); Assert.IsTrue(cust1CollChangedList.Last().NewItems.Contains(order1), "change event should contain order1"); // Assert.IsTrue(propChangedList.Any(args => args.PropertyName == "Customer"), "propChange should mention Customer"); Assert.IsTrue(propChangedList.Any(args => args.PropertyName == "CustomerID"), "propChange should mention CustomerID"); Assert.IsTrue(cust1.Orders.Count == 2, "count should be 2"); }
private void CustPropValAssert(Customer cust, String propValue, int count) { var valErrors = cust.EntityAspect.ValidationErrors; cust.Address = propValue; if (valErrors.Count > 0) { var msg = valErrors.First().Message; Assert.IsTrue(msg.Contains("Address")); } Assert.IsTrue(valErrors.Count == count, "expected " + count + " but got: " + valErrors.Count); }
public async Task GraphAttachChild() { await _emTask; var cust1 = new Customer(); // this test will fail if we don't give the customer a new Guid cust1.CustomerID = Guid.NewGuid(); var order1 = new Order(); order1.Customer = cust1; _em1.AddEntity(order1); Assert.IsTrue(order1.EntityAspect.EntityState.IsAdded()); Assert.IsTrue(cust1.EntityAspect.EntityState.IsAdded()); var orders = cust1.Orders; Assert.IsTrue(orders.Contains(order1) , "should contain order1"); Assert.IsTrue(order1.Customer == cust1, "Customer should be cust2"); Assert.IsTrue(order1.CustomerID == cust1.CustomerID, "CustomerID should be cust2's id"); }
public async Task PhoneValidator() { var em1 = await TestFns.NewEm(_serviceName); var custType = em1.MetadataStore.GetEntityType(typeof(Customer)); var validator = new PhoneNumberValidator(); var validators = custType.GetDataProperty("Address").Validators; try { validators.Add(validator); var cust = new Customer() { CompanyName = "Foo" }; em1.AddEntity(cust); var valErrors = cust.EntityAspect.ValidationErrors; CustPropValAssert(cust, "asdf", 1); Assert.IsTrue(valErrors.First().Message.Contains("phone number")); CustPropValAssert(cust, "Pennsylvania 6500", 1); CustPropValAssert(cust, "5", 1); // missing '.com' CustPropValAssert(cust, null, 0); CustPropValAssert(cust, "(510) 686-8275", 0); CustPropValAssert(cust, "01 510 686-8275", 0); CustPropValAssert(cust, "+1 510 686-8275", 0); // // these pass too. You might not expect that CustPropValAssert(cust, "51", 0); CustPropValAssert(cust, "1234567", 0); CustPropValAssert(cust, "12345678901234567890123456789", 0); } finally { validators.Remove(validator); } }
public async Task GraphAttachParent() { await _emTask; 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 UrlValidator() { var em1 = await TestFns.NewEm(_serviceName); var custType = em1.MetadataStore.GetEntityType(typeof(Customer)); var validator = new UrlValidator(null, UrlOptions.RequireProtocol); var validators = custType.GetDataProperty("Address").Validators; try { validators.Add(validator); var cust = new Customer() { CompanyName = "Foo" }; em1.AddEntity(cust); var valErrors = cust.EntityAspect.ValidationErrors; CustPropValAssert(cust, "asdf", 1); Assert.IsTrue(valErrors.First().Message.Contains("url")); CustPropValAssert(cust, "Pennsylvania 6500", 1); CustPropValAssert(cust, "1234567", 1); CustPropValAssert(cust, "traband.contuso.com", 1); // protocol missing CustPropValAssert(cust, null, 0); CustPropValAssert(cust, "http://traband", 0); CustPropValAssert(cust, "http://traband.contoso.com", 0); CustPropValAssert(cust, "https://traband.contoso.com", 0); CustPropValAssert(cust, "ftp://traband.contoso.com", 0); CustPropValAssert(cust, "http://traband.contoso.commiepinko", 0); } finally { validators.Remove(validator); } }
public async Task DuplicateKeysError() { await _emTask; var cust1 = new Customer(); var cust2 = new Customer(); _em1.AttachEntity(cust1); try { cust2.CustomerID = cust1.CustomerID; _em1.AttachEntity(cust2); Assert.Fail("should not get here"); } catch (Exception e) { Assert.IsTrue(e.Message.Contains("key"), "message should mention 'key'"); } }