public void DoNotResolveOrRejectAfterCancel()
{
// arrange
var scheduler = new Mock <IScheduler>();
scheduler.Setup(s => s.Schedule(It.IsAny <Action>())).Callback <Action>(action => action());
var cancelInvoked = false;
var cancel = new Action(() => { cancelInvoked = true; });
var resolveInvoked = false;
var resolve = new ResolvedCallback <object>(val => { resolveInvoked = true; });
var rejectInvoked = false;
var reject = new RejectedCallback(reason => { rejectInvoked = true; });
// act
var deferred = scheduler.Object.Defer <object>(cancel);
deferred.Promise.Then(resolve, reject);
var cancelled = deferred.Promise.Cancel();
var resolved = deferred.Resolve(new object());
var rejected = deferred.Reject(new Exception());
// assert
Assert.That(cancelled, Is.True, "Expected cancel to be successful");
Assert.That(cancelInvoked, Is.True, "Expected cancel action to be invoked");
Assert.That(resolved, Is.False, "Did not expect the resolve call to be successful");
Assert.That(resolveInvoked, Is.False, "Did not expect the resolve callback to be invoked");
Assert.That(rejected, Is.False, "Did not expect the reject call to be successful");
Assert.That(rejectInvoked, Is.False, "Did not expect the reject callback to be invoked");
}
/// <summary>
/// Enqueues the given <paramref name="callback"/>.
/// </summary>
/// <param name="callback">The callback which to enqueue.</param>
private void Enqueue(RejectedCallback callback)
{
// make sure we are the only thread updating the state of this promise
lock (stateSyncRoot)
{
// if the promise is unfulfilled, register the callback
if (state == PromiseStates.Unfulfilled)
{
rejectedCallbacks.Enqueue(callback);
}
// if the promise was already rejected, schedule the callback on the event loop
else if (state == PromiseStates.Rejected)
{
scheduler.Schedule(() => callback(rejectionReason));
}
}
}
/// <summary>
/// Registers
/// </summary>
/// <param name="resolvedCallback">The <see cref="ResolvedCallback{TResult}"/> invoked if the promise is resolved.</param>
/// <param name="rejectedCallback">The <see cref="RejectedCallback"/> invoked if the promise is rejected.</param>
public void Then(ResolvedCallback <TValue> resolvedCallback, RejectedCallback rejectedCallback = null)
{
// validate arguments
if (resolvedCallback == null)
{
throw new ArgumentNullException("resolvedCallback");
}
// enqueue the resolved callback
Enqueue(resolvedCallback);
// if there is a rejection handler, enqueue it
if (rejectedCallback != null)
{
Enqueue(rejectedCallback);
}
}
public void RejectBeforeAttachingHandler()
{
// arrange
var result = new Exception();
var callbackInvoked = false;
var callback = new RejectedCallback(res => { callbackInvoked = true; });
var scheduler = new Mock <IScheduler>();
scheduler.Setup(s => s.Schedule(It.IsAny <Action>())).Callback <Action>(action => action());
// act
var deferred = scheduler.Object.Defer <object>();
deferred.Reject(result);
deferred.Promise.Then(value => { }, callback);
// assert
scheduler.VerifyAll();
Assert.That(callbackInvoked, Is.True);
}
public void DoNoRejectAfterResolve()
{
// arrange
var scheduler = new Mock<IScheduler>();
scheduler.Setup(s => s.Schedule(It.IsAny<Action>())).Callback<Action>(action => action());
var resolveInvoked = false;
var resolve = new ResolvedCallback<object>(val => { resolveInvoked = true; });
var rejectInvoked = false;
var reject = new RejectedCallback(reason => { rejectInvoked = true; });
// act
var deferred = scheduler.Object.Defer<object>();
deferred.Promise.Then(resolve, reject);
var resolved = deferred.Resolve(new object());
var rejected = deferred.Reject(new Exception());
// assert
Assert.That(resolved, Is.True, "Expect the resolve call to be successful");
Assert.That(resolveInvoked, Is.True, "Expect the resolve callback to be invoked");
Assert.That(rejected, Is.False, "Did not expect the reject call to be successful");
Assert.That(rejectInvoked, Is.False, "Did not expect the reject callback to be invoked");
}
public void RejectBeforeAttachingHandler()
{
// arrange
var result = new Exception();
var callbackInvoked = false;
var callback = new RejectedCallback(res => { callbackInvoked = true; });
var scheduler = new Mock<IScheduler>();
scheduler.Setup(s => s.Schedule(It.IsAny<Action>())).Callback<Action>(action => action());
// act
var deferred = scheduler.Object.Defer<object>();
deferred.Reject(result);
deferred.Promise.Then(value => { }, callback);
// assert
scheduler.VerifyAll();
Assert.That(callbackInvoked, Is.True);
}
