/// <summary>
/// Initialises a new instance of <see cref="ResultsForErroredValuesExecutionDecorator"/>.
/// </summary>
/// <param name="wrapped">The wrapped rule executor.</param>
/// <exception cref="System.ArgumentNullException">If <paramref name="wrapped"/> is <see langword="null" />.</exception>
public ResultsForErroredValuesExecutionDecorator(IExecutesAllRules wrapped)
{
this.wrapped = wrapped ?? throw new System.ArgumentNullException(nameof(wrapped));
}
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.");
});
}
static IExecutesAllRules WrapWithErroredValuesDecorator(IExecutesAllRules wrapped) => new ResultsForErroredValuesExecutionDecorator(wrapped);
IExecutesAllRules WrapWithFailedDependenciesDecorator(IExecutesAllRules wrapped) => new ResultsForRulesWithFailedDependenciesExecutionDecorator(wrapped, resolver.GetRequiredService <IGetsRuleContext>());
public async Task ValidateAsyncNonGenericShouldReturnReturnValidationResultContainingRuleResults([ManifestModel, Frozen] ValidationManifest manifest,
[Frozen] IGetsRuleExecutor executorFactory,
[Frozen] IGetsAllExecutableRulesWithDependencies ruleFactory,
[Frozen] IGetsRuleExecutionContext contextFactory,
IExecutesAllRules executor,
Validator <object> sut,
object validatedObject,
ValidationOptions options,
CancellationToken cancellationToken,
IRuleExecutionContext context,
[ExecutableModel] ExecutableRuleAndDependencies[] ruleAndDependencies,
[RuleResult] ValidationRuleResult[] results)
{
Mock.Get(executorFactory)
.Setup(x => x.GetRuleExecutorAsync(It.IsAny <ResolvedValidationOptions>(), cancellationToken))
.Returns(Task.FromResult(executor));
Mock.Get(contextFactory)
.Setup(x => x.GetExecutionContext(ruleAndDependencies, It.IsAny <ResolvedValidationOptions>()))
.Returns(context);
Mock.Get(executor)
.Setup(x => x.ExecuteAllRulesAsync(context, cancellationToken))
.Returns(Task.FromResult((IReadOnlyCollection <ValidationRuleResult>)results));
Mock.Get(ruleFactory)
.Setup(x => x.GetRulesWithDependencies(manifest.RootValue, validatedObject, It.IsAny <ResolvedValidationOptions>()))
.Returns(ruleAndDependencies);
var result = await((IValidator)sut).ValidateAsync(validatedObject, options, cancellationToken);
Assert.That(result.RuleResults, Is.EqualTo(results));
}
/// <summary>
/// Initialises a new instance of <see cref="ResultsForRulesWithFailedDependenciesExecutionDecorator"/>.
/// </summary>
/// <param name="wrapped">The wrapped executor instance.</param>
/// <param name="contextFactory">A rule context factory.</param>
/// <exception cref="System.ArgumentNullException">If any parameter is <see langword="null" />.</exception>
public ResultsForRulesWithFailedDependenciesExecutionDecorator(IExecutesAllRules wrapped, IGetsRuleContext contextFactory)
{
this.wrapped = wrapped ?? throw new System.ArgumentNullException(nameof(wrapped));
this.contextFactory = contextFactory ?? throw new System.ArgumentNullException(nameof(contextFactory));
}
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");
});
}
