public async Task RetryPolicyTest_LinearJitterStrategyRetryPolicy_Success()
{
await RunWithTelemetryAsync(
totalOfExecutions : 1,
runInParallel : true,
handler : async execution => {
#region Arrange
var result = false;
var retryPolicy = new RetryPolicy(
"linearJitter",
new RetryPolicyParams(
maxAttempts: 3,
jitterStrategyType: JitterStrategyTypeEnum.Linear,
timeSpanBase: TimeSpan.FromSeconds(3),
customJitterTimeFunction: null
)
);
var totalOfFails = 0;
#endregion
#region Act
var sw = Stopwatch.StartNew();
var policyExecutionResultA = await retryPolicy.ExecutePolicyAsync(async(attempt) => {
return(await Task.FromResult(true));
});
var policyExecutionResultB = await retryPolicy.ExecutePolicyAsync(async(attempt) => {
var result = await Task.FromResult(attempt == 3);
if (!result)
{
totalOfFails++;
}
return(result);
});
sw.Stop();
result = policyExecutionResultA.success &&
policyExecutionResultB.success &&
sw.ElapsedMilliseconds >= 9_000 &&
sw.ElapsedMilliseconds <= 10_000 &&
totalOfFails == 2
;
#endregion
#region Assert
return(result);
#endregion
}
).ConfigureAwait(false);
}
public async Task RetryPolicyTest_CustomJitterStrategyRetryPolicy_Success()
{
await RunWithTelemetryAsync(
totalOfExecutions : 1,
runInParallel : true,
handler : async execution => {
#region Arrange
var result = false;
var retryPolicy = new RetryPolicy(
"exponentialJitter",
new RetryPolicyParams(
maxAttempts: 3,
jitterStrategyType: JitterStrategyTypeEnum.Custom,
timeSpanBase: TimeSpan.FromSeconds(2),
customJitterTimeFunction: attemp => {
return(TimeSpan.FromSeconds(attemp + 1));
}
)
);
#endregion
#region Act
var sw = Stopwatch.StartNew();
var policyExecutionResultA = await retryPolicy.ExecutePolicyAsync(async(attempt) => {
return(await Task.FromResult(true));
});
var policyExecutionResultB = await retryPolicy.ExecutePolicyAsync(async(attempt) => {
return(await Task.FromResult(attempt == 3));
});
sw.Stop();
result = policyExecutionResultA.success &&
policyExecutionResultB.success &&
sw.ElapsedMilliseconds >= 5_000 &&
sw.ElapsedMilliseconds <= 6_000
;
#endregion
#region Assert
return(result);
#endregion
}
).ConfigureAwait(false);
}
public async Task <(bool success, int attempt)> ExecutePolicyAsync(Func <int, Task <bool> > executionFunction)
{
if (CircuitState == CircuitStateEnum.Opened)
{
return(success : false, attempt : CurrentAttempt);
}
CurrentAttempt++;
var retryPatternPolicyResult = await _retryPolicy.ExecutePolicyAsync(executionFunction);
if (!retryPatternPolicyResult.success)
{
ChangeCircuitState(
CircuitStateEnum.Opened,
retryPatternPolicyResult.currentAttempt,
CurrentAttempt);
_ = Task.Run(() =>
{
Thread.Sleep(_windowSleepTime);
ChangeCircuitState(
CircuitStateEnum.HalfOpened,
retryPatternPolicyResult.currentAttempt,
CurrentAttempt
);
});
return(success : false, attempt : CurrentAttempt);
}
var successCurrentAttempt = CurrentAttempt;
if (CircuitState == CircuitStateEnum.HalfOpened)
{
ChangeCircuitState(
CircuitStateEnum.Closed,
retryPatternPolicyResult.currentAttempt,
CurrentAttempt
);
}
return(success : true, attempt : successCurrentAttempt);
}