/// <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"); }); }