text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>Span");
}
[Fact]
public void SlidingExpirationKey_is_correct()
{
// Assert
ContextualTtl.SlidingExpirationKey.ShouldBe("ContextualTtlSliding");
}
[Fact]
public void ContextualTtl_behaves_correctly_for_no_ttl()
{
// Arrange
var target = new ... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Caching;
public class DefaultCacheKeyStrategySpecs
{
[Fact]
public void Should_throw_when_context_is_null()
{
Context context = null!;
Action action = () => DefaultCacheKeyStrategy.Instance.GetCacheKey(context);
Should.Throw<ArgumentNul<|fim_suff... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Caching;
[Collection(Constants.SystemClockDependentTestCollection)]
public class GenericCacheProviderAsyncSpecs : IDisposable
{
[Fact]
public async Task Should_not_error_for_executions_on_non_nullable_types_if_cache_does_not_hold_value()
{
const string Operation... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Caching;
[Collection(Constants.SystemClockDependentTestCollection)]
public class GenericCacheProviderSpecs : IDisposable
{
[Fact]
public void Should_not_error_for_executions_on_non_nullable_types_if_cache_does_not_hold_value()
{
const string OperationKey = "Some... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>lidingExpiration.ShouldBeFalse();
}
[Fact]
public void Should_return_configured_timespan_from_time_requested()
{
DateTimeOffset fixedTime = SystemClock.DateTimeOffsetUtcNow();
TimeSpan ttl = TimeSpan.FromSeconds(30);
TimeSpan delay = TimeSpan.FromSeconds(5);
... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Caching;
public class ResultTtlSpecs
{
[Fact]
public void Should_throw_when_func_is_null()
{
<|fim_suffix|> Should.Throw<ArgumentNullException>(configure).ParamName.ShouldBe("ttlFunc");
}
[Fact]
public void Should_throw_when_func_is_null_using_context(... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>=> { serializeInvoked = true; return new StubSerialized(o); },
deserialize: s => s?.Original ?? default);
StubCacheProvider stubCacheProvider = new StubCacheProvider();
object? objectToCache = null;
string key = "some key";
SerializingCacheProvider<StubSerializ... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Caching;
public class SlidingTtlSpecs
{
[Fact]
public void Should_throw_when_timespan_is_less_than_zero()
{
Action configure = () => _ = new Sliding<|fim_suffix|> public void Should_return_configured_timespan()
{
TimeSpan ttl = TimeSpan.FromSeconds(3... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>tate.ShouldBe(CircuitState.Open);
onBreakCalled.ShouldBe(1);
SystemClock.UtcNow = () => time.Add(durationOfBreak);
// duration has passed, circuit now half open
onHalfOpenCalled.ShouldBe(0); // not yet transitioned to half-open, because we have not queried state
... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>rcuit.
breaker.CircuitState.ShouldBe(CircuitState.Open);
throw new DivideByZeroException();
}));
}, TaskCreationOptions.LongRunning);
permitMainThreadToOpenCircuit.WaitOne(testTimeoutToExposeDeadlocks).ShouldBeTrue();
// Break circuit ... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>rcuitState.ShouldBe(CircuitState.Closed);
// manually break circuit
breaker.Isolate();
breaker.CircuitState.ShouldBe(CircuitState.Isolated);
// circuit manually broken: execution should be blocked; even non-fault-returning executions should not reset circuit
bool ... | fim | App-vNext/Polly | csharp |
namespace Polly.Specs.CircuitBreaker;
[Collection(Constants.SystemClockDependentTestCollection)]
public class CircuitBreakerTResultMixedResultExceptionSpecs : IDisposable
{
#region Circuit-breaker threshold-to-break tests
[Fact]
public void Should_open_circuit_with_exception_after_specified_number_of_spe... | fim | App-vNext/Polly | csharp |
using Scenario = Polly.Specs.Helpers.PolicyTResultExtensions.ResultAndOrCancellationScenario;
namespace Polly.Specs.CircuitBreaker;
[Collection(Constants.SystemClockDependentTestCollection)]
public class CircuitBreakerTResultSpecs : IDisposable
{
#region Configuration tests
[Fact]
public void Should_thr... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.CircuitBreaker;
public class ICircuitBreakerPolicySpecs
{
[Fact]
public void Should_be_able_to_use_CircuitState_via_interface()
{
ICircuitBreakerPolicy breaker = Policy
.Handle<DivideByZeroException>()
.CircuitBreaker(2, TimeSpan.FromMinu... | fim | App-vNext/Polly | csharp |
namespace Polly.Specs.CircuitBreaker;
public class ICircuitBreakerTResultPolicySpecs
{
[Fact]
public void Should_be_able_to_use_LastHandledResult_via_interface()
{
var breaker = Policy
.HandleResult(ResultPrimitive.Fault)
.CircuitBreaker(2, TimeSpan.FromMinutes(1));
... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>Seconds(2);
health.Add(metrics.GetHealthCount_NeedsLock());
health[0].ShouldBeEquivalentTo(new HealthCount { Successes = 1, Failures = 1, StartedAt = startedAt.AddSeconds(0).Ticks });
health[1].ShouldBeEquivalentTo(new HealthCount { Successes = 2, Failures = 2, StartedAt = started... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs;
public class ContextSpecs
{
[Fact]
public void Should_assign_OperationKey_from_constructor()
{
Context con<|fim_suffix|>nKey_and_context_data_from_constructor()
{
Context context = new Context("SomeKey", CreateDictionary("key1", "value1", "key2", "v... | fim | App-vNext/Polly | csharp |
namespace Polly.Specs.Custom;
public class CustomAsyncSpecs
{
[Fact]
public void Should_be_able_to_construct_active_policy()
{
Action construct = () =>
{
AsyncPreExecutePolicy policy = AsyncPreExecutePolicy.CreateAsync(async () =>
{
Console.WriteLine... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>ePolicy.Create(() => Console.WriteLine("Do something"));
};
Should.NotThrow(construct);
}
[Fact]
public void Active_policy_should_execute()
{
bool preExecuted = false;
PreExecutePolicy policy = PreExecutePolicy.Create(() => preExecuted = true);
bo... | fim | App-vNext/Polly | csharp |
<|fim_suffix|> ResultPrimitive handled = ResultPrimitive.Undefined;
AsyncAddBehaviourIfHandlePolicy<ResultPrimitive> policy = Policy
.HandleResult(ResultPrimitive.Fault)
.WithBehaviourAsync(async outcome => { handled = outcome.Result; await Task.CompletedTask; });
ResultPrimitiv... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>ehaviourIfHandlePolicy<ResultPrimitive> policy = Policy.HandleResult(ResultPrimitive.Fault).WithBehaviour(outcome => handled = outcome.Result);
ResultPrimitive toReturn = ResultPrimitive.Fault;
bool executed = false;
policy.Execute(() =>
{
executed = t... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs;
public static class DictionaryHelpers
{
public static Dictionary<TKey, object> CreateDictionar<|fim_suffix|> => new() { [key] = value };
public static Dictionary<TKey, object> CreateDictionary<TKey>(TKey key1, object value1, TKey key2, object value2)
where TKey : n... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>ationTokenSource.Token;
await Should.NotThrowAsync(() => policy.RaiseExceptionAndOrCancellationAsync<DivideByZeroException>(scenario, cancellationTokenSource, onExecute));
}
attemptsInvoked.ShouldBe(1);
fallbackActionExecuted.ShouldBeTrue();
}
[Fact]
pub... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>g_exception_triggering_fallback()
{
bool fallbackActionExecuted = false;
Action fallbackAction = () => fallbackActionExecuted = true;
Exception? exceptionPassedToOnFallback = null;
Action<Exception> onFallback = ex => exceptionPassedToOnFallback = ex;
Fallback... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>using Scenario = Polly.Specs.Helpers.PolicyTResultExtensionsAsync.ResultAndOrCancellationScenario;
namespace Polly.Specs.Fallback;
public class FallbackTResultAsyncSpecs
{
#region Configuration guard condition tests
[Fact]
public void Should_throw_when_action_is_null()
{
var fl... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>using Scenario = Polly.Specs.Helpers.PolicyTResultExtensions.ResultAndOrCancellationScenario;
namespace Polly.Specs.Fallback;
public class FallbackTResultSpecs
{
#region Configuration guard condition tests
[Fact]
public void Should_throw_when_action_is_null()
{
var flags = Bind... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>adonly object[] _noArgs = [];
private readonly ITestOutputHelper _innerOutputHelper;
public AnnotatedOutputHelper(ITestOutputHelper innerOutputHelper) =>
_innerOutputHelper = innerOutputHelper ?? throw new ArgumentNullException(nameof(innerOutputHelper));
public void Flush()
{
... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Helpers.Bulkhead;
public class AssertionFailure
{
public AssertionFailure(int expected, int actual, string measure)
{
if (string.IsNullOrWhiteSpace(measure))
{
throw new ArgumentNullException(nameo<|fim_suffix|>; }
public int Actual { get; }
... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Helpers.Bulkhead;
public class SilentOutputHelper : ITestOutputHelper
{
public void WriteLine(string messa<|fim_suffix|> public void WriteLine(string format, params object[] args)
{
// Do nothing: intentionally silent.
}
}
<|fim_middle|>ge)
{
// Do ... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>ertions may be occurring) in that it releases a semaphore slot sucessfully.
// There can also be races between assertions and executions-responding-to-previous-state-changes, so a second signal presents another opportunity for assertions to be run.
SignalStateChange();
... | fim | App-vNext/Polly | csharp |
<|fim_suffix|> QueueingForSemaphore,
Executing,
Rejected,
Canceled,
Faulted,
Completed,
}
<|fim_prefix|>namespace Polly.Specs.Helpers.Bulkhead;
/// <summary>
/// States of a <see cref="TraceableAction"/> that can be tracked during testing.
/// </summary>
pu<|fim_middle|>blic enum TraceableActionS... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Helpers.Caching;
/// <summary>
/// A configurable stub ICacheKeyStrategy, to support te<|fim_suffix|>trategy = strategy;
public string GetCacheKey(Context context) =>
_strategy(context);
}
<|fim_middle|>sts..
/// </summary>
internal class StubCacheKeyStrategy : ICacheK... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>
public Task<(bool, object?)> TryGetAsync(string key, CancellationToken cancellationToken, bool continueOnCapturedContext) =>
Task.FromResult(TryGet(key));
public Task PutAsync(string key, object? value, Ttl ttl, CancellationToken cancellationToken, bool continueOnCapturedContext)
{
... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Helpers.Caching;
internal class StubErroringCacheProvider : ISyncCacheProvider, IAsyncCacheProvider
{
private readonly Exception? _getException;
private readonly Exception? _putException;
private readonly StubCacheProvider _innerProvider = new();
public StubErrori... | fim | App-vNext/Polly | csharp |
<|fim_suffix|> : base(obj)
{
}
}
<|fim_prefix|>namespace Polly.Specs.Helpers.Caching;
/// <summary>
/// An intentionally naive class to be the simplest thing possible to support tests around serializing cache providers. This serialization does nothing but wrap the object to be serialized.
/// </summary>
/... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Helpers.Caching;
/// <summary>
/// A configurable stub serializer implementation to support tests around serializing cache providers.
/// </summary>
/// <typeparam name="TResult">The type of the results being cached.</typeparam>
/// <typeparam name="TSerialized">The type of the se... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>rallel threads.
/// </summary>
/// <remarks>These tests are not run in parallel with each other, to reduce heavy use of threads in the build/CI environment.</remarks>
public const string ParallelThreadDependentTestCollection = "ParallelThreadDependentTestCollection";
}
<|fim_prefix|>namespace... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>ta, configureException);
}
<|fim_prefix|>namespace Polly.Specs.Helpers;
public static class ContextualPolicyExtensions
{
public static void RaiseException<TException>(this Policy policy,
int numberOfTimesToRaiseException,
IDictionary<string, object> contextData,
Action<TExcep... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>tionToken);
}
<|fim_prefix|>namespace Polly.Specs.Helpers;
public static class ContextualPolicyExtensionsAsync
{
public static Task RaiseExceptionAsync<TException>(this AsyncPolicy policy, int numberOfTimesToRaiseException, IDictionary<string, object> contextData, Action<TException, int>? configureE... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>entOutOfRangeException(nameof(resultsToRaise), "Not enough TResult values in resultsToRaise.");
}
return enumerator.Current;
}, contextData);
}
}
<|fim_prefix|>namespace Polly.Specs.Helpers;
public static class ContextualPolicyTResultE<|fim_middle|>xtensions
{
pu... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>ough TResult values in resultsToRaise.");
}
return Task.FromResult(enumerator.Current);
}, contextData);
}
}
<|fim_prefix|>namespace Polly.Specs.Helpers;
public static class ContextualPolicyTResultExtensionsAsync
{
public static Task<TResult> RaiseResultSequenceA... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Helpers.Custom.AddBehaviourIfHandle;
internal static class AddBehaviourIfHandleEngi<|fim_suffix|>edException = shouldHandleExceptionPredicates.FirstMatchOrDefault(ex);
if (handledException == null)
{
throw;
}
behaviou... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>plementation(
ExceptionPredicates,
ResultPredicates,
_behaviourIfHandle,
action,
context,
cancellationToken);
}
<|fim_prefix|>namespace Polly.Specs.Helpers.Custom.AddBehaviourIfHandle;
internal class AddBehaviourIfHandlePolicy : Pol... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Helpers.Custom.AddBehaviourIfHandle;
internal static class AddBehaviourIfHandleSyntax
{
internal static AddBehaviourIfHandlePolicy WithBehaviour(this PolicyBuilder policyBuilder<|fim_suffix|>haviourIfHandle.ShouldNotBeNull();
return new AddBehaviourIfHandlePolicy<TResul... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Helpers.Custom.AddBehaviourIfHandle;
internal static class AsyncAddBehaviourIfHandleEngine
{
internal static async Task<TResult> ImplementationAsync<TResult>(
ExceptionPredicates shouldHandleExceptionPredicates,
ResultPredicates<TResult> shouldHandl<|fim_suffix|... | fim | App-vNext/Polly | csharp |
namespace Polly.Specs.Helpers.Custom.AddBehaviourIfHandle;
internal class AsyncAddBehaviourIfHandlePolicy : AsyncPolicy
{
private readonly Func<Exception, Task> _behaviourIfHandle;
internal AsyncAddBehaviourIfHandlePolicy(
Func<Exception, Task> behaviourIfHandle,
PolicyBuilder policyBuilder)
... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>umentNullException(nameof(behaviourIfHandle));
}
return new AsyncAddBehaviourIfHandlePolicy<TResult>(behaviourIfHandle, policyBuilder);
}
}
<|fim_prefix|>namespace Polly.Specs.Helpers.Custom<|fim_middle|>.AddBehaviourIfHandle;
internal static class AsyncAddBehaviourIfHandleSyntax
{
... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>ntinueOnCapturedContext);
await action(context, cancellationToken).ConfigureAwait(continueOnCapturedContext);
}
internal static async Task<TResult> ImplementationAsync<TResult>(
Func<Task> preExecute,
Func<Context, CancellationToken, Task<TResult>> action,
Context... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>uredContext);
}
<|fim_prefix|>namespace Polly.Specs.Helpers.Custom.PreExecute;
internal class AsyncPreExecutePolicy : AsyncPolicy
{
private readonly Func<Task> _preExecute;
public static AsyncPreExecutePolicy CreateAsync(Func<Task> preExecute) => new(preExecute);
internal AsyncPreExecutePo... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Helpers.Custom.PreExecute;
internal static class PreExecuteEngine
{
internal static void Implementation(
Action preExecute,
<|fim_suffix|> }
internal static TResult Implementation<TResult>(
Action preExecute,
Func<Context, CancellationToken, TResul... | fim | App-vNext/Polly | csharp |
namespace Polly.Specs.Helpers.Custom.PreExecute;
internal class PreExecutePolicy : Policy
{
private readonly Action _preExecute;
public static PreExecutePolicy Create(Action preExecute) => new(preExecute);
internal PreExecutePolicy(Action preExecute) =>
_preExecute = preExecute ?? throw new Argu... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>ce cancellationTokenSource, Action onExecute, Func<int, TException> exceptionFactory, TResult successResult)
where TException : Exception
{
int counter = 0;
CancellationToken cancellationToken = cancellationTokenSource.Token;
return policy.Execute(ct =>
{
... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>tory, TResult successResult)
where TException : Exception
{
int counter = 0;
CancellationToken cancellationToken = cancellationTokenSource.Token;
return policy.ExecuteAsync(ct =>
{
onExecute();
counter++;
if (scenario.Atte... | fim | App-vNext/Polly | csharp |
using Scenario = Polly.Specs.Helpers.PolicyTResultExtensions.ResultAndOrCancellationScenario;
namespace Polly.Specs.Helpers;
public static class PolicyTResultExtensions
{
public static TResult RaiseResultSequence<TResult>(this Policy<TResult> policy, params TResult[] resultsToRaise) =>
policy.RaiseResult... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>using Scenario = Polly.Specs.Helpers.PolicyTResultExtensionsAsync.ResultAndOrCancellationScenario;
namespace Polly.Specs.Helpers;
public static class PolicyTResultExtensionsAsync
{
public static Task<TResult> RaiseResultSequenceAsync<TResult>(this AsyncPolicy<TResult> policy, params TResult[] resul... | fim | App-vNext/Polly | csharp |
<|fim_suffix|> numberOfExecutions; execution++)
{
rateLimiter.ShouldPermitAnExecution();
}
}
public static void ShouldNotPermitAnExecution(this IRateLimiter rateLimiter, TimeSpan? retryAfter = null)
{
(bool PermitExecution, TimeSpan RetryAfter) canExecute = rateLimiter.P... | fim | App-vNext/Polly | csharp |
<|fim_suffix|> ResultClassWithRetryAfter : ResultClass
{
public TimeSpan RetryAfter { get; }
public ResultClassWithRetryAfter(ResultPrimitive result)
: base(result) =>
RetryAfter = TimeSpan.Zero;
public ResultClassWithRetryAfter(TimeSpan retryAfter)
: base(ResultPrimitive.Undefined) =>
... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>ultCode, null)
{
}
public ResultPrimitive ResultCode { get; set; } = resultCode;
public string? SomeString { get; set; } = someString;
}
<|fim_prefix|>namespace Polly.Specs.Helpers;
/// <summary>
/// A helper class supporting tests on how Policy<TResult> policies handle return re... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>teverButTooLate
}
<|fim_prefix|>namespace Polly.Specs.Helpers;
/// <summary>
/// A helper class<|fim_middle|> supporting tests on how Policy<TResult> policies may handle return results which are primitive types such as ints or enums.
/// </summary>
internal enum ResultPrimitive
{
Undefined,
... | fim | App-vNext/Polly | csharp |
namespace Polly.Specs;
public class IAsyncPolicyExtensionsSpecs
{
[Fact]
public void Converting_a_nongeneric_IAsyncPolicy_to_generic_should_return_a_generic_IAsyncPolicyTResult()
{
IAsyncPolicy nonGenericPolicy = Policy.TimeoutAsync(10);
var genericPolicy = nonGenericPolicy.AsAsyncPolicy<R... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs;
public class ISyncPolicyExtensionsSpecs
{
[Fact]
public void Converting_a_nongeneric_ISyncPolicy_to_generic_should_return_a_generic_ISyncPolicyTResult()
{
ISyncPolicy nonGenericPolicy = Policy.Timeout(10);
var genericPolicy = nonGenericPolicy.AsPolicy<R... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>lse;
using (var cts = new CancellationTokenSource())
{
cts.Cancel();
await Should.NotThrowAsync(() => policy.ExecuteAsync(
_ => { executed = true; return TaskHelper.EmptyTask; }, cts.Token));
}
executed.ShouldBeTrue();
}
}
<|fi... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.NoOp;
public class NoOpSpecs
{
[Fact]
public void Should_throw_when_action_is_null()
{
var flags = BindingFlags.NonPublic | BindingFlags.Instance;
Func<Context, CancellationToken, EmptyStruct> action = null!;
var instance = Activator.CreateInsta... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>ArgumentNullException>()
.ParamName.ShouldBe("action");
}
[Fact]
public async Task Should_execute_user_delegate()
{
var policy = Policy.NoOpAsync<int?>();
int? result = null;
await Should.NotThrowAsync(async () => result = await policy.ExecuteAsync(() ... | fim | App-vNext/Polly | csharp |
namespace Polly.Specs.NoOp;
public class NoOpTResultSpecs
{
[Fact]
public void Should_throw_when_action_is_null()
{
var flags = BindingFlags.NonPublic | BindingFlags.Instance;
Func<Context, CancellationToken, EmptyStruct> action = null!;
var instance = Activator.CreateInstance(typ... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs;
public class PolicyAsyncSpecs
{
#region Execute tests
[Fact]
public async Task Executing_the_policy_action_should_execute_the_specified_async_action()
{
bool executed = false;
var policy = Policy
.Handle<DivideByZeroException>()
... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>retry = Policy.Handle<Exception>().RetryAsync(1, onRetry).WithPolicyKey(policyKey);
await retry.RaiseExceptionAsync<Exception>(1);
policyKeySetOnExecutionContext.ShouldBe(policyKey);
}
[Fact]
public async Task Should_pass_OperationKey_to_execution_context()
{
str... | fim | App-vNext/Polly | csharp |
namespace Polly.Specs;
public class PolicyKeySpecs
{
#region Configuration
[Fact]
public void Should_be_able_fluently_to_configure_the_policy_key()
{
var policy = Policy.Handle<Exception>().Retry().WithPolicyKey(Guid.NewGuid().ToString());
policy.ShouldBeAssignableTo<Policy>();
}... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs;
public class PolicySpecs
{
#region Execute tests
[Fact]
public void Executing_the_policy_action_should_execute_the_specified_action()
{
var executed = false;
var policy = Policy
.Handle<DivideByZeroException>()
.Retry((_, _... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>act]
public async Task Executing_the_policy_function_successfully_should_return_success_result()
{
var result = await Policy
.HandleResult(ResultPrimitive.Fault)
.RetryAsync((_, _) => { })
.ExecuteAndCaptureAsync(() => Task.FromResult(ResultPrimitive.Goo... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs;
public class PolicyTResultKeyAsyncSpecs
{
#region Configuration
[Fact]
public void Should_be_able_fluently_to_configure_the_policy_key()
{
var policy = Policy.HandleResult(0).RetryAsync().WithPolicyKey(Guid.NewGuid().ToString());
policy.ShouldBeAs... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs;
public class PolicyTResultKeySpecs
{
#region Configuration
[Fact]
public void Should_be_able_fluently_to_configure_the_policy_key()
{
var policy = Policy.HandleResult(0).Retry().WithPolicyKey(Guid.NewGuid().ToString());
policy.ShouldBeAssignableTo... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>n ResultPrimitive.Good; }, executionContext);
capturedContext.ShouldNotBeNull();
capturedContext.ShouldBeSameAs(executionContext);
}
[Fact]
public void Execute_and_capturing_the_policy_function_should_pass_context_to_PolicyResult()
{
string operationKey = "SomeKey... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>eric = methodInfo.MakeGenericMethod(typeof(EmptyStruct));
var func = () => generic.Invoke(instance, [action, new Context(), CancellationToken, false]);
var exceptionAssertions = Should.Throw<TargetInvocationException>(func);
exceptionAssertions.Message.ShouldBe("Exception has bee... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.RateLimit;
[Collection(Constants.SystemClockDependentTestCollection)]
public class AsyncRateLimitPolicyTResultSpecs : RateLimitPolicyTResultSpecsBase, IDisposable
{
public void Dispose() =>
SystemClock.Reset();
protected override IRateLimitPolicy GetPolicyViaSyntax... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>tRateLimiterTestsBase
{
internal override IRateLimiter GetRateLimiter(TimeSpan onePer, long bucketCapacity) =>
new LockFreeTokenBucketRateLimiter(onePer, bucketCapacity);
}
<|fim_prefix|>namespace Polly.Specs.RateLimit;
public class L<|fim_middle|>ockFreeTokenBucketRateLimiterTests : TokenBu... | fim | App-vNext/Polly | csharp |
<|fim_suffix|> // Act
var exception = Should.Throw<ArgumentOutOfRangeException>(() => Policy.RateLimit(1, TimeSpan.FromSeconds(-1), 1));
// Assert
exception.Message.ShouldStartWith("perTimeSpan must be a positive timespan");
exception.ParamName.ShouldBe("perTimeSpan");
exce... | fim | App-vNext/Polly | csharp |
namespace Polly.Specs.RateLimit;
public abstract class RateLimitPolicySpecsBase : RateLimitSpecsBase
{
protected static CancellationToken CancellationToken => TestCancellation.Token;
protected abstract IRateLimitPolicy GetPolicyViaSyntax(
int numberOfExecutions,
TimeSpan perTimeSpan);
pr... | fim | App-vNext/Polly | csharp |
<|fim_suffix|> rateLimiter = new LockFreeTokenBucketRateLimiter(TimeSpan.FromSeconds(1), 1);
Func<TimeSpan, Context, EmptyStruct>? retryAfterFactory = null;
var instance = Activator.CreateInstance(
typeof(RateLimitPolicy<EmptyStruct>),
flags,
null,
[rateL... | fim | App-vNext/Polly | csharp |
namespace Polly.Specs.RateLimit;
public abstract class RateLimitPolicyTResultSpecsBase : RateLimitPolicySpecsBase
{
protected abstract IRateLimitPolicy<TResult> GetPolicyViaSyntax<TResult>(
int numberOfExecutions,
TimeSpan perTimeSpan,
int maxBurst,
Func<TimeSpan, Context, TResult>... | fim | App-vNext/Polly | csharp |
<|fim_suffix|> new RateLimitRejectedException(retryAfter).Message.ShouldBe($"The operation has been rate-limited and should be retried after {retryAfter}");
rate = new RateLimitRejectedException(retryAfter, exception);
rate.RetryAfter.ShouldBe(retryAfter);
rate.InnerException.ShouldBe(exceptio... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>
SystemClock.DateTimeOffsetUtcNow = () => now + advance;
}
protected static void AdvanceClock(long advanceTicks) =>
AdvanceClock(TimeSpan.FromTicks(advanceTicks));
}
<|fim_prefix|>namespace Polly.Specs.RateLimit;
public abstract class RateLimitSpecsBase
{
/// <summary>
/... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.RateLimit;
[Collection(Constants.SystemClockDependentTestCollection)]
public abstract class TokenBucketRateLimiterTestsBase : RateLimitSpecsBase, IDisposable
{
internal abstract IRateLimiter GetRateLimiter(TimeSpan onePer, long bucketCapacity);
public void Dispose() =>
... | fim | App-vNext/Polly | csharp |
namespace Polly.Specs.Registry;
public class ConcurrentPolicyRegistrySpecs
{
private readonly PolicyRegistry _registry = [];
[Fact]
public void Should_be_able_to_add_Policy_using_TryAdd()
{
Policy policy = Policy.NoOp();
string key = Guid.NewGuid().ToString();
var insert = _r... | fim | App-vNext/Polly | csharp |
<|fim_suffix|> Policy<ResultPrimitive> policy = Policy<ResultPrimitive>.HandleResult(ResultPrimitive.Fault).Retry();
string key = Guid.NewGuid().ToString();
_registry.Add(key, policy);
_registry.TryGet(key, out Policy<ResultPrimitive> outPolicy).ShouldBeTrue();
outPolicy.ShouldBeSameAs... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>ing();
ISyncPolicy<ResultPrimitive>? policy = null;
Should.Throw<KeyNotFoundException>(() => policy = ReadOnlyRegistry.Get<ISyncPolicy<ResultPrimitive>>(key));
policy.ShouldBeNull();
}
[Fact]
public void Should_throw_while_retrieving_when_key_does_not_exist_using_Index... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>using Polly.TestUtils;
namespace Polly.Specs;
public class ResiliencePipelineConversionExtensionsTests
{
private static readonly ResiliencePropertyKey<string> Incoming = new("incoming-key");
private static readonly ResiliencePropertyKey<string> Executing = new("executing-key");
private sta... | fim | App-vNext/Polly | csharp |
using Scenario = Polly.Specs.Helpers.PolicyExtensionsAsync.ExceptionAndOrCancellationScenario;
namespace Polly.Specs.Retry;
public class RetryAsyncSpecs
{
[Fact]
public void Should_throw_when_action_is_null()
{
var flags = BindingFlags.NonPublic | BindingFlags.Instance;
Func<Context, Canc... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>using Scenario = Polly.Specs.Helpers.PolicyExtensionsAsync.ExceptionAndOrCancellationScenario;
namespace Polly.Specs.Retry;
public class RetryForeverAsyncSpecs
{
[Fact]
public void Should_not_throw_if_arguments_are_valid()
{
Action policy = () => Policy
.HandleResult(Res... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>ct]
public void Should_call_onretry_on_each_retry_with_the_current_exception()
{
var expectedExceptions = new[] { "Exception #1", "Exception #2", "Exception #3" };
var retryExceptions = new List<Exception>();
var policy = Policy
.Handle<DivideByZeroException>()... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Retry;
public class RetrySpecs
{
[Fact]
public void Should_throw_when_action_is_null()
{
var flags = BindingFlags.NonPublic | BindingFlags.Instance;
Func<Context, CancellationToken, EmptyStruct> action = null!;
var policyBuilder = new PolicyBuild... | fim | App-vNext/Polly | csharp |
<|fim_suffix|> };
using (var cancellationTokenSource = new CancellationTokenSource())
{
CancellationToken cancellationToken = cancellationTokenSource.Token;
var ex = await Should.ThrowAsync<OperationCanceledException>(
() => policy.RaiseResultSequenceAndOr... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>ceptionSequence(new ResultClass(ResultPrimitive.Fault), new ArgumentException("message", "key"), new ResultClass(ResultPrimitive.Good));
result.ResultCode.ShouldBe(ResultPrimitive.Good);
}
[Fact]
public void Should_throw_if_exception_predicate_not_matched()
{
Policy<Result... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>using Scenario = Polly.Specs.Helpers.PolicyTResultExtensions.ResultAndOrCancellationScenario;
namespace Polly.Specs.Retry;
public class RetryTResultSpecs
{
[Fact]
public void Should_throw_when_action_is_null()
{
var flags = BindingFlags.NonPublic | BindingFlags.Instance;
Fun... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>using Scenario = Polly.Specs.Helpers.PolicyExtensionsAsync.ExceptionAndOrCancellationScenario;
namespace Polly.Specs.Retry;
[Collection(Constants.SystemClockDependentTestCollection)]
public class WaitAndRetryAsyncSpecs : IDisposable
{
public WaitAndRetryAsyncSpecs() => SystemClock.SleepAsync = (_, ... | fim | App-vNext/Polly | csharp |
using Scenario = Polly.Specs.Helpers.PolicyExtensionsAsync.ExceptionAndOrCancellationScenario;
namespace Polly.Specs.Retry;
[Collection(Constants.SystemClockDependentTestCollection)]
public class WaitAndRetryForeverAsyncSpecs : IDisposable
{
public WaitAndRetryForeverAsyncSpecs() => SystemClock.SleepAsync = (_, ... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Retry;
[Collection(Constants.SystemClockDependentTestCollection)]
public class WaitAndRetryForeverSpecs : IDisposable
{
public WaitAndRetryForeverSpecs() => SystemClock.Sleep = (_, _) => { };
[Fact]
public void Should_throw_when_sleep_duration_provider_is_null()
{
... | fim | App-vNext/Polly | csharp |
<|fim_suffix|> Should.NotThrow(policy);
policy = () => Policy
.HandleResult(ResultPrimitive.Fault)
.WaitAndRetryForeverAsync((_, _) => TimeSpan.Zero, (_, _, _) => TaskHelper.EmptyTask);
Should.NotThrow(policy);
policy = () => Policy
.HandleResult(Resul... | fim | App-vNext/Polly | csharp |
<|fim_prefix|>namespace Polly.Specs.Retry;
[Collection(Constants.SystemClockDependentTestCollection)]
public class WaitAndRetryForeverTResultSpecs : IDisposable
{
public WaitAndRetryForeverTResultSpecs() => SystemClock.Sleep = (_, _) => { };
[Fact]
public void Should_be_able_to_calculate_retry_timespans_... | fim | App-vNext/Polly | csharp |
<|fim_suffix|>++;
PolicyExtensions.ExceptionAndOrCancellationScenario scenario = new PolicyExtensions.ExceptionAndOrCancellationScenario
{
NumberOfTimesToRaiseException = 1 + 3,
AttemptDuringWhichToCancel = 2,
ActionObservesCancellation = true
};
usi... | fim | App-vNext/Polly | csharp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.