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