async Task <ValidationResult> ExerciseNonGenericSut(string validated,
                                                            ValidationOptions options,
                                                            RuleThrowingBehaviour behaviour,
                                                            params RuleResult[] ruleResults)
        {
            var result = new ValidationResult <string>(ruleResults.Select(x => new ValidationRuleResult(x, null, null)), new Manifest.ValidationManifest {
                ValidatedType = typeof(string)
            });
            var wrapped = new Mock <IValidator <string> >();

            wrapped.As <IValidator>().Setup(x => x.ValidateAsync(validated, options, default)).Returns(Task.FromResult <ValidationResult>(result));
            var sut = new ThrowingBehaviourValidatorDecorator <string>(wrapped.Object, Mock.Of <IGetsResolvedValidationOptions>(x => x.GetResolvedValidationOptions(options) == new ResolvedValidationOptions {
                RuleThrowingBehaviour = behaviour
            }));

            options.RuleThrowingBehaviour = behaviour;
            return(await sut.ValidateAsync((object)validated, options).ConfigureAwait(false));
        }
        async Task <IQueryableValidationResult <string> > ExerciseGenericSut(ThrowingBehaviourValidatorDecorator <string> sut,
                                                                             string validated,
                                                                             ValidationOptions options,
                                                                             IValidator <string> wrapped,
                                                                             IGetsResolvedValidationOptions optionsResolver,
                                                                             RuleThrowingBehaviour behaviour,
                                                                             params RuleResult[] ruleResults)
        {
            var result = new ValidationResult <string>(ruleResults.Select(x => new ValidationRuleResult(x, null, null)), new Manifest.ValidationManifest {
                ValidatedType = typeof(string)
            });

            Mock.Get(wrapped).Setup(x => x.ValidateAsync(validated, options, default)).Returns(Task.FromResult <IQueryableValidationResult <string> >(result));
            options.RuleThrowingBehaviour = behaviour;
            Mock.Get(optionsResolver).Setup(x => x.GetResolvedValidationOptions(options)).Returns(new ResolvedValidationOptions {
                RuleThrowingBehaviour = behaviour
            });
            return(await sut.ValidateAsync(validated, options).ConfigureAwait(false));
        }
 public void GenericValidateAsyncShouldNotThrowIfBehaviourIsNeverAndResultContainsBothErrorsAndFailures([Frozen] IValidator <string> wrapped,
                                                                                                        [Frozen] IGetsResolvedValidationOptions optionsResolver,
                                                                                                        ThrowingBehaviourValidatorDecorator <string> sut,
                                                                                                        string validated,
                                                                                                        ValidationOptions options)
 {
     Assert.That(async() => await ExerciseGenericSut(sut, validated, options, wrapped, optionsResolver, RuleThrowingBehaviour.Never, Error(), Fail()),
                 Throws.Nothing);
 }
 public void GenericValidateAsyncShouldThrowIfBehaviourIsOnFailureAndResultsContainAFailure([Frozen] IValidator <string> wrapped,
                                                                                            [Frozen] IGetsResolvedValidationOptions optionsResolver,
                                                                                            ThrowingBehaviourValidatorDecorator <string> sut,
                                                                                            string validated,
                                                                                            ValidationOptions options)
 {
     Assert.That(async() => await ExerciseGenericSut(sut, validated, options, wrapped, optionsResolver, RuleThrowingBehaviour.OnFailure, Fail()),
                 Throws.InstanceOf <ValidationException>());
 }