public async Task SaveCustomersAndNewOrder() {
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery<Customer>("Customers").Where(c => c.CompanyName.StartsWith("A"));
var custs = await q.Execute(em1);
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();
Assert.IsTrue(saveResult.Entities.Count == custs.Count() + 2, "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() == false, "hasChanges should be false");
Assert.IsTrue(em1.GetChanges().Count() == 0, "should be no changes left");
}
public async Task NullForeignKey() {
await _emTask;
var prod1 = new Product();
_em1.AttachEntity(prod1);
prod1.ProductName = "Test";
prod1.SupplierID = null;
var q0 = new EntityQuery<Product>().Where(p => p.Supplier != null).Take(2).Expand(p => p.Supplier);
var r0 = (await q0.Execute(_em1)).ToList();
Assert.IsTrue(r0.Count() == 2);
Assert.IsTrue(r0.All(p => p.Supplier != null));
var p0 = r0[0];
var p1 = r0[1];
var s0 = p0.Supplier;
var s1 = p1.Supplier;
Assert.IsTrue(s0.Products.Contains(p0));
p0.Supplier = null;
Assert.IsTrue(p0.SupplierID == null);
Assert.IsTrue(!s0.Products.Contains(p0));
Assert.IsTrue(s1.Products.Contains(p1));
p1.SupplierID = null;
Assert.IsTrue(p1.Supplier == null);
Assert.IsTrue(!s1.Products.Contains(p1));
}
public async Task CustomersStartingWith() {
await _emTask;
var q = new EntityQuery<Customer>("CustomersStartingWith").WithParameter("companyName", "A");
var rp = q.GetResourcePath();
var customers = await q.Execute(_em1);
Assert.IsTrue(customers.Count() > 0, "should be some results");
Assert.IsTrue(customers.All(c => c.CompanyName.StartsWith("A")));
}
public async Task LoadNavigationPropertyNonscalar() {
var em1 = await TestFns.NewEm(_serviceName);
TestFns.RunInWpfSyncContext( async () => {
var q0 = new EntityQuery<Customer>().Where(c => c.Orders.Any()).Take(3);
var r0 = await q0.Execute(em1);
// Task.WaitAll(r0.Select(c => c.EntityAspect.LoadNavigationProperty("Orders")).ToArray());
await Task.WhenAll(r0.Select(c => c.EntityAspect.LoadNavigationProperty("Orders")));
Assert.IsTrue(r0.All(c => c.Orders.Count() > 0));
});
}
public async Task CustomersStartingWith() {
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery<Customer>("CustomersStartingWith").WithParameter("companyName", "A");
var rp = q.GetResourcePath(em1.MetadataStore);
var customers = await q.Execute(em1);
Assert.IsTrue(customers.Count() > 0, "should be some results");
Assert.IsTrue(customers.All(c => c.CompanyName.StartsWith("A")));
}
public async Task NestedExpand()
{
var em1 = await TestFns.NewEm(_serviceName);
var q0 = new EntityQuery <OrderDetail>().Take(5).Expand(od => od.Order.Customer);
var r0 = await q0.Execute(em1);
Assert.IsTrue(r0.Count() > 0, "should have returned some orderDetails");
Assert.IsTrue(r0.All(od => od.Order != null && od.Order.Customer != null));
}
public async Task ExpandNested3Levels()
{
var em1 = await TestFns.NewEm(_serviceName);
var q0 = new EntityQuery <Order>().Take(5).Expand("OrderDetails.Product.Category");
var r0 = await q0.Execute(em1);
Assert.IsTrue(r0.Count() > 0, "should have returned some orders");
Assert.IsTrue(r0.All(o => o.OrderDetails.Any(od => od.Product.Category != null)));
}
public async Task WhereAnyNested()
{
var em1 = await TestFns.NewEm(_serviceName);
var query1 = new EntityQuery <Customer>()
.Where(c => c.Orders.Any(o => o.OrderDetails.All(od => od.UnitPrice > 200)));
var results = await query1.Execute(em1);
Assert.IsTrue(results.Any());
}
public async Task CustomersStartingWith()
{
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery <Customer>("CustomersStartingWith").WithParameter("companyName", "A");
var rp = q.GetResourcePath();
var customers = await q.Execute(em1);
Assert.IsTrue(customers.Count() > 0, "should be some results");
Assert.IsTrue(customers.All(c => c.CompanyName.StartsWith("A")));
}
public async Task SimpleAnonEntityCollectionSelect() {
await _emTask;
var q1 = new EntityQuery<Customer>().Where(c => c.CompanyName.StartsWith("C")).Select(c => new { c.Orders });
var r1 = await q1.Execute(_em1);
Assert.IsTrue(r1.Count() > 0);
var ok = r1.All(r => r.Orders.Count() > 0);
Assert.IsTrue(ok);
}
public async Task SimpleSelect2() {
await _emTask;
var q1 = new EntityQuery<Customer>().Where(c => c.CompanyName.StartsWith("C")).Expand("Orders").Select(c => c.Orders);
var r1 = await q1.Execute(_em1);
Assert.IsTrue(r1.Count() > 0);
//var ok = r1.All(c => c.GetType() == typeof(Customer));
//Assert.IsTrue(ok);
}
public async Task SimpleSelect() {
await _emTask;
var q1 = new EntityQuery<Order>().Select(o => o.Customer).Take(5);
var r1 = await q1.Execute(_em1);
Assert.IsTrue(r1.Count() == 5);
var ok = r1.All(c => c.GetType() == typeof(Customer));
Assert.IsTrue(ok);
}
public async Task LoadNavigationPropertyScalar()
{
var em1 = await TestFns.NewEm(_serviceName);
TestFns.RunInWpfSyncContext(async() => {
var q0 = new EntityQuery <Order>().Where(o => o.Customer != null).Take(3);
var r0 = await q0.Execute(em1);
// Task.WaitAll(r0.Select(o => o.EntityAspect.LoadNavigationProperty("Customer")).ToArray());
await Task.WhenAll(r0.Select(o => o.EntityAspect.LoadNavigationProperty("Customer")));
Assert.IsTrue(r0.All(o => o.Customer != null));
});
}
public async Task SimpleEntitySelect() {
Assert.Inconclusive("Known issue with OData - use an anon projection instead");
await _emTask;
var q1 = new EntityQuery<Order>().Where(o => true).Select(o => o.Customer).Take(5);
var r1 = await q1.Execute(_em1);
Assert.IsTrue(r1.Count() == 5);
var ok = r1.All(r => r.GetType() == typeof(Customer));
Assert.IsTrue(ok);
}
public async Task SelectSimpleAnonEntity()
{
var em1 = await TestFns.NewEm(_serviceName);
var q1 = new EntityQuery <Order>().Select(o => new { o.Customer }).Take(5);
var r1 = await q1.Execute(em1);
Assert.IsTrue(r1.Count() == 5);
var ok = r1.All(r => r.Customer.GetType() == typeof(Customer));
Assert.IsTrue(ok);
}
public async Task SelectAnonSingleDp()
{
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery <Customer>("Customers")
.Where(c => c.CompanyName.StartsWith("C"))
.Select(c => new { c.CompanyName });
var results = await q.Execute(em1);
Assert.IsTrue(results.Any());
}
public async Task SelectSimpleAnonEntityCollection()
{
var em1 = await TestFns.NewEm(_serviceName);
var q1 = new EntityQuery <Customer>().Where(c => c.CompanyName.StartsWith("C")).Select(c => new { c.Orders });
var r1 = await q1.Execute(em1);
Assert.IsTrue(r1.Count() > 0);
var ok = r1.All(r => r.Orders.Count() > 0);
Assert.IsTrue(ok);
}
public async Task CompanyNamesAndIds() {
await _emTask;
var q = new EntityQuery<Object>("CompanyNamesAndIds");
var rp = q.GetResourcePath();
var companyNamesAndIds = await q.Execute(_em1);
Assert.IsTrue(companyNamesAndIds.Count() > 0, "should be some results");
// each item is a JObject
var companyNamesAndIdObjects = companyNamesAndIds.Cast<JObject>();
var item = companyNamesAndIdObjects.First();
var companyName = item["CompanyName"].ToObject<String>();
var id = item["CustomerID"].ToObject<Guid>();
}
public async Task LoadNavigationPropertyNonscalar()
{
var em1 = await TestFns.NewEm(_serviceName);
TestFns.RunInWpfSyncContext(async() => {
var q0 = new EntityQuery <Customer>().Where(c => c.Orders.Any()).Take(3);
var r0 = await q0.Execute(em1);
// Task.WaitAll(r0.Select(c => c.EntityAspect.LoadNavigationProperty("Orders")).ToArray());
await Task.WhenAll(r0.Select(c => c.EntityAspect.LoadNavigationProperty("Orders")));
Assert.IsTrue(r0.All(c => c.Orders.Count() > 0));
});
}
public async Task SimpleAnonEntityCollectionSelect()
{
await _emTask;
var q1 = new EntityQuery <Customer>().Where(c => c.CompanyName.StartsWith("C")).Select(c => new { c.Orders });
var r1 = await q1.Execute(_em1);
Assert.IsTrue(r1.Count() > 0);
var ok = r1.All(r => r.Orders.Count() > 0);
Assert.IsTrue(ok);
}
public async Task SimpleAnonEntitySelect()
{
await _emTask;
var q1 = new EntityQuery <Order>().Select(o => new { o.Customer }).Take(5);
var r1 = await q1.Execute(_em1);
Assert.IsTrue(r1.Count() == 5);
var ok = r1.All(r => r.Customer.GetType() == typeof(Customer));
Assert.IsTrue(ok);
}
public async Task QueryWithYearFn()
{
var em1 = await TestFns.NewEm(_serviceName);
var q0 = new EntityQuery <Employee>().Where(e => e.HireDate.Value.Year > 1993);
var r0 = await q0.Execute(em1);
Assert.IsTrue(r0.Count() > 0);
Assert.IsTrue(r0.All(r => r.HireDate.Value.Year > 1993));
var r1 = q0.ExecuteLocally(em1);
Assert.IsTrue(r1.Count() == r0.Count());
}
public async Task SimpleEntitySelect()
{
Assert.Inconclusive("Known issue with OData - use an anon projection instead");
await _emTask;
var q1 = new EntityQuery <Order>().Where(o => true).Select(o => o.Customer).Take(5);
var r1 = await q1.Execute(_em1);
Assert.IsTrue(r1.Count() == 5);
var ok = r1.All(r => r.GetType() == typeof(Customer));
Assert.IsTrue(ok);
}
public async Task Take0WithInlineCount()
{
await _emTask;
var q0 = new EntityQuery <Customer>().Take(0).InlineCount();
var r0 = await q0.Execute(_em1);
Assert.IsTrue(r0.Count() == 0);
var count = ((IHasInlineCount)r0).InlineCount;
Assert.IsTrue(count > 0);
}
public async Task QueryWithAddFn()
{
await _emTask;
var q0 = new EntityQuery <Employee>().Where(e => e.EmployeeID + e.ReportsToEmployeeID.Value > 3);
var r0 = await q0.Execute(_em1);
Assert.IsTrue(r0.Count() > 0);
Assert.IsTrue(r0.All(e => e.EmployeeID + e.ReportsToEmployeeID > 3));
var r1 = q0.ExecuteLocally(_em1);
Assert.IsTrue(r1.Count() == r0.Count());
}
public async Task QueryWithMonthFn()
{
await _emTask;
var q0 = new EntityQuery <Employee>().Where(e => e.HireDate.Value.Month > 6 && e.HireDate.Value.Month < 11);
var r0 = await q0.Execute(_em1);
Assert.IsTrue(r0.Count() > 0);
Assert.IsTrue(r0.All(e => e.HireDate.Value.Month > 6 && e.HireDate.Value.Month < 11));
var r1 = q0.ExecuteLocally(_em1);
Assert.IsTrue(r1.Count() == r0.Count());
}
public async Task QueryWithYearFn()
{
await _emTask;
var q0 = new EntityQuery <Employee>().Where(e => e.HireDate.Value.Year > 1993);
var r0 = await q0.Execute(_em1);
Assert.IsTrue(r0.Count() > 0);
Assert.IsTrue(r0.All(r => r.HireDate.Value.Year > 1993));
var r1 = q0.ExecuteLocally(_em1);
Assert.IsTrue(r1.Count() == r0.Count());
}
public async Task ExpEntities() {
await _emTask;
var q = new EntityQuery<Foo.Customer>("Customers").Take(5);
var results = await q.Execute(_em1);
Assert.IsTrue(results.Count() > 0);
var exportedEntities = _em1.ExportEntities();
File.WriteAllText("c:/temp/emExport.txt", exportedEntities);
}
public async Task SaveModifiedCustomers()
{
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery <Customer>("Customers").Where(c => c.CompanyName.StartsWith("A"));
var custs = await q.Execute(em1);
Assert.IsTrue(custs.Count() > 0, "should be some results");
custs.ForEach(c => c.Fax = TestFns.MorphString(c.Fax));
var saveResult = await em1.SaveChanges();
Assert.IsTrue(saveResult.Entities.Count == custs.Count());
}
public async Task ExpEntities()
{
await _emTask;
var q = new EntityQuery <Foo.Customer>("Customers").Take(5);
var results = await q.Execute(_em1);
Assert.IsTrue(results.Count() > 0);
var exportedEntities = _em1.ExportEntities();
File.WriteAllText("c:/temp/emExport.txt", exportedEntities);
}
public async Task EmployeesFilteredByCountryAndBirthDate()
{
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery <Employee>().From("EmployeesFilteredByCountryAndBirthdate")
.WithParameter("birthDate", "1/1/1960")
.WithParameter("country", "USA");
var rp = q.GetResourcePath(em1.MetadataStore);
var results = await q.Execute(em1);
Assert.IsTrue(results.Any());
}
public async Task ExpEntities()
{
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery <Foo.Customer>("Customers").Take(5);
var results = await q.Execute(em1);
Assert.IsTrue(results.Count() > 0);
var exportedEntities = em1.ExportEntities();
File.WriteAllText("c:/temp/emExport.txt", exportedEntities);
}
public async Task ExpEntities() {
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery<Foo.Customer>("Customers").Take(5);
var results = await q.Execute(em1);
Assert.IsTrue(results.Count() > 0);
var exportedEntities = em1.ExportEntities();
File.WriteAllText("c:/temp/emExport.txt", exportedEntities);
}
public async Task Take0WithInlineCount()
{
var em1 = await TestFns.NewEm(_serviceName);
var q0 = new EntityQuery <Customer>().Take(0).InlineCount();
var r0 = await q0.Execute(em1);
Assert.IsTrue(r0.Count() == 0);
var count = ((IHasInlineCount)r0).InlineCount;
Assert.IsTrue(count > 0);
}
public async Task SelectScalarNpNoAnon()
{
Assert.Inconclusive("Known issue with OData - use an anon projection instead");
var em1 = await TestFns.NewEm(_serviceName);
var q1 = new EntityQuery <Order>().Where(o => true).Select(o => o.Customer).Take(5);
var r1 = await q1.Execute(em1);
Assert.IsTrue(r1.Count() == 5);
var ok = r1.All(r => r.GetType() == typeof(Customer));
Assert.IsTrue(ok);
}
public async Task WhereFnAdd()
{
var em1 = await TestFns.NewEm(_serviceName);
var q0 = new EntityQuery <Employee>().Where(e => e.EmployeeID + e.ReportsToEmployeeID.Value > 3);
var r0 = await q0.Execute(em1);
Assert.IsTrue(r0.Count() > 0);
Assert.IsTrue(r0.All(e => e.EmployeeID + e.ReportsToEmployeeID > 3));
var r1 = q0.ExecuteLocally(em1);
Assert.IsTrue(r1.Count() == r0.Count());
}
public async Task WhereFnMonth()
{
var em1 = await TestFns.NewEm(_serviceName);
var q0 = new EntityQuery <Employee>().Where(e => e.HireDate.Value.Month > 6 && e.HireDate.Value.Month < 11);
var r0 = await q0.Execute(em1);
Assert.IsTrue(r0.Count() > 0);
Assert.IsTrue(r0.All(e => e.HireDate.Value.Month > 6 && e.HireDate.Value.Month < 11));
var r1 = q0.ExecuteLocally(em1);
Assert.IsTrue(r1.Count() == r0.Count());
}
public async Task QueryWithBadResourceName()
{
var em1 = await TestFns.NewEm(_serviceName);
var q0 = new EntityQuery <Customer>("Error").Where(c => c.CompanyName.StartsWith("P"));
try {
var r0 = await q0.Execute(em1);
Assert.Fail("shouldn't get here");
} catch (Exception e) {
Assert.IsTrue(e.Message.ToLower().Contains("not found"), "should be the right message");
}
}
public async Task CompanyNamesAndIds()
{
await _emTask;
var q = new EntityQuery <Object>("CompanyNamesAndIds");
var rp = q.GetResourcePath();
var companyNamesAndIds = await q.Execute(_em1);
Assert.IsTrue(companyNamesAndIds.Count() > 0, "should be some results");
// each item is a JObject
var companyNamesAndIdObjects = companyNamesAndIds.Cast <JObject>();
var item = companyNamesAndIdObjects.First();
var companyName = item["CompanyName"].ToObject <String>();
var id = item["CustomerID"].ToObject <Guid>();
}
public async Task CompanyNames() {
await _emTask;
var q = new EntityQuery<String>("CompanyNames");
var rp = q.GetResourcePath();
var companyNames = await q.Execute(_em1);
Assert.IsTrue(companyNames.Count() > 0, "should be some results");
var q2 = new EntityQuery<Object>("CompanyNames");
rp = q2.GetResourcePath();
var companyNames2 = await q2.Execute(_em1);
Assert.IsTrue(companyNames2.Count() > 0, "should be some results");
Assert.IsTrue(companyNames.SequenceEqual(companyNames2.Cast<String>()));
}
public async Task CustomersAndOrders()
{
await _emTask;
var q = new EntityQuery <Customer>("CustomersAndOrders").Where(c => c.CompanyName.StartsWith("A"));
var rp = q.GetResourcePath();
var results = await q.Execute(_em1);
Assert.IsTrue(results.Count() > 0, "should be some results");
Assert.IsTrue(_em1.GetEntities <Customer>().Count() > 0, "should have some customers");
Assert.IsTrue(_em1.GetEntities <Order>().Count() > 0, "should have some orders");
Assert.IsTrue(results.All(c => c.CompanyName.StartsWith("A")));
}
public async Task CustomersAndOrders()
{
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery <Customer>("CustomersAndOrders").Where(c => c.CompanyName.StartsWith("A"));
var rp = q.GetResourcePath(em1.MetadataStore);
var results = await q.Execute(em1);
Assert.IsTrue(results.Count() > 0, "should be some results");
Assert.IsTrue(em1.GetEntities <Customer>().Count() > 0, "should have some customers");
Assert.IsTrue(em1.GetEntities <Order>().Count() > 0, "should have some orders");
Assert.IsTrue(results.All(c => c.CompanyName.StartsWith("A")));
}
private async Task <IEnumerable <T> > QueryBillingBase <T>(EntityManager em, String typeName) where T : IBillingDetail
{
var q0 = new EntityQuery <T>(typeName + "s").With(em);
var r0 = await q0.Execute();
if (r0.Count() == 0)
{
Assert.Inconclusive("Please restart the server - inheritance data was deleted by prior tests");
}
Assert.IsTrue(r0.All(r => typeof(T).IsAssignableFrom(r.GetType())));
Assert.IsTrue(r0.All(r => r.Owner == r.Owner.ToUpper()), "all owners should be uppercase (from initializer)");
Assert.IsTrue(r0.All(r => r.MiscData == "asdf"), "all 'MiscData' should be 'asdf' (from initializer)");
return(r0);
}
public async Task ExpEntitiesWithChanges() {
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery<Foo.Customer>("Customers").Take(5);
var results = await q.Execute(em1);
Assert.IsTrue(results.Count() > 0);
var custs = results.Take(2);
custs.ForEach(c => c.City = "Paris");
var emp1 = em1.CreateEntity<Employee>();
var exportedEntities = em1.ExportEntities();
File.WriteAllText("c:/temp/emExportWithChanges.txt", exportedEntities);
}
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 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 OriginalValues() {
await _emTask;
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:" + s.Location.Address);
Assert.IsTrue(suppliers.All(s => s.EntityAspect.EntityState.IsModified()));
Assert.IsTrue(suppliers.All(s => s.EntityAspect.OriginalValuesMap.Count() == 0), "supplier originalValuesMap should be empty");
suppliers.ForEach(s => {
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");
var oldAddress = (String) location.ComplexAspect.OriginalValuesMap["Address"];
if (oldAddress == null) {
Assert.IsTrue(location.Address == "Foo:", "should have a null old address");
} else {
Assert.IsTrue(location.Address.Substring(4) == oldAddress, "should have the right old address");
}
});
}
public async Task SaveModifiedCustomers() {
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery<Customer>("Customers").Where(c => c.CompanyName.StartsWith("A"));
var custs = await q.Execute(em1);
Assert.IsTrue(custs.Count() > 0, "should be some results");
custs.ForEach(c => c.Fax = TestFns.MorphString(c.Fax));
var saveResult = await em1.SaveChanges();
Assert.IsTrue(saveResult.Entities.Count == custs.Count());
}
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 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 CustomersWithHttpError() {
await _emTask;
var q = new EntityQuery<Customer>("CustomersWithHttpError");
var rp = q.GetResourcePath();
try {
var results = await q.Execute(_em1);
Assert.Fail("shouldn't get here");
} catch (HttpRequestException e) {
Assert.IsTrue(e.Message.Contains("Custom Reason"));
Assert.IsTrue(e.Message.Contains("404"));
}
}
public async Task SearchCustomersWithParameters() {
await _emTask;
//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 CustomersAndOrders() {
await _emTask;
var q = new EntityQuery<Customer>("CustomersAndOrders").Where(c => c.CompanyName.StartsWith("A"));
var rp = q.GetResourcePath();
var results = await q.Execute(_em1);
Assert.IsTrue(results.Count() > 0, "should be some results");
Assert.IsTrue(_em1.GetEntities<Customer>().Count() > 0, "should have some customers");
Assert.IsTrue(_em1.GetEntities<Order>().Count() > 0, "should have some orders");
Assert.IsTrue(results.All(c => c.CompanyName.StartsWith("A")));
}
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 SaveModifiedCpAndNonCp() {
await _emTask;
var q0 = EntityQuery.From<Supplier>().Where(s => s.CompanyName.StartsWith("P"));
var r0 = await q0.With(_em1).Execute();
Assert.IsTrue(r0.Count() > 0);
var supplier = r0.First();
var val = "foo-" + TestFns.RandomSuffix(5);
var oldVal = supplier.Location.PostalCode;
Assert.IsTrue(val != oldVal);
supplier.Location.PostalCode = val;
var oldCompanyName = supplier.CompanyName;
supplier.CompanyName = TestFns.MorphString(supplier.CompanyName);
var newCompanyName = supplier.CompanyName;
var sr = await _em1.SaveChanges();
Assert.IsTrue(sr.Entities.Count == 1);
var _em2 = new EntityManager(_em1);
var q1 = new EntityQuery<Supplier>().Where(s => s.Location.PostalCode == val);
var r1 = await q1.Execute(_em2);
Assert.IsTrue(r1.Count() == 1);
Assert.IsTrue(r1.First().CompanyName == newCompanyName, "should have changed the companyName");
}
public async Task CaptureAddlSavesDoneOnServer() {
var em1 = await TestFns.NewEm(_serviceName);
// ok(true, "Skipped test - OData does not support server interception or alt resources");
// ok(true, "N/A for Mongo - test not yet implemented - requires server side async call");
var q = new EntityQuery<Category>().Where(c => c.CategoryName.StartsWith("Beverage")).Expand("Products");
var r = await q.Execute(em1);
var category = r.First();
var products = category.Products;
var prices = products.Select(p => p.UnitPrice).ToList();
category.CategoryName = TestFns.MorphString(category.CategoryName);
var so = new SaveOptions(tag: "increaseProductPrice");
var sr = await em1.SaveChanges(null, so);
Assert.IsTrue(sr.Entities.Count == 13, "should have saved 13 entities + 1 category + 12 products");
Assert.IsTrue(sr.Entities.OfType<Product>().Count() == 12, "should be 12 products");
var ek = category.EntityAspect.EntityKey;
var em2 = new EntityManager(em1);
var r2 = await em2.ExecuteQuery(ek.ToQuery<Category>().Expand("Products"));
var cat2 = r2.First();
var products2 = cat2.Products;
var newPrices = products2.Select(p => p.UnitPrice).ToList();
Assert.IsTrue(!prices.SequenceEqual(newPrices), "prices should have changed");
}
public async Task SaveModifiedCpOnly() {
await _emTask;
var q0 = EntityQuery.From<Supplier>().Where(s => s.CompanyName.StartsWith("P"));
var r0 = await q0.With(_em1).Execute();
Assert.IsTrue(r0.Count() > 0);
var supplier = r0.First();
var val = "foo-" + TestFns.RandomSuffix(5);
var oldVal = supplier.Location.PostalCode;
Assert.IsTrue(val != oldVal);
supplier.Location.PostalCode = val;
var sr = await _em1.SaveChanges();
Assert.IsTrue(sr.Entities.Count == 1);
_em1.Clear();
var q1 = new EntityQuery<Supplier>().Where(s => s.Location.PostalCode == val);
var r1 = await q1.Execute(_em1);
Assert.IsTrue(r1.Count() == 1);
}
public async Task CustomersWithBigOrders2() {
await _emTask;
var q = new EntityQuery<CustomerAndBigOrders>("CustomersWithBigOrders");
var rp = q.GetResourcePath();
var results = await q.Execute(_em1);
Assert.IsTrue(results.Count() > 0, "should be some results");
Assert.IsTrue(_em1.GetEntities<Customer>().Count() > 0, "should have some customers");
Assert.IsTrue(_em1.GetEntities<Order>().Count() > 0, "should have some orders");
Assert.IsTrue(results.All(r =>
r.Customer.GetType() == typeof(Customer) && r.BigOrders.GetType() == typeof(List<Order>)
));
}
public async Task AnonSelectEntity() {
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery<Order>().Take(5);
var r0 = await q.Execute(em1);
Assert.IsTrue(r0.Count() == 5);
var q1 = new EntityQuery<Order>().Select(o => new { o.Customer }).Take(5);
var r1 = await q1.Execute(em1);
Assert.IsTrue(r1.Count() == 5);
var ok = r1.All(r => r.Customer.GetType() == typeof(Customer));
Assert.IsTrue(ok);
// This only works because we insure that the order exists in cache before the query
var r1Local = q1.ExecuteLocally(em1);
Assert.IsTrue(r1Local.Count() == r1.Count());
ok = r1Local.All(r => r.Customer.Orders.Count == 1);
Assert.IsTrue(ok, "Order's per customer should be only one for now because that's all we cached");
ok = r1Local.All(r => r.Customer.GetType() == typeof(Customer));
Assert.IsTrue(ok );
}
public async Task LoadNavigationPropertyScalar() {
var em1 = await TestFns.NewEm(_serviceName);
TestFns.RunInWpfSyncContext(async () => {
var q0 = new EntityQuery<Order>().Where(o => o.Customer != null).Take(3);
var r0 = await q0.Execute(em1);
// Task.WaitAll(r0.Select(o => o.EntityAspect.LoadNavigationProperty("Customer")).ToArray());
await Task.WhenAll(r0.Select(o => o.EntityAspect.LoadNavigationProperty("Customer")));
Assert.IsTrue(r0.All(o => o.Customer != null));
});
}
