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