public void TestMethodQueryMismatch()
{
WebDomainClient <TestDomainServices.LTS.Catalog.ICatalogContract> dc = new WebDomainClient <TestDomainServices.LTS.Catalog.ICatalogContract>(TestURIs.EF_Catalog)
{
EntityTypes = new Type[] { typeof(Product), typeof(PurchaseOrder), typeof(PurchaseOrderDetail) }
};
QueryCompletedResult queryResults = null;
var query = new EntityQuery <PurchaseOrder>(new EntityQuery <Product>(dc, "GetProducts", null, true, false), new PurchaseOrder[0].AsQueryable().Take(2));
query.IncludeTotalCount = true;
dc.BeginQuery(
query,
delegate(IAsyncResult asyncResult)
{
queryResults = dc.EndQuery(asyncResult);
},
null
);
EnqueueConditional(() => queryResults != null);
EnqueueCallback(delegate
{
Assert.AreEqual(2, queryResults.Entities.Concat(queryResults.IncludedEntities).Count());
Assert.AreEqual(504, queryResults.TotalCount);
});
EnqueueTestComplete();
}
public void TestQueryEvents()
{
QueryCompletedResult result = null;
object userState = this;
WebDomainClient <TestDomainServices.LTS.Catalog.ICatalogContract> dc = new WebDomainClient <TestDomainServices.LTS.Catalog.ICatalogContract>(TestURIs.LTS_Catalog)
{
EntityTypes = new Type[] { typeof(Product) }
};
dc.BeginQuery(
new EntityQuery <Product>(dc, "GetProducts", null, true, false),
delegate(IAsyncResult asyncResult)
{
result = dc.EndQuery(asyncResult);
},
userState
);
EnqueueConditional(delegate
{
return(result != null);
});
EnqueueCallback(delegate
{
Assert.AreEqual(504, result.Entities.Concat(result.IncludedEntities).Count());
Assert.AreEqual(result.Entities.Count(), result.TotalCount);
});
EnqueueTestComplete();
}
/// <summary>
/// Set the result of the next Load
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entities"></param>
/// <param name="relatedEntities"></param>
/// <param name="totalCount"></param>
/// <param name="validationResult"></param>
public void SetQueryResult(IEnumerable <Entity> entities, IEnumerable <Entity> relatedEntities = null, int totalCount = -1, IEnumerable <ValidationResult> validationResult = null)
{
QueryResult = new QueryCompletedResult(entities.ToList(),
relatedEntities ?? Enumerable.Empty <Entity>(),
totalCount,
validationResult ?? Enumerable.Empty <ValidationResult>()
);
}
protected override QueryCompletedResult EndQueryCore(IAsyncResult asyncResult)
{
MockAsyncResult ar = (MockAsyncResult)asyncResult;
int entityCount = ar.Entities.Count();
QueryCompletedResult results = new QueryCompletedResult(ar.Entities, new Entity[0], entityCount, new ValidationResult[0]);
return(results);
}
protected override Task <QueryCompletedResult> QueryAsyncCore(EntityQuery query, CancellationToken cancellationToken)
{
// load test data and get query result
IEnumerable <Entity> entities = GetQueryResult(query.QueryName, query.Parameters);
if (query.Query != null)
{
entities = RebaseQuery(entities.AsQueryable(), query.Query).Cast <Entity>().ToList();
}
int entityCount = entities.Count();
QueryCompletedResult results = new QueryCompletedResult(entities, Array.Empty <Entity>(), entityCount, Array.Empty <ValidationResult>());
return(TaskHelper.FromResult(results));
}
protected override QueryCompletedResult EndQueryCore(IAsyncResult asyncResult)
{
// Maybe assert expected type
if (this.Error != null)
{
throw this.Error;
}
AdcAsyncResult result = asyncResult as AdcAsyncResult;
QueryCompletedResult results;
if (result.User == null)
{
results = new QueryCompletedResult(new MockUser[0], new Entity[0], 0, new ValidationResult[0]);
}
else
{
results = new QueryCompletedResult(new MockUser[] { result.User }, new Entity[0], 1, new ValidationResult[0]);
}
return(results);
}
private Task <QueryCompletedResult> BeginQueryRequest(string operation = "GetZips", Dictionary <string, object> parameters = null, CancellationToken cancellationToken = default)
{
var result = this.DomainClient.QueryAsync(new EntityQuery <Zip>(this.DomainClient, operation, parameters, true, false), cancellationToken);
this.AssertInProgress(result);
return(result.ContinueWith(task =>
{
try
{
QueryCompletedResult res = task.GetAwaiter().GetResult();
this.QueryCompletedResults = res;
return res;
}
catch (Exception ex)
{
this.Error = ex;
throw;
}
}, TaskContinuationOptions.NotOnCanceled));
}
public void TestQuery()
{
QueryCompletedResult result = null;
object userState = this;
WebDomainClient <TestDomainServices.LTS.Catalog.ICatalogContract> dc = new WebDomainClient <TestDomainServices.LTS.Catalog.ICatalogContract>(TestURIs.LTS_Catalog)
{
EntityTypes = new Type[] { typeof(Product) }
};
var query = from p in new Product[0].AsQueryable()
where p.Weight < 10.5M
orderby p.Weight
select p;
var entityQuery = new EntityQuery <Product>(new EntityQuery <Product>(dc, "GetProducts", null, true, false), query);
entityQuery.IncludeTotalCount = true;
dc.BeginQuery(
entityQuery,
delegate(IAsyncResult asyncResult)
{
result = dc.EndQuery(asyncResult);
},
userState
);
EnqueueConditional(delegate
{
return(result != null);
});
EnqueueCallback(delegate
{
Assert.AreEqual(79, result.Entities.Concat(result.IncludedEntities).Count());
Assert.AreEqual(result.Entities.Count(), result.TotalCount);
});
EnqueueTestComplete();
}
protected override async Task <QueryCompletedResult> QueryAsyncCore(EntityQuery query, CancellationToken cancellationToken)
{
MockUser user = null;
if (query.QueryName == "Login")
{
Assert.IsNotNull(query.Parameters,
"Parameters should not be null.");
Assert.IsTrue(query.Parameters.ContainsKey("UserName"),
"Parameters should contain UserName.");
Assert.IsTrue(query.Parameters.ContainsKey("Password"),
"Parameters should contain Password.");
Assert.IsTrue(query.Parameters.ContainsKey("IsPersistent"),
"Parameters should contain IsPersistent.");
if (AuthenticationDomainClient.ValidUserName == (string)query.Parameters["UserName"])
{
user = new MockUser()
{
Type = UserType.LoggedIn, Name = "LoggedIn"
};
}
}
else if (query.QueryName == "Logout")
{
Assert.IsTrue((query.Parameters == null) || (query.Parameters.Count == 0),
"Logout operation is not expecting any parameters.");
user = new MockUser()
{
Type = UserType.LoggedOut
};
}
else if (query.QueryName == "GetUser")
{
Assert.AreEqual("GetUser", query.QueryName,
"Operation should be GetUser.");
Assert.IsTrue((query.Parameters == null) || (query.Parameters.Count == 0),
"GetUser operation is not expecting any parameters.");
Assert.IsNull(query.Query,
"GetUser operation is not expecting a query.");
user = new MockUser()
{
Type = UserType.Loaded
};
}
else
{
Assert.Fail("Only Login, Logout, and GetUser methods are supported for queries.");
}
cancellationToken.Register(() => this.CancellationRequested = true);
await _callbackDelay.WaitAsync(cancellationToken);
// Maybe assert expected type
if (this.Error != null)
{
throw this.Error;
}
QueryCompletedResult results;
if (user == null)
{
results = new QueryCompletedResult(Array.Empty <MockUser>(), Array.Empty <Entity>(), 0, Array.Empty <ValidationResult>());
}
else
{
results = new QueryCompletedResult(new MockUser[] { user }, Array.Empty <Entity>(), 1, Array.Empty <ValidationResult>());
}
return(results);
}
protected override Task <QueryCompletedResult> QueryAsyncCore(EntityQuery query, CancellationToken cancellationToken)
{
MockUser user = null;
if (query.QueryName == "Login")
{
Assert.IsNotNull(query.Parameters,
"Parameters should not be null.");
Assert.IsTrue(query.Parameters.ContainsKey("UserName"),
"Parameters should contain UserName.");
Assert.IsTrue(query.Parameters.ContainsKey("Password"),
"Parameters should contain Password.");
Assert.IsTrue(query.Parameters.ContainsKey("IsPersistent"),
"Parameters should contain IsPersistent.");
if (AuthenticationDomainClient.ValidUserName == (string)query.Parameters["UserName"])
{
user = new MockUser()
{
Type = UserType.LoggedIn, Name = "LoggedIn"
};
}
}
else if (query.QueryName == "Logout")
{
Assert.IsTrue((query.Parameters == null) || (query.Parameters.Count == 0),
"Logout operation is not expecting any parameters.");
user = new MockUser()
{
Type = UserType.LoggedOut
};
}
else if (query.QueryName == "GetUser")
{
Assert.AreEqual("GetUser", query.QueryName,
"Operation should be GetUser.");
Assert.IsTrue((query.Parameters == null) || (query.Parameters.Count == 0),
"GetUser operation is not expecting any parameters.");
Assert.IsNull(query.Query,
"GetUser operation is not expecting a query.");
user = new MockUser()
{
Type = UserType.Loaded
};
}
else
{
Assert.Fail("Only Login, Logout, and GetUser methods are supported for queries.");
}
AsyncCallback completeCallback = (asyncResult) =>
{
var adcAsyncResult = (AdcAsyncResult)asyncResult;
var tcs = (TaskCompletionSource <QueryCompletedResult>)adcAsyncResult.AsyncState;
// Maybe assert expected type
if (this.Error != null)
{
tcs.SetException(this.Error);
}
else if (this.CancellationRequested)
{
tcs.SetCanceled();
}
else
{
QueryCompletedResult results;
if (user == null)
{
results = new QueryCompletedResult(Array.Empty <MockUser>(), Array.Empty <Entity>(), 0, Array.Empty <ValidationResult>());
}
else
{
results = new QueryCompletedResult(new MockUser[] { user }, Array.Empty <Entity>(), 1, Array.Empty <ValidationResult>());
}
tcs.SetResult(results);
}
};
var taskCompletionSource = new TaskCompletionSource <QueryCompletedResult>();
this.Result = new AdcAsyncResult(user, completeCallback, taskCompletionSource);
cancellationToken.Register(res =>
{
this.CancellationRequested = true;
}, this.Result);
return(taskCompletionSource.Task);
}
