public async Task NestedExpand3Levels()
{
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 CheckDefaultValues()
{
var em1 = await TestFns.NewEm(_serviceName);
var supplier = em1.CreateEntity <Supplier>();
var companyName = supplier.CompanyName;
var location = supplier.Location;
Assert.IsTrue(location.GetType() == typeof(Location));
var city = location.City;
}
public async Task FkFixup()
{
var em1 = await TestFns.NewEm(_serviceName);
var cust1 = em1.CreateEntity <Customer>(EntityState.Unchanged);
var order1 = em1.CreateEntity <Order>(EntityState.Unchanged);
order1.CustomerID = cust1.CustomerID;
Assert.IsTrue(cust1.Orders.Contains(order1), "should contain order1");
Assert.IsTrue(order1.Customer == cust1, "customer should be attached");
}
public async Task WithEntityManager()
{
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.With(em1).Execute();
Assert.IsTrue(results.Count() == 2);
}
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 SaveWithServerExit()
{
var em1 = await TestFns.NewEm(_serviceName);
// ok(true, "Skipped test - OData does not support server interception or alt resources");
CreateParentAndChildren(em1);
var so = new SaveOptions("SaveWithExit", tag: "exit");
var sr0 = await em1.SaveChanges(so);
Assert.IsTrue(sr0.Entities.Count == 0);
}
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 WhereOrderByTake()
{
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);
Assert.IsTrue(results.All(r1 => r1.GetType() == typeof(Foo.Customer)), "should all get customers");
}
public async Task AttachDetachReattach()
{
var em1 = await TestFns.NewEm(_serviceName);
var order = em1.CreateEntity <Order>(EntityState.Unchanged);
Assert.IsTrue(order.EntityAspect.IsAttached && order.EntityAspect.EntityState.IsUnchanged());
em1.DetachEntity(order);
Assert.IsTrue(order.EntityAspect.IsDetached);
em1.AttachEntity(order);
Assert.IsTrue(order.EntityAspect.IsAttached && order.EntityAspect.EntityState.IsUnchanged());
}
public async Task ServerSideProjection()
{
var entityManager = await TestFns.NewEm(_serviceName);
// Query from service that projects User onto UserPartial, omitting the Password property
var query1 = EntityQuery.From("UserPartials", new {
Id = 0L,
UserName = "",
FirstName = "",
LastName = "",
Email = ""
// Even though this works, sending every user's roles seems unwise
// Roles = user.UserRoles.Select(ur => ur.Role)
});
var users1 = await query1.Execute(entityManager);
Assert.IsTrue(users1.Any(), "UserPartials query should produce data");
var user1 = users1.First();
var usersInCache = entityManager.GetEntities <User>();
Assert.IsFalse(usersInCache.Any(), "UserPartials query should not have retrieved User entities into cacha");
var rolesInCache = entityManager.GetEntities <Role>();
Assert.IsFalse(rolesInCache.Any(), "UserPartials query should not have retrieved Role entities into cacha");
// Query from similar service that accepts parameter
var query2 = EntityQuery.From("GetUserById", new {
Id = 0L,
UserName = "",
FirstName = "",
LastName = "",
Email = "",
// Roles = Enumerable.Empty<Role>()
RoleNames = ""
// Even though this works, sending every user's roles seems unwise
// Roles = user.UserRoles.Select(ur => ur.Role)
}).WithParameter("Id", 3);
var users2 = await query2.Execute(entityManager);
Assert.IsTrue(users2.Count() == 1, "GetUserById query should return exactly 1 user");
var user2 = users2.First();
var usersInCache2 = entityManager.GetEntities <User>();
Assert.IsFalse(usersInCache2.Any(), "GetUserById query should not have retrieved User entities into cacha");
var roleNames = user2.GetPropValue <String>("RoleNames");
Assert.IsTrue(!String.IsNullOrEmpty(roleNames), "User with Id 3 should have defined roles");
}
public async Task SimpleAnonEntitySelect()
{
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 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 NonGenericQuery()
{
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery <Foo.Customer>("Customers");
var q2 = q.Where(c => c.CompanyName.StartsWith("C")).Take(3);
var q3 = (EntityQuery)q2;
var results = await em1.ExecuteQuery(q3);
Assert.IsTrue(results.Cast <Object>().Count() == 3);
}
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 WithOnlyExpand()
{
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery <Customer>().Take(3);
var r0 = await em1.ExecuteQuery(q);
var q1 = new EntityQuery <Customer>().Expand("Orders");
var r1 = q1.ExecuteLocally(em1);
Assert.IsTrue(r0.Count() == r1.Count());
}
public async Task SimpleAnonEntityCollectionSelect()
{
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 Projection() {
try {
var entityManager = await TestFns.NewEm(_serviceName);
// Next line does not work because of MS OData restrictions.
// var productNames = await new EntityQuery<Product>().Select(p => p.ProductName).Execute(entityManager);
var productNames = await new EntityQuery<Product>().Select(p => new { p.ProductName }).Execute(entityManager);
Assert.IsTrue(productNames.Any(), "Projection query should return items");
} catch (Exception e) {
var message = TestFns.FormatException(e);
Assert.Fail(message);
}
}
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 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 CompanyNamesAndIds2()
{
var em1 = await TestFns.NewEm(_serviceName);
var q = EntityQuery.From("CompanyNamesAndIds", new { CompanyName = "", CustomerID = new Guid() });
var rp = q.GetResourcePath();
var companyNamesAndIds = await q.Execute(em1);
Assert.IsTrue(companyNamesAndIds.Count() > 0, "should be some results");
Assert.IsTrue(companyNamesAndIds.All(x => {
return(x.CompanyName.Length > 0 && x.CustomerID != null);
}));
}
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 CreateEntity()
{
var em1 = await TestFns.NewEm(_serviceName);
var emp1 = em1.CreateEntity(typeof(Employee));
Assert.IsTrue(emp1.EntityAspect.EntityState == EntityState.Added);
var emp3 = em1.CreateEntity <Employee>(EntityState.Detached);
emp3.LastName = "Smith";
Assert.IsTrue(emp3.EntityAspect.EntityState.IsDetached());
Assert.IsTrue(emp3.LastName == "Smith");
}
public async Task SimpleEntitySelect()
{
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 QueryWithAddFn()
{
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 QueryWithMonthFn()
{
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 SimpleQuery()
{
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery <Customer>();
var r0 = await em1.ExecuteQuery(q);
Assert.IsTrue(r0.Cast <Object>().Count() > 0);
var r1 = q.ExecuteLocally(em1);
Assert.IsTrue(r0.Count() == r1.Count());
}
public async Task GuidQuery()
{
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery <Customer>().Take(3);
var r = await em1.ExecuteQuery(q);
Assert.IsTrue(r.Count() == 3, "should be no results");
var q1 = new EntityQuery <Customer>().Where(c => c.CustomerID.Equals(Guid.NewGuid()));
var r1 = q1.ExecuteLocally(em1);
Assert.IsTrue(r1.Count() == 0);
}
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 RemoveFromNavCollection()
{
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);
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);
};
orders.Remove(order1);
Assert.IsTrue(collectionChangedList.Last().Action == NotifyCollectionChangedAction.Remove);
Assert.IsTrue(collectionChangedList.Last().OldItems.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 have been removed");
Assert.IsTrue(order1.Customer == null, "Customer should be null");
Assert.IsTrue(order1.CustomerID == null, "CustomerID should be null"); // null because not required.
Assert.IsTrue(order1.EntityAspect.EntityState.IsAdded());
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");
}
public async Task QueryByComplexProp()
{
var em1 = await TestFns.NewEm(_serviceName);
var q = new EntityQuery <Supplier>().Where(c => c.Location.City.StartsWith("P") && c.CompanyName != null);
// var q = new EntityQuery<Supplier>().Where(c => c.CompanyName.StartsWith("P") && c.Location.City != null && c.Location.Address != null);
var x = q.GetResourcePath();
var suppliers = await em1.ExecuteQuery(q);
Assert.IsTrue(suppliers.Count() > 0, "should have returned some suppliers");
// Assert.IsTrue(suppliers.All(s => s.Location.City != null && s.Location.Address != null));
Assert.IsTrue(suppliers.All(s => s.Location.City.StartsWith("P") && s.CompanyName != null), "should match query");
}
