/// <summary>
/// Initialises a new instance of <see cref="Validator{TValidated}"/>.
/// </summary>
/// <param name="manifest">A validation manifest from which to creator the validator.</param>
/// <param name="executorFactory">The rule-executor factory.</param>
/// <param name="ruleFactory">The rule factory.</param>
/// <param name="optionsResolver">An options resolver.</param>
/// <param name="contextFactory">A rule execution context factory.</param>
/// <exception cref="ArgumentNullException">If any parameter is <see langword="null" />.</exception>
public Validator(ValidationManifest manifest,
IGetsRuleExecutor executorFactory,
IGetsAllExecutableRulesWithDependencies ruleFactory,
IGetsResolvedValidationOptions optionsResolver,
IGetsRuleExecutionContext contextFactory)
{
this.manifest = manifest ?? throw new ArgumentNullException(nameof(manifest));
this.executorFactory = executorFactory ?? throw new ArgumentNullException(nameof(executorFactory));
this.ruleFactory = ruleFactory ?? throw new ArgumentNullException(nameof(ruleFactory));
this.optionsResolver = optionsResolver ?? throw new ArgumentNullException(nameof(optionsResolver));
this.contextFactory = contextFactory ?? throw new ArgumentNullException(nameof(contextFactory));
}
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));
}
