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