public void GetRulesWithDependenciesShouldThrowIfTheMatchingValueDoesNotHaveTheSpecifiedRule([Frozen] IGetsAllExecutableRules executableRulesProvider,
[ManifestModel] ManifestValue manifestValue,
object objectToBeValidated,
IValidationLogic logic,
ManifestRule manifestRule,
ManifestRule manifestDependency,
[ExecutableModel] ValidatedValue validatedValue,
[ExecutableModel] ValidatedValue parentValue,
ExecutableRulesAndDependenciesProvider sut,
ResolvedValidationOptions validationOptions)
{
var rule = new ExecutableRule {
ValidatedValue = validatedValue, ManifestRule = manifestRule, RuleLogic = logic
};
validatedValue.ParentValue = parentValue;
var dependency = new ExecutableRule {
ValidatedValue = parentValue, ManifestRule = manifestDependency, RuleLogic = logic
};
parentValue.ManifestValue = manifestDependency.Identifier.ManifestValue;
Mock.Get(executableRulesProvider)
.Setup(x => x.GetExecutableRules(manifestValue, objectToBeValidated, validationOptions))
.Returns(new [] { rule, dependency });
rule.ManifestRule.DependencyRules.Clear();
rule.ManifestRule.DependencyRules.Add(manifestDependency.Identifier);
Assert.That(() => sut.GetRulesWithDependencies(manifestValue, objectToBeValidated, validationOptions), Throws.InstanceOf <ValidationException>());
}
public void GetRulesWithDependenciesShouldReturnAnObjectWithDependencyExecutableRulesWhereItHasADependencyUponAParentValue([Frozen] IGetsAllExecutableRules executableRulesProvider,
[ManifestModel] ManifestValue manifestValue,
object objectToBeValidated,
IValidationLogic logic,
ManifestRule manifestRule,
ManifestRule manifestDependency,
[ExecutableModel] ValidatedValue validatedValue,
[ExecutableModel] ValidatedValue parentValue,
ExecutableRulesAndDependenciesProvider sut,
ResolvedValidationOptions validationOptions)
{
var rule = new ExecutableRule {
ValidatedValue = validatedValue, ManifestRule = manifestRule, RuleLogic = logic
};
validatedValue.ParentValue = parentValue;
var dependency = new ExecutableRule {
ValidatedValue = parentValue, ManifestRule = manifestDependency, RuleLogic = logic
};
parentValue.ManifestValue = manifestDependency.Identifier.ManifestValue;
parentValue.Rules.Add(dependency);
Mock.Get(executableRulesProvider)
.Setup(x => x.GetExecutableRules(manifestValue, objectToBeValidated, validationOptions))
.Returns(new [] { rule, dependency });
rule.ManifestRule.DependencyRules.Clear();
rule.ManifestRule.DependencyRules.Add(manifestDependency.Identifier);
var result = sut.GetRulesWithDependencies(manifestValue, objectToBeValidated, validationOptions);
Assert.That(result.First(x => x.ExecutableRule == rule).Dependencies, Is.EqualTo(new[] { dependency }));
}
/// <summary>
/// Initialises an instance of <see cref="ExecutableRuleAndDependencies"/>.
/// </summary>
/// <param name="executableRule">The rule.</param>
/// <param name="dependencies">The rule's dependencies.</param>
/// <param name="dependedUponBy">A collection of rules which depend upon <paramref name="executableRule"/>.</param>
/// <exception cref="System.ArgumentNullException">If <paramref name="executableRule"/> is <see langword="null"/>.</exception>
public ExecutableRuleAndDependencies(ExecutableRule executableRule,
IEnumerable <ExecutableRule> dependencies = null,
IEnumerable <ExecutableRule> dependedUponBy = null)
{
ExecutableRule = executableRule ?? throw new System.ArgumentNullException(nameof(executableRule));
Dependencies = new List <ExecutableRule>(dependencies ?? Enumerable.Empty <ExecutableRule>());
DependedUponBy = new List <ExecutableRule>(dependedUponBy ?? Enumerable.Empty <ExecutableRule>());
}
internal static async Task <ValidationRuleResult> ExecuteRuleAsync(ExecutableRule rule,
IExeucutesSingleRule ruleExecutor,
IRuleExecutionContext executionContext,
CancellationToken cancellationToken)
{
var result = await ruleExecutor.ExecuteRuleAsync(rule, cancellationToken).ConfigureAwait(false);
rule.Result = result;
executionContext.HandleValidationRuleResult(rule);
return(result);
}
public async Task ExecuteRuleAsyncShouldGetContextFromFactory([Frozen] IGetsRuleContext contextFactory,
[RuleContext] RuleContext context,
[ExecutableModel] ExecutableRule rule,
SingleRuleExecutor sut,
[RuleResult] RuleResult expectedResult)
{
RuleContext capturedContext = null;
Mock.Get(rule.RuleLogic)
.Setup(x => x.GetResultAsync(It.IsAny <object>(), It.IsAny <object>(), It.IsAny <RuleContext>(), It.IsAny <CancellationToken>()))
.Callback((object v1, object v2, RuleContext context, CancellationToken t) => capturedContext = context)
.Returns(() => Task.FromResult(expectedResult));
Mock.Get(contextFactory).Setup(x => x.GetRuleContext(rule)).Returns(context);
await sut.ExecuteRuleAsync(rule);
Assert.That(capturedContext, Is.SameAs(context));
}
/// <inheritdoc/>
public async Task <ValidationRuleResult> ExecuteRuleAsync(ExecutableRule rule, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var context = contextFactory.GetRuleContext(rule);
var timeout = rule.RuleLogic.GetTimeout();
using (var ruleTokenSource = timeout.HasValue ? new CancellationTokenSource(timeout.Value) : new CancellationTokenSource())
using (var combinedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, ruleTokenSource.Token))
{
var ruleTask = rule.RuleLogic.GetResultAsync(rule.ValidatedValue.GetActualValue(),
rule.ValidatedValue.ParentValue?.GetActualValue(),
context,
combinedTokenSource.Token);
var result = await WaitForResultAsync(ruleTask, combinedTokenSource.Token, timeout).ConfigureAwait(false);
return(new ValidationRuleResult(result, context, rule.RuleLogic));
}
}
public async Task ExecuteRuleAsyncShouldReturnResultCreatedFromRuleLogic([Frozen] IGetsRuleContext contextFactory,
[RuleContext] RuleContext context,
[ExecutableModel] ExecutableRule rule,
SingleRuleExecutor sut,
[RuleResult] RuleResult expectedResult)
{
Mock.Get(rule.RuleLogic)
.Setup(x => x.GetResultAsync(It.IsAny <object>(), It.IsAny <object>(), It.IsAny <RuleContext>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(expectedResult));
Mock.Get(contextFactory).Setup(x => x.GetRuleContext(rule)).Returns(context);
var result = await sut.ExecuteRuleAsync(rule);
Assert.Multiple(() =>
{
Assert.That(result.Data, Is.SameAs(expectedResult.Data), nameof(ValidationRuleResult.Data));
Assert.That(result.Outcome, Is.EqualTo(expectedResult.Outcome), nameof(ValidationRuleResult.Outcome));
});
}
/// <inheritdoc />
public void HandleValidationRuleResult(ExecutableRule rule)
{
if (rule.Result is null)
{
var message = String.Format(GetExceptionMessage("RuleResultMustNotBeNull"), nameof(ExecutableRule.Result));
throw new ArgumentException(message, nameof(rule));
}
lock (syncRoot)
{
if (rule.Result.Outcome != RuleOutcome.Passed)
{
RemoveRuleAndAllDependentsFromPending(rule);
}
else
{
pendingRules.Remove(rule);
}
}
}
/// <summary>
/// When the specified <paramref name="rule"/> has failed then this rule and all of its dependencies must be
/// removed from the collection of pending rules. Additionally, any rules removed in this way that do not yet
/// have a <see cref="ExecutableRule.Result"/> must be marked with a result indicating
/// <see cref="RuleOutcome.DependencyFailed"/>.
/// </summary>
/// <param name="rule">The rule which has failed validation in some manner.</param>
void RemoveRuleAndAllDependentsFromPending(ExecutableRule rule)
{
var openList = new Queue <ExecutableRule>(GetRuleAndDependencies(rule).DependedUponBy);
while (openList.Any())
{
var current = openList.Dequeue();
pendingRules.Remove(current);
var ruleAndDependencies = GetRuleAndDependencies(current);
if (ruleAndDependencies.ExecutableRule.Result is null)
{
ruleAndDependencies.ExecutableRule.Result = new RuleResult(RuleOutcome.DependencyFailed);
dependencyFailures.Add(ruleAndDependencies.ExecutableRule);
}
foreach (var dependedUpon in ruleAndDependencies.DependedUponBy)
{
openList.Enqueue(dependedUpon);
}
}
}
static IEnumerable <ExecutableRule> GetDependencies(ExecutableRule rule)
{
return((from dependencyId in rule.ManifestRule.DependencyRules
select GetDependency(dependencyId, rule))
.ToList());
}
public void GetRulesWhoseDependenciesHaveFailedShouldReturnCorrectRulesAfterHandleValidationRuleResult([ExecutableModel] ExecutableRule rule1,
[ExecutableModel] ExecutableRule rule2,
[ExecutableModel] ExecutableRule rule3,
[ExecutableModel] ExecutableRule rule4)
{
var rulesAndDeps = new[] {
new ExecutableRuleAndDependencies(rule1, new[] { rule2 }),
new ExecutableRuleAndDependencies(rule2, new[] { rule3 }, new[] { rule1 }),
new ExecutableRuleAndDependencies(rule3, null, new[] { rule2 }),
new ExecutableRuleAndDependencies(rule4)
};
var sut = GetSut(rulesAndDeps);
rule3.Result = Fail();
sut.HandleValidationRuleResult(rule3);
Assert.That(() => sut.GetRulesWhoseDependenciesHaveFailed(), Is.EquivalentTo(new[] { rule2, rule1 }));
}
public void GetCircularDependenciesShouldReturnTwoWhenThereAreTwoCircularDependencies([ExecutableModel] ExecutableRule rule1,
[ExecutableModel] ExecutableRule rule2,
[ExecutableModel] ExecutableRule rule3,
[ExecutableModel] ExecutableRule rule4,
CircularDependencyDetector sut)
{
var rulesAndDependencies = new[]
{
new ExecutableRuleAndDependencies(rule1, new[] { rule2, }),
new ExecutableRuleAndDependencies(rule2, new[] { rule1 }),
new ExecutableRuleAndDependencies(rule3, new[] { rule4 }),
new ExecutableRuleAndDependencies(rule4, new[] { rule3 }),
};
Assert.That(() => sut.GetCircularDependencies(rulesAndDependencies).ToList(), Has.Count.EqualTo(2));
}
public void GetRulesWhichMayBeExecutedShouldNotReturnRulesWhichAlreadyHaveResults([ExecutableModel] ExecutableRule rule1,
[ExecutableModel] ExecutableRule rule2,
[ExecutableModel] ExecutableRule rule3,
[ExecutableModel] ExecutableRule rule4,
[ExecutableModel] ExecutableRule rule5)
{
rule1.Result = Pass();
rule2.Result = Fail();
rule3.Result = Error();
rule4.Result = new RuleResult(RuleOutcome.DependencyFailed);
var rulesAndDeps = new[] {
new ExecutableRuleAndDependencies(rule1),
new ExecutableRuleAndDependencies(rule2),
new ExecutableRuleAndDependencies(rule3),
new ExecutableRuleAndDependencies(rule4),
new ExecutableRuleAndDependencies(rule5)
};
var sut = GetSut(rulesAndDeps);
Assert.That(() => sut.GetRulesWhichMayBeExecuted(), Is.EquivalentTo(new[] { rule5 }));
}
public void GetRulesWhichMayBeExecutedShouldNotReturnRulesWhichHaveFailedValues([ExecutableModel] ExecutableRule rule1,
[ExecutableModel] ExecutableRule rule2,
[ExecutableModel] ExecutableRule rule3,
[ExecutableModel] ExecutableRule rule4,
[ExecutableModel] ExecutableRule rule5)
{
rule1.ValidatedValue.ValueResponse = new IgnoredGetValueToBeValidatedResponse();
rule2.ValidatedValue.ValueResponse = new SuccessfulGetValueToBeValidatedResponse(new object());
rule3.ValidatedValue.ValueResponse = new ErrorGetValueToBeValidatedResponse(new Exception());
rule4.ValidatedValue.ValueResponse = new SuccessfulGetValueToBeValidatedResponse(new object());
rule5.ValidatedValue.ValueResponse = new ErrorGetValueToBeValidatedResponse(new Exception());
var rulesAndDeps = new[] {
new ExecutableRuleAndDependencies(rule1),
new ExecutableRuleAndDependencies(rule2),
new ExecutableRuleAndDependencies(rule3),
new ExecutableRuleAndDependencies(rule4),
new ExecutableRuleAndDependencies(rule5)
};
var sut = GetSut(rulesAndDeps);
Assert.That(() => sut.GetRulesWhichMayBeExecuted(), Is.EquivalentTo(new[] { rule2, rule4 }));
}
public async Task ExecuteRuleAsyncShouldReturnErrorResultWithTimeoutIfRuleTakesTooLongToExecute([Frozen] IGetsRuleContext contextFactory,
[RuleContext] RuleContext context,
[ExecutableModel] ExecutableRule rule,
SingleRuleExecutor sut)
{
var timeout = TimeSpan.FromMilliseconds(100);
Mock.Get(rule.RuleLogic).Setup(x => x.GetTimeout()).Returns(timeout);
Mock.Get(rule.RuleLogic)
.Setup(x => x.GetResultAsync(It.IsAny <object>(), It.IsAny <object>(), It.IsAny <RuleContext>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.Run(async() => {
await Task.Delay(200);
return(CommonResults.Pass());
}));
Mock.Get(contextFactory).Setup(x => x.GetRuleContext(rule)).Returns(context);
var result = await sut.ExecuteRuleAsync(rule);
Assert.Multiple(() =>
{
Assert.That(result.Outcome, Is.EqualTo(RuleOutcome.Errored), "Result has error outcome");
Assert.That(result.Data, Does.ContainKey(RuleResult.RuleTimeoutDataKey), "Result has a rule-timeout data key");
if (result.Data.TryGetValue(RuleResult.RuleTimeoutDataKey, out var timeoutData))
{
Assert.That(timeoutData, Is.EqualTo(timeout), "Timeout data is equal");
}
});
}
public void GetRulesWhichMayBeExecutedShouldReturnRulesWhichMayBeExecutedBecauseTheirDependenciesPassed([ExecutableModel] ExecutableRule rule1,
[ExecutableModel] ExecutableRule rule2,
[ExecutableModel] ExecutableRule rule3,
[ExecutableModel] ExecutableRule rule4)
{
var rulesAndDeps = new[] {
new ExecutableRuleAndDependencies(rule1, new[] { rule2 }),
new ExecutableRuleAndDependencies(rule2, new[] { rule3 }, new[] { rule1 }),
new ExecutableRuleAndDependencies(rule3, dependedUponBy: new[] { rule2 }),
new ExecutableRuleAndDependencies(rule4)
};
var sut = GetSut(rulesAndDeps);
rule3.Result = Pass();
sut.HandleValidationRuleResult(rule3);
Assert.That(() => sut.GetRulesWhichMayBeExecuted(), Is.EquivalentTo(new[] { rule2, rule4 }));
}
public void GetCircularDependenciesShouldReturnAnEmptyCollectionIfThereAreNoCircularDependencies([ExecutableModel] ExecutableRule rule1,
[ExecutableModel] ExecutableRule rule2,
[ExecutableModel] ExecutableRule rule3,
[ExecutableModel] ExecutableRule rule4,
CircularDependencyDetector sut)
{
var rulesAndDependencies = new[]
{
new ExecutableRuleAndDependencies(rule1, new[] { rule2, rule3 }),
new ExecutableRuleAndDependencies(rule2),
new ExecutableRuleAndDependencies(rule3, new[] { rule2 }),
new ExecutableRuleAndDependencies(rule4),
};
Assert.That(() => sut.GetCircularDependencies(rulesAndDependencies), Is.Empty);
}
public void GetCircularDependenciesShouldReturnACircularDependencyWithTheCorrectChainOfRules([ExecutableModel] ExecutableRule rule1,
[ExecutableModel] ExecutableRule rule2,
[ExecutableModel] ExecutableRule rule3,
[ExecutableModel] ExecutableRule rule4,
CircularDependencyDetector sut)
{
var rulesAndDependencies = new[]
{
new ExecutableRuleAndDependencies(rule1, new[] { rule2, }),
new ExecutableRuleAndDependencies(rule2, new[] { rule3 }),
new ExecutableRuleAndDependencies(rule3, new[] { rule4 }),
new ExecutableRuleAndDependencies(rule4, new[] { rule1 }),
};
Assert.That(() => sut.GetCircularDependencies(rulesAndDependencies).Single().DependencyChain, Is.EqualTo(new [] { rule1, rule2, rule3, rule4, rule1 }));
}
public async Task ExecuteAllRulesAsyncShouldNotIncludeErrorResultsForIgnoredValues(IRuleExecutionContext executionContext,
[Frozen] IExecutesAllRules wrapped,
ResultsForErroredValuesExecutionDecorator sut,
ErrorGetValueToBeValidatedResponse response1,
IgnoredGetValueToBeValidatedResponse response2,
[ExecutableModel] ExecutableRule rule1,
[ExecutableModel] ExecutableRule rule2,
[ExecutableModel] ExecutableRule rule3)
{
Mock.Get(wrapped)
.Setup(x => x.ExecuteAllRulesAsync(executionContext, default))
.Returns(Task.FromResult <IReadOnlyCollection <ValidationRuleResult> >(Array.Empty <ValidationRuleResult>()));
var ruleAndDependencies1 = new ExecutableRuleAndDependencies(rule1);
var ruleAndDependencies2 = new ExecutableRuleAndDependencies(rule2);
var ruleAndDependencies3 = new ExecutableRuleAndDependencies(rule3);
rule1.ValidatedValue.ValueResponse = response1;
rule2.ValidatedValue.ValueResponse = response1;
rule3.ValidatedValue.ValueResponse = response2;
Mock.Get(executionContext)
.SetupGet(x => x.AllRules)
.Returns(new[] { ruleAndDependencies1, ruleAndDependencies2, ruleAndDependencies3 });
var result = await sut.ExecuteAllRulesAsync(executionContext);
Assert.Multiple(() =>
{
Assert.That(result,
Has.One.Matches <ValidationRuleResult>(v => v.Outcome == RuleOutcome.Errored && v.Exception == response1.Exception),
"First response present");
Assert.That(result, Has.Count.EqualTo(1), "Correct count");
});
}
public void GetRulesWithDependenciesShouldNotReturnAnyDependenciesForARuleWhichHasNone([Frozen] IGetsAllExecutableRules executableRulesProvider,
[ManifestModel] ManifestValue manifestValue,
object objectToBeValidated,
[ExecutableModel] ExecutableRule rule,
ExecutableRulesAndDependenciesProvider sut,
ResolvedValidationOptions validationOptions)
{
Mock.Get(executableRulesProvider)
.Setup(x => x.GetExecutableRules(manifestValue, objectToBeValidated, validationOptions))
.Returns(new [] { rule });
var result = sut.GetRulesWithDependencies(manifestValue, objectToBeValidated, validationOptions);
Assert.That(result.Single().Dependencies, Is.Empty);
}
public void ExecuteRuleAsyncShouldReturnPassResultWithTimeoutIfRuleCompletesInATimelyManner([Frozen] IGetsRuleContext contextFactory,
[RuleContext] RuleContext context,
[ExecutableModel] ExecutableRule rule,
SingleRuleExecutor sut)
{
var timeout = TimeSpan.FromMilliseconds(300);
Mock.Get(rule.RuleLogic).Setup(x => x.GetTimeout()).Returns(timeout);
Mock.Get(rule.RuleLogic)
.Setup(x => x.GetResultAsync(It.IsAny <object>(), It.IsAny <object>(), It.IsAny <RuleContext>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.Run(async() => {
await Task.Delay(50);
return(CommonResults.Pass());
}));
Mock.Get(contextFactory).Setup(x => x.GetRuleContext(rule)).Returns(context);
Assert.That(() => sut.ExecuteRuleAsync(rule), Is.PassingValidationResult);
}
public void ExecuteRuleAsyncShouldThrowIfCancellationIsRequestedWithoutExecutingRuleLogic([Frozen] IGetsRuleContext contextFactory,
[RuleContext] RuleContext context,
[ExecutableModel] ExecutableRule rule,
SingleRuleExecutor sut,
[AlreadyCancelled] CancellationToken token)
{
Mock.Get(contextFactory).Setup(x => x.GetRuleContext(rule)).Returns(context);
Assert.That(async() => await sut.ExecuteRuleAsync(rule, token), Throws.InstanceOf <OperationCanceledException>());
Mock.Get(rule.RuleLogic)
.Verify(x => x.GetResultAsync(It.IsAny <object>(), It.IsAny <object>(), It.IsAny <RuleContext>(), It.IsAny <CancellationToken>()), Times.Never);
}
ExecutableRuleAndDependencies GetRuleAndDependencies(ExecutableRule rule) => allRules[rule];
static ExecutableRule GetDependency(ManifestRuleIdentifier dependencyIdentifier, ExecutableRule rule)
{
var matchingValidatedValue = GetCandidateValidatedValueMatches(dependencyIdentifier, rule)
.FirstOrDefault(x => !(x is null));
if (matchingValidatedValue is null)
{
var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("CannotGetMatchingValueForDependency"),
rule.ManifestRule.Identifier,
dependencyIdentifier);
throw new ValidationException(message);
}
var dependency = matchingValidatedValue.Rules
.FirstOrDefault(valueRule => Equals(valueRule.ManifestRule.Identifier, dependencyIdentifier));
if (dependency == null)
{
var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("DependencyRuleNotOnMatchingValue"),
rule.ManifestRule.Identifier,
dependencyIdentifier);
throw new ValidationException(message);
}
return(dependency);
}
public void GetRulesWhichMayBeExecutedShouldNotReturnRulesWhichHaveUnresolvedDependencies([ExecutableModel] ExecutableRule rule1,
[ExecutableModel] ExecutableRule rule2,
[ExecutableModel] ExecutableRule rule3,
[ExecutableModel] ExecutableRule rule4)
{
var rulesAndDeps = new[] {
new ExecutableRuleAndDependencies(rule1, new[] { rule2 }),
new ExecutableRuleAndDependencies(rule2, new[] { rule3 }, new[] { rule1 }),
new ExecutableRuleAndDependencies(rule3, null, new[] { rule2 }),
new ExecutableRuleAndDependencies(rule4)
};
var sut = GetSut(rulesAndDeps);
Assert.That(() => sut.GetRulesWhichMayBeExecuted(), Is.EquivalentTo(new[] { rule3, rule4 }));
}
static IEnumerable <ValidatedValue> GetCandidateValidatedValueMatches(ManifestRuleIdentifier dependencyIdentifier, ExecutableRule rule)
{
for (var currentValue = rule.ValidatedValue; currentValue != null; currentValue = currentValue.ParentValue)
{
yield return(GetMatchingValidatedValue(dependencyIdentifier, currentValue));
}
}
public async Task ExecuteRuleAsyncShouldExecuteRuleLogicWithCorrectValidatedInstances([Frozen] IGetsRuleContext contextFactory,
[RuleContext] RuleContext context,
[ExecutableModel] ExecutableRule rule,
SingleRuleExecutor sut,
ValidatedValue validatedValue,
ValidatedValue parentValue,
[RuleResult] RuleResult expectedResult)
{
rule.ValidatedValue = validatedValue;
validatedValue.ParentValue = parentValue;
Mock.Get(contextFactory).Setup(x => x.GetRuleContext(rule)).Returns(context);
Mock.Get(rule.RuleLogic)
.Setup(x => x.GetResultAsync(It.IsAny <object>(), It.IsAny <object>(), It.IsAny <RuleContext>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(expectedResult));
await sut.ExecuteRuleAsync(rule);
Mock.Get(rule.RuleLogic)
.Verify(x => x.GetResultAsync(validatedValue.GetActualValue(), parentValue.GetActualValue(), It.IsAny <RuleContext>(), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task ExecuteAllRulesAsyncShouldReturnAResultForEachRuleWithFailedDependencies([Frozen] IExecutesAllRules wrapped,
[Frozen] IGetsRuleContext contextFactory,
ResultsForRulesWithFailedDependenciesExecutionDecorator sut,
IRuleExecutionContext executionContext,
[ExecutableModel] ExecutableRule rule1,
[ExecutableModel] ExecutableRule rule2,
[RuleContext] RuleContext context)
{
Mock.Get(wrapped)
.Setup(x => x.ExecuteAllRulesAsync(executionContext, default))
.Returns(Task.FromResult <IReadOnlyCollection <ValidationRuleResult> >(Array.Empty <ValidationRuleResult>()));
Mock.Get(executionContext)
.Setup(x => x.GetRulesWhoseDependenciesHaveFailed())
.Returns(new[] { rule1, rule2 });
Mock.Get(contextFactory)
.Setup(x => x.GetRuleContext(It.IsAny <ExecutableRule>()))
.Returns(context);
rule1.Result = new RuleResult(RuleOutcome.DependencyFailed);
rule2.Result = new RuleResult(RuleOutcome.DependencyFailed);
var results = await sut.ExecuteAllRulesAsync(executionContext);
Assert.Multiple(() =>
{
Assert.That(results, Has.Count.EqualTo(2), "Count of results");
Assert.That(results.Select(x => x.ValidationLogic).ToList(),
Is.EqualTo(new[] { rule1.RuleLogic, rule2.RuleLogic }),
"Correct rules used, identified by their logic instances.");
});
}
public void GetExecutableRulesShouldReturnAFlattenedListOfRulesIncludingCollectionItemRules([Frozen] IGetsValidatedValue validatedValueProvider,
[ExecutableModel] ValidatedValue rootValue,
[ExecutableModel] ValidatedValue childVal1,
[ExecutableModel] ValidatedValue childVal2,
[ExecutableModel] ValidatedValue collectionValue1,
[ExecutableModel] ValidatedValue collectionValue2,
[ExecutableModel] ExecutableRule rule1,
[ExecutableModel] ExecutableRule rule2,
[ExecutableModel] ExecutableRule rule3,
[ExecutableModel] ExecutableRule rule4,
[ExecutableModel] ExecutableRule rule5,
[ExecutableModel] ExecutableRule rule6,
ExecutableRulesFromValidatedValueProvider sut,
[ManifestModel] ManifestValue manifestValue,
object valueToBeValidated,
ResolvedValidationOptions validationOptions)
{
rootValue.ChildValues.Add(childVal1);
rootValue.ChildValues.Add(childVal2);
childVal2.CollectionItems.Add(collectionValue1);
childVal2.CollectionItems.Add(collectionValue2);
rootValue.Rules.Add(rule1);
childVal1.Rules.Add(rule2);
childVal1.Rules.Add(rule3);
childVal2.Rules.Add(rule4);
collectionValue1.Rules.Add(rule5);
collectionValue2.Rules.Add(rule6);
Mock.Get(validatedValueProvider).Setup(x => x.GetValidatedValue(manifestValue, valueToBeValidated, validationOptions)).Returns(rootValue);
var expected = new[] { rule1, rule2, rule3, rule4, rule5, rule6 };
Assert.That(() => sut.GetExecutableRules(manifestValue, valueToBeValidated, validationOptions), Is.EquivalentTo(expected));
}
