public void Should_throw_when_retrieving_using_Indexer_when_key_is_null()
{
string key = null;
IsPolicy policy = null;
_registry.Invoking(r => policy = r[key])
.Should().Throw <ArgumentNullException>();
}
public void Should_throw_while_retrieving_when_key_does_not_exist_using_Indexer()
{
string key = Guid.NewGuid().ToString();
IsPolicy outPolicy = null;
_registry.Invoking(r => outPolicy = r[key])
.Should().Throw <KeyNotFoundException>();
}
public IProxyConfig <T> For(Expression <Action <T> > methodExpression, IsPolicy policy)
{
var methodCall = methodExpression.Body as MethodCallExpression;
if (methodCall != null)
{
_policyMapping.Add(mi => mi == methodCall.Method ? policy : null);
}
return(this);
}
private void QueueTasks(int parallelism, bool useCollapser, bool sameKey, IKeyStrategy overrideKeyStrategy = null)
{
IsPolicy policy = GetPolicy(useCollapser, overrideKeyStrategy);
for (int i = 0; i < parallelism; i++)
{
string key = sameKey ? SharedKey : i.ToString();
Context context = new Context(key);
ConcurrentTasks[i] = ExecuteThroughPolicy(policy, context, i, true);
}
}
protected override Task ExecuteThroughPolicy(IsPolicy policy, Context context, int j, bool gated)
{
return(Task.Factory.StartNew(() =>
{
if (gated)
{
QueueTaskAtHoldingGate();
}
((ISyncPolicy)policy).Execute(ctx => UnderlyingExpensiveWork(j), context);
}, TaskCreationOptions.LongRunning));
}
protected override Task ExecuteThroughPolicy(IsPolicy policy, Context context, int j, bool gated)
{
return(Task.Factory.StartNew(async() =>
{
if (gated)
{
QueueTaskAtHoldingGate();
}
return await((IAsyncPolicy <ResultClass>)policy).ExecuteAsync(ctx =>
{
UnderlyingExpensiveWork(j);
return Task.FromResult(ResultFactory());
}, context);
}, TaskCreationOptions.LongRunning).Unwrap());
}
protected abstract Task ExecuteThroughPolicy(IsPolicy policy, Context context, int j, bool gated);
public IProxyConfig <T> Default(IsPolicy policy)
{
_defaultPolicy = policy;
return(this);
}
public IProxyConfig <T> When(Func <MethodInfo, bool> predicate, IsPolicy policy)
{
_policyMapping.Add(mi => predicate.Invoke(mi) ? policy : null);
return(this);
}
public IProxyConfig <T> For(string methodName, IsPolicy policy)
{
_policyMapping.Add(mi => mi.Name == methodName ? policy : null);
return(this);
}
internal PolicyWrap(Action <Action <Context, CancellationToken>, Context, CancellationToken> policyAction, Policy outer, ISyncPolicy inner)
: base(policyAction, outer.ExceptionPredicates)
{
_outer = outer;
_inner = inner;
}
public void Use(Policy policy)
{
_policy = policy;
}
public void Use(AsyncPolicy policy)
{
_policy = policy;
}
