private Task <SubmitCompletedResult> BeginSubmitRequest(CancellationToken cancellationToken = default)
{
this.CityDomainContext.Cities.Add(new City()
{
Name = "TestCity", StateName = "ZZ"
});
var result = this.DomainClient.SubmitAsync(this.CityDomainContext.EntityContainer.GetChanges(), cancellationToken);
this.AssertInProgress(result);
return(result.ContinueWith(task =>
{
try
{
SubmitCompletedResult res = task.GetAwaiter().GetResult();
this.SubmitCompletedResults = res;
return res;
}
catch (Exception ex)
{
this.Error = ex;
throw;
}
}
, TaskContinuationOptions.NotOnCanceled));
}
public void TestInitialize()
{
this.Error = null;
this.InvokeCompletedResults = null;
this.QueryCompletedResults = null;
this.SubmitCompletedResults = null;
this.CreateDomainContext();
}
protected override Task <SubmitCompletedResult> SubmitAsyncCore(EntityChangeSet changeSet, CancellationToken cancellationToken)
{
IEnumerable <ChangeSetEntry> submitOperations = changeSet.GetChangeSetEntries();
// perform mock submit operations
SubmitCompletedResult submitResults = new SubmitCompletedResult(changeSet, submitOperations);
return(TaskHelper.FromResult(submitResults));
}
protected override SubmitCompletedResult EndSubmitCore(IAsyncResult asyncResult)
{
MockAsyncResult ar = (MockAsyncResult)asyncResult;
object[] stateParts = (object[])ar.InnerState;
EntityChangeSet changeSet = (EntityChangeSet)stateParts[0];
IEnumerable <ChangeSetEntry> submitOperations = (IEnumerable <ChangeSetEntry>)stateParts[1];
SubmitCompletedResult submitResults = new SubmitCompletedResult(changeSet, submitOperations);
return(submitResults);
}
protected override SubmitCompletedResult EndSubmitCore(IAsyncResult asyncResult)
{
// Maybe assert expected type
if (this.Error != null)
{
throw this.Error;
}
this.Submitted = true;
AdcSubmitAsyncResult result = asyncResult as AdcSubmitAsyncResult;
result.SubmitOperations.First().Entity = result.User;
result.Submit(this.SubmitConflictMembers, this.SubmitErrors, this.SubmitValidationErrors);
SubmitCompletedResult results = new SubmitCompletedResult(result.ChangeSet, result.SubmitOperations);
return(results);
}
public async Task SubmitAsync_Cancel_DomainClientCompletes()
{
var mockDomainClient = new CitiesMockDomainClient();
Cities.CityDomainContext ctx = new Cities.CityDomainContext(mockDomainClient);
// If cancellation results in request beeing cancelled the result should be cancelled
using var cts = new CancellationTokenSource();
mockDomainClient.SubmitCompletedCallback = async(changeSet, submitOperations) =>
{
// Wait for cancellation, and then return successfully without cancellation
try
{
await Task.Delay(-1, cts.Token);
}
catch (OperationCanceledException)
{
// Do nothing this is the expected outcome
}
// perform mock submit operations
SubmitCompletedResult submitResults = new SubmitCompletedResult(changeSet, submitOperations);
return(submitResults);
};
ctx.Cities.Add(new City()
{
Name = "NewCity", StateName = "NN", CountyName = "NewCounty"
});
var submitTask = ctx.SubmitChangesAsync(cts.Token);
Assert.IsTrue(ctx.IsSubmitting);
Assert.IsTrue(ctx.Cities.First().IsSubmitting, "entity should be in submitting state");
cts.Cancel();
var result = await submitTask;
Assert.IsFalse(ctx.IsSubmitting);
Assert.IsFalse(ctx.Cities.First().IsSubmitting, "entity should not be in submitting state");
}
private void SubmitAsyncCallback(IAsyncResult result)
{
this.SubmitCompletedResults = this.DomainClient.EndSubmit(result);
}
protected override Task <SubmitCompletedResult> SubmitAsyncCore(EntityChangeSet changeSet, CancellationToken cancellationToken)
{
Assert.AreEqual(0, changeSet.AddedEntities.Count,
"Change set should not contained added entities.");
Assert.IsFalse(changeSet.IsEmpty,
"Change set should not be empty.");
Assert.AreEqual(1, changeSet.ModifiedEntities.Count,
"Change set should contain a single modified entity.");
Assert.AreEqual(0, changeSet.RemovedEntities.Count,
"Change set should not contained removed entities.");
ChangeSetEntry[] submitOperations = changeSet.GetChangeSetEntries().ToArray();
Assert.AreEqual(1, submitOperations.Length,
"A single submit operation is expected.");
MockUser userToSubmit = (MockUser)submitOperations[0].Entity;
MockUser userToReturn = new MockUser()
{
Name = userToSubmit.Name, Type = UserType.Saved
};
List <ChangeSetEntry> submitOperationsToReturn = new List <ChangeSetEntry>();
submitOperationsToReturn.Add(new ChangeSetEntry(userToReturn, submitOperations[0].Id, submitOperations[0].Operation));
AsyncCallback completeCallback = (asyncResult) =>
{
var tcs = (TaskCompletionSource <SubmitCompletedResult>)asyncResult.AsyncState;
// Maybe assert expected type
if (this.Error != null)
{
tcs.SetException(this.Error);
}
else if (this.CancellationRequested)
{
tcs.SetCanceled();
}
else
{
this.Submitted = true;
AdcSubmitAsyncResult result = asyncResult as AdcSubmitAsyncResult;
result.SubmitOperations.First().Entity = result.User;
result.Submit(this.SubmitConflictMembers, this.SubmitErrors, this.SubmitValidationErrors);
SubmitCompletedResult results = new SubmitCompletedResult(result.ChangeSet, result.SubmitOperations);
tcs.SetResult(results);
}
};
var taskCompletionSource = new TaskCompletionSource <SubmitCompletedResult>();
this.Result = new AdcSubmitAsyncResult(changeSet, submitOperationsToReturn, userToReturn, completeCallback, taskCompletionSource);
cancellationToken.Register(res =>
{
this.CancellationRequested = true;
}, this.Result);
return(taskCompletionSource.Task);
}
