public void Should_handle_handled_fault_and_execute_fallback_following_faulting_action_execution_when_user_delegate_does_not_observe_cancellationtoken()
{
bool fallbackActionExecuted = false;
Func <ResultPrimitive> fallbackAction = () => { fallbackActionExecuted = true; return(ResultPrimitive.Substitute); };
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
FallbackPolicy <ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.OrResult(ResultPrimitive.FaultAgain)
.Fallback(fallbackAction);
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = 1,
ActionObservesCancellation = false
};
policy.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute, ResultPrimitive.Fault)
.Should().Be(ResultPrimitive.Substitute);
attemptsInvoked.Should().Be(1);
fallbackActionExecuted.Should().BeTrue();
}
public void Should_report_cancellation_during_faulting_last_retry_execution_when_user_delegate_does_observe_cancellationToken()
{
RetryPolicy <ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.Retry(3);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = 1 + 3,
ActionObservesCancellation = true
};
policy.Invoking(x => x.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Good))
.Should().Throw <OperationCanceledException>()
.And.CancellationToken.Should().Be(cancellationToken);
attemptsInvoked.Should().Be(1 + 3);
}
public void Should_report_faulting_from_faulting_last_retry_execution_when_user_delegate_does_not_observe_cancellation_raised_during_last_retry()
{
RetryPolicy <ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.Retry(3);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = 1 + 3,
ActionObservesCancellation = false
};
policy.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Good)
.Should().Be(ResultPrimitive.Fault);
attemptsInvoked.Should().Be(1 + 3);
}
public void Should_execute_all_tries_when_faulting_and_cancellationToken_not_cancelled()
{
RetryPolicy <ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.Retry(3);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = null,
};
policy.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Good)
.Should().Be(ResultPrimitive.Good);
attemptsInvoked.Should().Be(1 + 3);
}
public void Should_report_cancellation_after_faulting_action_execution_and_cancel_further_retries_if_onRetry_invokes_cancellation()
{
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
RetryPolicy <ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.Retry(3, (_, __) =>
{
cancellationTokenSource.Cancel();
});
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = null, // Cancellation during onRetry instead - see above.
ActionObservesCancellation = false
};
policy.Invoking(x => x.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Good))
.Should().Throw <OperationCanceledException>()
.And.CancellationToken.Should().Be(cancellationToken);
attemptsInvoked.Should().Be(1);
}
public static TResult RaiseResultSequenceAndOrCancellation <TResult>(this Policy <TResult> policy,
Scenario scenario, CancellationTokenSource cancellationTokenSource, Action onExecute,
params TResult[] resultsToRaise)
{
return(policy.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute,
resultsToRaise.ToList()));
}
public void Should_not_execute_action_when_cancellationToken_cancelled_before_execute()
{
RetryPolicy <ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.Retry(3);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = null, // Cancellation token cancelled manually below - before any scenario execution.
};
cancellationTokenSource.Cancel();
policy.Invoking(x => x.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Good))
.Should().Throw <OperationCanceledException>()
.And.CancellationToken.Should().Be(cancellationToken);
attemptsInvoked.Should().Be(0);
}
public void Should_not_execute_action_when_cancellationtoken_cancelled_before_execute()
{
bool fallbackActionExecuted = false;
Func <ResultPrimitive> fallbackAction = () => { fallbackActionExecuted = true; return(ResultPrimitive.Substitute); };
FallbackPolicy <ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.OrResult(ResultPrimitive.FaultAgain)
.Fallback(fallbackAction);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = null, // Cancellation token cancelled manually below - before any scenario execution.
};
cancellationTokenSource.Cancel();
policy.Invoking(x => x.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute, ResultPrimitive.Fault))
.ShouldThrow <OperationCanceledException>()
.And.CancellationToken.Should().Be(cancellationToken);
attemptsInvoked.Should().Be(0);
fallbackActionExecuted.Should().BeFalse();
}
public void Should_report_cancellation_and_not_execute_fallback_during_otherwise_non_faulting_action_execution_when_user_delegate_observes_cancellationtoken_and_fallback_does_not_handle_cancellations()
{
bool fallbackActionExecuted = false;
Func <ResultPrimitive> fallbackAction = () => { fallbackActionExecuted = true; return(ResultPrimitive.Substitute); };
FallbackPolicy <ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.OrResult(ResultPrimitive.FaultAgain)
.Fallback(fallbackAction);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = 1,
ActionObservesCancellation = true
};
policy.Invoking(x => x.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute, ResultPrimitive.Good))
.ShouldThrow <OperationCanceledException>()
.And.CancellationToken.Should().Be(cancellationToken);
attemptsInvoked.Should().Be(1);
fallbackActionExecuted.Should().BeFalse();
}
public void Should_execute_action_when_non_faulting_and_cancellationtoken_not_cancelled()
{
bool fallbackActionExecuted = false;
Func <ResultPrimitive> fallbackAction = () => { fallbackActionExecuted = true; return(ResultPrimitive.Substitute); };
FallbackPolicy <ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.OrResult(ResultPrimitive.FaultAgain)
.Fallback(fallbackAction);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = null,
};
policy.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute, ResultPrimitive.Good)
.Should().Be(ResultPrimitive.Good);
attemptsInvoked.Should().Be(1);
fallbackActionExecuted.Should().BeFalse();
}
public static TResult RaiseResultSequenceAndOrCancellation <TResult>(this Policy <TResult> policy, Scenario scenario, CancellationTokenSource cancellationTokenSource, Action onExecute, IEnumerable <TResult> resultsToRaise)
{
int counter = 0;
CancellationToken cancellationToken = cancellationTokenSource.Token;
using (var enumerator = resultsToRaise.GetEnumerator())
{
return(policy.Execute(ct =>
{
onExecute();
counter++;
if (!enumerator.MoveNext())
{
throw new ArgumentOutOfRangeException(nameof(resultsToRaise), $"Not enough {typeof(TResult).Name} values in {nameof(resultsToRaise)}.");
}
if (scenario.AttemptDuringWhichToCancel.HasValue && counter >= scenario.AttemptDuringWhichToCancel.Value)
{
cancellationTokenSource.Cancel();
}
if (scenario.ActionObservesCancellation)
{
ct.ThrowIfCancellationRequested();
}
return enumerator.Current;
}, cancellationToken));
}
}
public void Should_report_cancellation_after_faulting_action_execution_and_cancel_further_retries_if_onRetry_invokes_cancellation()
{
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
RetryPolicy<ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.Retry(3, (_, __) =>
{
cancellationTokenSource.Cancel();
});
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = null, // Cancellation during onRetry instead - see above.
ActionObservesCancellation = false
};
policy.Invoking(x => x.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Good))
.ShouldThrow<OperationCanceledException>()
.And.CancellationToken.Should().Be(cancellationToken);
attemptsInvoked.Should().Be(1);
}
public void Should_report_faulting_from_faulting_last_retry_execution_when_user_delegate_does_not_observe_cancellation_raised_during_last_retry()
{
RetryPolicy<ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.Retry(3);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = 1 + 3,
ActionObservesCancellation = false
};
policy.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Good)
.Should().Be(ResultPrimitive.Fault);
attemptsInvoked.Should().Be(1 + 3);
}
public void Should_report_cancellation_during_faulting_last_retry_execution_when_user_delegate_does_observe_cancellationtoken()
{
RetryPolicy<ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.Retry(3);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = 1 + 3,
ActionObservesCancellation = true
};
policy.Invoking(x => x.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Good))
.ShouldThrow<OperationCanceledException>()
.And.CancellationToken.Should().Be(cancellationToken);
attemptsInvoked.Should().Be(1 + 3);
}
public void Should_not_execute_action_when_cancellationtoken_cancelled_before_execute()
{
RetryPolicy<ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.Retry(3);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = null, // Cancellation token cancelled manually below - before any scenario execution.
};
cancellationTokenSource.Cancel();
policy.Invoking(x => x.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Good))
.ShouldThrow<OperationCanceledException>()
.And.CancellationToken.Should().Be(cancellationToken);
attemptsInvoked.Should().Be(0);
}
public void Should_execute_action_when_non_faulting_and_cancellationtoken_not_cancelled()
{
var durationOfBreak = TimeSpan.FromMinutes(1);
CircuitBreakerPolicy<ResultPrimitive> breaker = Policy
.HandleResult(ResultPrimitive.Fault)
.CircuitBreaker(2, durationOfBreak);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = null,
};
breaker.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute,
ResultPrimitive.Good)
.Should().Be(ResultPrimitive.Good);
attemptsInvoked.Should().Be(1);
}
public void Should_handle_handled_fault_and_execute_fallback_following_faulting_action_execution_when_user_delegate_does_not_observe_cancellationtoken()
{
bool fallbackActionExecuted = false;
Func<ResultPrimitive> fallbackAction = () => { fallbackActionExecuted = true; return ResultPrimitive.Substitute; };
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
FallbackPolicy<ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.OrResult(ResultPrimitive.FaultAgain)
.Fallback(fallbackAction);
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = 1,
ActionObservesCancellation = false
};
policy.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute, ResultPrimitive.Fault)
.Should().Be(ResultPrimitive.Substitute);
attemptsInvoked.Should().Be(1);
fallbackActionExecuted.Should().BeTrue();
}
public void Should_report_cancellation_and_not_execute_fallback_during_otherwise_non_faulting_action_execution_when_user_delegate_observes_cancellationtoken_and_fallback_does_not_handle_cancellations()
{
bool fallbackActionExecuted = false;
Func<ResultPrimitive> fallbackAction = () => { fallbackActionExecuted = true; return ResultPrimitive.Substitute; };
FallbackPolicy<ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.OrResult(ResultPrimitive.FaultAgain)
.Fallback(fallbackAction);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = 1,
ActionObservesCancellation = true
};
policy.Invoking(x => x.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute, ResultPrimitive.Good))
.ShouldThrow<OperationCanceledException>()
.And.CancellationToken.Should().Be(cancellationToken);
attemptsInvoked.Should().Be(1);
fallbackActionExecuted.Should().BeFalse();
}
public void Should_not_execute_action_when_cancellationtoken_cancelled_before_execute()
{
bool fallbackActionExecuted = false;
Func<ResultPrimitive> fallbackAction = () => { fallbackActionExecuted = true; return ResultPrimitive.Substitute; };
FallbackPolicy<ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.OrResult(ResultPrimitive.FaultAgain)
.Fallback(fallbackAction);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = null, // Cancellation token cancelled manually below - before any scenario execution.
};
cancellationTokenSource.Cancel();
policy.Invoking(x => x.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute, ResultPrimitive.Fault))
.ShouldThrow<OperationCanceledException>()
.And.CancellationToken.Should().Be(cancellationToken);
attemptsInvoked.Should().Be(0);
fallbackActionExecuted.Should().BeFalse();
}
public void Should_execute_action_when_non_faulting_and_cancellationtoken_not_cancelled()
{
bool fallbackActionExecuted = false;
Func<ResultPrimitive> fallbackAction = () => { fallbackActionExecuted = true; return ResultPrimitive.Substitute; };
FallbackPolicy<ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.OrResult(ResultPrimitive.FaultAgain)
.Fallback(fallbackAction);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = null,
};
policy.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute, ResultPrimitive.Good)
.Should().Be(ResultPrimitive.Good);
attemptsInvoked.Should().Be(1);
fallbackActionExecuted.Should().BeFalse();
}
public void Should_report_faulting_from_faulting_action_execution_when_user_delegate_does_not_observe_cancellation()
{
var durationOfBreak = TimeSpan.FromMinutes(1);
CircuitBreakerPolicy<ResultPrimitive> breaker = Policy
.HandleResult(ResultPrimitive.Fault)
.CircuitBreaker(2, durationOfBreak);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = 1,
ActionObservesCancellation = false
};
breaker.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute, ResultPrimitive.Fault)
.Should().Be(ResultPrimitive.Fault);
attemptsInvoked.Should().Be(1);
}
public void Should_report_cancellation_when_both_open_circuit_and_cancellation()
{
CircuitBreakerPolicy<ResultPrimitive> breaker = Policy
.HandleResult(ResultPrimitive.Fault)
.CircuitBreaker(1, TimeSpan.FromMinutes(1));
breaker.RaiseResultSequence(ResultPrimitive.Fault)
.Should().Be(ResultPrimitive.Fault);
breaker.Invoking(x => x.RaiseResultSequence(ResultPrimitive.Fault))
.ShouldThrow<BrokenCircuitException>()
.WithMessage("The circuit is now open and is not allowing calls.");
// Circuit is now broken.
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
cancellationTokenSource.Cancel();
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = null, // Cancelled manually instead - see above.
ActionObservesCancellation = false
};
breaker.Invoking(x => x.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute,
ResultPrimitive.Fault,
ResultPrimitive.Good))
.ShouldThrow<OperationCanceledException>()
.And.CancellationToken.Should().Be(cancellationToken);
attemptsInvoked.Should().Be(0);
}
public void Should_execute_all_tries_when_faulting_and_cancellationtoken_not_cancelled()
{
RetryPolicy<ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.Retry(3);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = null,
};
policy.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Fault,
ResultPrimitive.Good)
.Should().Be(ResultPrimitive.Good);
attemptsInvoked.Should().Be(1 + 3);
}
public void Should_report_cancellation_during_faulting_action_execution_when_user_delegate_observes_cancellationtoken()
{
var durationOfBreak = TimeSpan.FromMinutes(1);
CircuitBreakerPolicy<ResultPrimitive> breaker = Policy
.HandleResult(ResultPrimitive.Fault)
.CircuitBreaker(2, durationOfBreak);
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;
int attemptsInvoked = 0;
Action onExecute = () => attemptsInvoked++;
Scenario scenario = new Scenario
{
AttemptDuringWhichToCancel = 1,
ActionObservesCancellation = true
};
breaker.Invoking(x => x.RaiseResultSequenceAndOrCancellation(scenario, cancellationTokenSource, onExecute,
ResultPrimitive.Fault,
ResultPrimitive.Good))
.ShouldThrow<OperationCanceledException>()
.And.CancellationToken.Should().Be(cancellationToken);
attemptsInvoked.Should().Be(1);
}
