public void Initialize()
{
_request1 = new MockRequestInfo("/path1/path2?param=value", "http", "test.com", 80);
_request2 = new MockRequestInfo("/path1/path2", "https", "secure.test.com", 443);
_request3 = new MockRequestInfo("/path1/path2/", "http", "test.com", 80);
_request1.NewPath[1] = "changed1";
_request1.NewParameters["param"] = new List <string> {
"changed"
};
_request1.PathChanged();
_request1.SetServerVariable("PATH_INFO", "/company/news/");
_request1.SetHeader("HOST", "www.mysite.com");
_request2.NewPath[2] = "changed2";
_request2.PathChanged();
_request2.SetServerVariable("SERVER_PORT", "443");
_request2.SetHeader("USER_AGENT", "blah blah blah");
_request3.NewUrlString = "/changed1/changed2/";
_request3.NewParameters["param"] = new List <string> {
"added"
};
_request3.ParametersChanged();
IFactory factory = new NinjectFactory();
_valueGetter = factory.Create <IValueGetter>();
_ruleResult = factory.Create <IRuleResult>();
}
public override void PerformAction(
IRuleExecutionContext requestInfo,
IRuleResult ruleResult,
out bool stopProcessing,
out bool endRequest)
{
stopProcessing = _stopProcessing;
endRequest = _endRequest;
if (_actions != null && _actions.Count > 0)
{
foreach (var action in _actions)
{
bool actionStopProcessing;
bool actionEndRequest;
action.PerformAction(requestInfo, ruleResult, out actionStopProcessing, out actionEndRequest);
if (actionEndRequest)
{
endRequest = true;
}
if (actionStopProcessing)
{
stopProcessing = true;
break;
}
}
}
}
public static void AssignRuleName(this IRuleResult ruleResult, string ruleName)
{
if (ruleResult != null)
{
ruleResult.Name = ruleResult.Name ?? ruleName;
}
}
private void AddToAsyncRuleResults(IRuleResult ruleResult)
{
if (ruleResult != null)
{
_asyncRuleResults.Add(ruleResult);
}
}
/// <summary>
/// Add a violation to the queue.
/// </summary>
/// <param name="result">
/// IRuleResult derived class to add.
/// </param>
public void AddAViolation(IRuleResult result)
{
if (result.Severity > 0)
{
this._violations.Enqueue(result);
}
}
public int GetInt(IRequestInfo requestInfo, IRuleResult ruleResult, int defaultValue)
{
var value = GetString(requestInfo, ruleResult);
int intValue;
return(int.TryParse(value, out intValue) ? intValue : defaultValue);
}
public static WrappedResponse <T> WrappedResponse <T>(this IRuleResult rulesResult)
{
return(new WrappedResponse <T>
{
ResultType = ResultType.BadRequest,
State = ((RuleWithStateResult)rulesResult).State
});
}
private void AddToRuleResults(IRuleResult ruleResult, string ruleName)
{
ruleResult.AssignRuleName(ruleName);
if (ruleResult != null)
{
_ruleResults.Add(ruleResult);
}
}
public override void PerformAction(
IRequestInfo requestInfo,
IRuleResult ruleResult,
out bool stopProcessing,
out bool endRequest)
{
stopProcessing = _stopProcessing;
endRequest = _endRequest;
}
public override void PerformAction(
IRuleExecutionContext requestInfo,
IRuleResult ruleResult,
out bool stopProcessing,
out bool endRequest)
{
stopProcessing = true;
endRequest = true;
}
public string GetString(IRequestInfo requestInfo, IRuleResult ruleResult)
{
var value = _getValueFunc(requestInfo, ruleResult);
if (_operation != null)
{
value = _operation.Execute(value);
}
return(value);
}
public override void PerformAction(
IRuleExecutionContext requestInfo,
IRuleResult ruleResult,
out bool stopProcessing,
out bool endRequest)
{
switch (_scope)
{
case Scope.Header:
foreach (var header in requestInfo.GetHeaderNames())
{
if (!_scopeIndex.Contains(header.ToLower()))
{
requestInfo.SetHeader(header, null);
}
}
break;
case Scope.Parameter:
var parameters = new DefaultDictionary <string, IList <string> >(StringComparer.OrdinalIgnoreCase);
foreach (var parameterName in _scopeIndex)
{
IList <string> parameterValue;
if (requestInfo.NewParameters.TryGetValue(parameterName, out parameterValue))
{
if (parameterValue != null && parameterValue.Count > 0)
{
parameters[parameterName] = parameterValue;
}
}
}
requestInfo.NewParameters = parameters;
break;
case Scope.PathElement:
// Note that _scopeIndexValue is sorted into ascending order and always includes 0
var newPath = _scopeIndexValue
.Where(i => i >= 0 && i < requestInfo.NewPath.Count)
.Select(index => requestInfo.NewPath[index])
.ToList();
if (newPath.Count < 2)
{
newPath.Add(string.Empty);
}
requestInfo.NewPath = newPath;
break;
case Scope.HostElement:
// TODO: but only if this makes any sense
break;
}
stopProcessing = _stopProcessing;
endRequest = _endRequest;
}
public void Initialize()
{
_request1 = new MockRequestInfo("/path1/path2/path3?param=value");
_request2 = new MockRequestInfo("/path1/path2", "https", "secure.test.com", 443);
_request3 = new MockRequestInfo("/path1/path2/");
_request4 = new MockRequestInfo("/");
IFactory factory = new NinjectFactory();
_deleteAction = factory.Create<IDeleteAction>();
_ruleResult = factory.Create<IRuleResult>();
}
void IAction.PerformAction(
IRequestInfo requestInfo,
IRuleResult ruleResult,
out bool stopProcessing,
out bool endRequest)
{
var result = Evaluate(requestInfo);
stopProcessing = result.StopProcessing;
endRequest = result.EndRequest;
}
public void Initialize()
{
_request1 = new MockRequestInfo("/path1/path2/path3?p2=v2");
_request2 = new MockRequestInfo("/path1/path2", "https", "secure.test.com", 443);
_request3 = new MockRequestInfo("/path1/path2/?p1=v1&p2=v2&p3=v3");
_request4 = new MockRequestInfo("/?p3=v3&p2=v2");
IFactory factory = new NinjectFactory();
_keepAction = factory.Create<IKeepAction>();
_ruleResult = factory.Create<IRuleResult>();
}
private async Task ExecuteParallelRules(IEnumerable <IRuleAsync <T> > rules)
{
foreach (var rule in GetParallelRules(rules))
{
await InvokeNestedRulesAsync(rule.Configuration.InvokeNestedRulesFirst, rule);
if (rule.CanInvoke() && !_ruleEngineConfiguration.IsRuleEngineTerminated())
{
await InvokeProactiveRulesAsync(rule);
_parallelRuleResults.Add(await Task.Factory.StartNew(async() =>
{
IRuleResult ruleResult = null;
try
{
ruleResult = await ExecuteRuleAsync(rule);
}
catch (Exception exception)
{
rule.UnhandledException = exception;
if (_rxRuleService.GetExceptionRules().ContainsKey(rule.GetType()))
{
await InvokeExceptionRulesAsync(rule);
}
else
{
var globalExceptionHandler = _rules.GetGlobalExceptionHandler();
if (globalExceptionHandler is IRuleAsync <T> ruleAsync)
{
globalExceptionHandler.UnhandledException = exception;
await ExecuteAsyncRules(new List <IRuleAsync <T> > {
ruleAsync
});
}
else
{
throw;
}
}
}
return(ruleResult);
}, rule.ParallelConfiguration.CancellationTokenSource?.Token ?? CancellationToken.None,
rule.ParallelConfiguration.TaskCreationOptions,
rule.ParallelConfiguration.TaskScheduler));
await InvokeReactiveRulesAsync(rule);
}
await InvokeNestedRulesAsync(!rule.Configuration.InvokeNestedRulesFirst, rule);
}
}
public void Initialize()
{
_request1 = new MockRequestInfo("/path1/path2/path3?param=value");
_request2 = new MockRequestInfo("/path1/path2", "https", "secure.test.com", 443);
_request3 = new MockRequestInfo("/path1/path2/");
_request4 = new MockRequestInfo("/");
IFactory factory = new NinjectFactory();
_replaceAction = factory.Create <IReplaceAction>();
_valueGetter = factory.Create <IValueGetter>().Initialize(Scope.Literal, "NewValue");
_ruleResult = factory.Create <IRuleResult>();
}
public override void PerformAction(
IRuleExecutionContext requestInfo,
IRuleResult ruleResult,
out bool stopProcessing,
out bool endRequest)
{
var value = _valueGetter.GetString(requestInfo, ruleResult);
_action(requestInfo, value);
stopProcessing = _stopProcessing;
endRequest = _endRequest;
}
public async Task given_rates_data_converrt_currency_to_USD()
{
var dataLocator = new MockExchangeRateAPI();
var repository = new ExchangeRateCurrencyRepository(dataLocator);
var context = new CurrencyContext(100.00)
{
CurrencyTo = "EUR",
CurrencyFrom = "USD"
};
var engine = new ExchangeCurrencyRulesEngine(context, repository);
IRuleResult <double> result = await engine.Execute();
}
public override void PerformAction(
IRequestInfo requestInfo,
IRuleResult ruleResult,
out bool stopProcessing,
out bool endRequest)
{
if (requestInfo.NewPath != null && requestInfo.NewPath.Count > _maximumDepth)
{
requestInfo.NewPath = requestInfo.NewPath.Take(_maximumDepth).ToList();
}
stopProcessing = _stopProcessing;
endRequest = _endRequest;
}
public override void PerformAction(
IRequestInfo requestInfo,
IRuleResult ruleResult,
out bool stopProcessing,
out bool endRequest)
{
foreach (var action in _actions)
{
action(requestInfo);
}
stopProcessing = _stopProcessing;
endRequest = _endRequest;
}
public override void PerformAction(
IRequestInfo requestInfo,
IRuleResult ruleResult,
out bool stopProcessing,
out bool endRequest)
{
if (requestInfo.ExecutionMode != ExecutionMode.TraceOnly)
{
var url = requestInfo.NewUrlString;
requestInfo.DeferredActions.Add(ri => _redirectAction(ri, url));
}
stopProcessing = _stopProcessing;
endRequest = _endRequest;
}
public override void PerformAction(
IRequestInfo requestInfo,
IRuleResult ruleResult,
out bool stopProcessing,
out bool endRequest)
{
if (requestInfo.ExecutionMode != ExecutionMode.TraceOnly)
{
requestInfo.Context.Response.StatusDescription = _statusLine;
requestInfo.Context.Response.Write(_responseLine);
}
stopProcessing = _stopProcessing;
endRequest = _endRequest;
}
private void SetSerializedResults(IRuleResultList transfferedResults, IRuleResult overrideResult)
{
if (transfferedResults.Any())
{
if (overrideResult == null)
{
Results = transfferedResults;
Results.SetKeysToNegative();
TransferredResults = true;
}
else
{
OverrideResult = overrideResult;
}
}
}
public void Initialize()
{
_request1 = new MockRequestInfo("");
_request2 = new MockRequestInfo("/");
_request3 = new MockRequestInfo("/path1");
_request4 = new MockRequestInfo("path1/");
_request5 = new MockRequestInfo("path1");
_request6 = new MockRequestInfo("/path1/path2");
_request7 = new MockRequestInfo("path1/path2/");
_request8 = new MockRequestInfo("path1/path2");
IFactory factory = new NinjectFactory();
_normalizeAction = factory.Create <INormalizeAction>();
_ruleResult = factory.Create <IRuleResult>();
}
public bool Test(IRuleExecutionContext request, IRuleResult ruleResult)
{
if (_trackAllCaptures)
{
ruleResult.Properties.Set(true, "trackAllCaptures");
}
var result = _testFunc(request, ruleResult);
if (_trackAllCaptures)
{
ruleResult.Properties.Set(false, "trackAllCaptures");
}
return(result);
}
public override void PerformAction(
IRequestInfo requestInfo,
IRuleResult ruleResult,
out bool stopProcessing,
out bool endRequest)
{
stopProcessing = _stopProcessing;
endRequest = _endRequest;
if (_actions != null && _actions.Count > 0)
{
if (requestInfo.ExecutionMode != ExecutionMode.ExecuteOnly)
{
requestInfo.Log.TraceActionListBegin(requestInfo, this);
}
foreach (var action in _actions)
{
bool actionStopProcessing;
bool actionEndRequest;
action.PerformAction(requestInfo, ruleResult, out actionStopProcessing, out actionEndRequest);
if (requestInfo.ExecutionMode != ExecutionMode.ExecuteOnly)
{
requestInfo.Log.TraceAction(requestInfo, action, actionEndRequest, actionStopProcessing);
}
if (actionEndRequest)
{
endRequest = true;
}
if (actionStopProcessing)
{
stopProcessing = true;
break;
}
}
if (requestInfo.ExecutionMode != ExecutionMode.ExecuteOnly)
{
requestInfo.Log.TraceActionListEnd(requestInfo, stopProcessing);
}
}
}
public bool Test(IRequestInfo request, IRuleResult ruleResult)
{
var path = _valueGetter.GetString(request, ruleResult);
try
{
if (!Path.IsPathRooted(path))
{
path = request.Application.Server.MapPath(path);
}
return(_inverted ? !_testFunc(path) : _testFunc(path));
}
catch
{
// When there is a permissions issue we can't tell if it exists or not
return(false);
}
}
private void Evaluate(List <RulesChain> rulesToBeEvaluated, bool isAlternativeChain = false)
{
foreach (RulesChain currentRuleChain in rulesToBeEvaluated)
{
IRuleResult currentRulesChainResult = currentRuleChain.Rule.Eval();
if (currentRulesChainResult.IsSuccess)
{
currentRulesChainResult.Execute();
if (isAlternativeChain)
{
break;
}
}
else
{
this.Evaluate(currentRuleChain.ElseRules, true);
}
}
}
private bool Any(IRuleExecutionContext request, IRuleResult ruleResult, bool expected)
{
if (_conditions == null || _conditions.Count == 0)
{
return(false);
}
foreach (var condition in _conditions)
{
var isTrue = condition.Test(request, ruleResult);
if (isTrue == expected)
{
return(true);
}
}
return(false);
}
