public void GetResolvedValidationOptionsShouldReturnHardcodedDefaultsIfSpecifiedAndDefaultOptionsAreNull([Frozen] IOptions <ValidationOptions> opts, ValidationOptionsResolver sut, ValidationOptions defaultOptions) { Mock.Get(opts).SetupGet(x => x.Value).Returns(defaultOptions); defaultOptions.AccessorExceptionBehaviour = null; defaultOptions.EnableMessageGeneration = null; defaultOptions.RuleThrowingBehaviour = null; defaultOptions.EnableRuleParallelization = null; var result = sut.GetResolvedValidationOptions(null); Assert.Multiple(() => { Assert.That(result.AccessorExceptionBehaviour, Is.EqualTo(ValueAccessExceptionBehaviour.TreatAsError), nameof(ValidationOptions.AccessorExceptionBehaviour)); Assert.That(result.EnableMessageGeneration, Is.EqualTo(false), nameof(ValidationOptions.EnableMessageGeneration)); Assert.That(result.RuleThrowingBehaviour, Is.EqualTo(RuleThrowingBehaviour.OnError), nameof(ValidationOptions.RuleThrowingBehaviour)); Assert.That(result.EnableRuleParallelization, Is.EqualTo(false), nameof(ValidationOptions.EnableRuleParallelization)); }); }
async Task <ValidationResult> IValidator.ValidateAsync(object validatedObject, ValidationOptions options, CancellationToken cancellationToken) { var result = await ValidateAsync((TValidated)validatedObject, options, cancellationToken).ConfigureAwait(false); return((ValidationResult)result); }
public void GetResolvedValidationOptionsShouldReturnValuesFromDefaultOptionsIfSpecifiedOptionsAreNull([Frozen] IOptions <ValidationOptions> opts, ValidationOptionsResolver sut, ValidationOptions defaultOptions) { Mock.Get(opts).SetupGet(x => x.Value).Returns(defaultOptions); defaultOptions.AccessorExceptionBehaviour = ValueAccessExceptionBehaviour.Throw; defaultOptions.EnableMessageGeneration = true; defaultOptions.RuleThrowingBehaviour = RuleThrowingBehaviour.OnFailure; defaultOptions.EnableRuleParallelization = true; var result = sut.GetResolvedValidationOptions(null); Assert.Multiple(() => { Assert.That(result.AccessorExceptionBehaviour, Is.EqualTo(ValueAccessExceptionBehaviour.Throw), nameof(ValidationOptions.AccessorExceptionBehaviour)); Assert.That(result.EnableMessageGeneration, Is.EqualTo(true), nameof(ValidationOptions.EnableMessageGeneration)); Assert.That(result.RuleThrowingBehaviour, Is.EqualTo(RuleThrowingBehaviour.OnFailure), nameof(ValidationOptions.RuleThrowingBehaviour)); Assert.That(result.EnableRuleParallelization, Is.EqualTo(true), nameof(ValidationOptions.EnableRuleParallelization)); }); }
/// <inheritdoc/> public async Task <IQueryableValidationResult <TValidated> > ValidateAsync(TValidated validatedObject, ValidationOptions options = null, CancellationToken cancellationToken = default) { var result = await wrapped.ValidateAsync(validatedObject, options, cancellationToken).ConfigureAwait(false); ThrowForUnsuccessfulValidationIfApplicable(result, optionsResolver.GetResolvedValidationOptions(options)); return(result); }
/// <inheritdoc/> public async Task <IQueryableValidationResult <TValidated> > ValidateAsync(TValidated validatedObject, ValidationOptions options = null, CancellationToken cancellationToken = default) { var result = await validator.ValidateAsync(validatedObject, options, cancellationToken).ConfigureAwait(false); if (options?.EnableMessageGeneration != true) { return(result); } return(await failureMessageEnricher.GetResultWithMessagesAsync(result, cancellationToken).ConfigureAwait(false)); }
public void ValidateAsyncShouldUseTheWrappedValidatorThenReturnTheResultEnrichedWithMessagesIfOptionsEnableIt([Frozen] IValidator <object> validator, [Frozen] IAddsFailureMessagesToResult failureMessageEnricher, MessageEnrichingValidatorDecorator <object> sut, [RuleResult] ValidationResult <object> originalResult, [RuleResult] ValidationResult <object> resultWithMessages, object validatedObject, ValidationOptions options) { options.EnableMessageGeneration = true; Mock.Get(validator).Setup(x => x.ValidateAsync(validatedObject, options, default)).Returns(Task.FromResult <IQueryableValidationResult <object> >(originalResult)); Mock.Get(failureMessageEnricher).Setup(x => x.GetResultWithMessagesAsync(originalResult, default)).Returns(Task.FromResult <IQueryableValidationResult <object> >(resultWithMessages)); Assert.That(async() => await sut.ValidateAsync(validatedObject, options), Is.SameAs(resultWithMessages)); }
public void ValidateAsyncShouldReturnTheWrappedValidatorResultIfOptionsDisableMessageGeneration([Frozen] IValidator <object> validator, [Frozen] IAddsFailureMessagesToResult failureMessageEnricher, MessageEnrichingValidatorDecorator <object> sut, [RuleResult] ValidationResult <object> originalResult, [RuleResult] ValidationResult <object> resultWithMessages, object validatedObject, ValidationOptions options) { options.EnableMessageGeneration = false; Mock.Get(validator).Setup(x => x.ValidateAsync(validatedObject, options, default)).Returns(Task.FromResult <IQueryableValidationResult <object> >(originalResult)); Assert.That(async() => await sut.ValidateAsync(validatedObject, options), Is.SameAs(originalResult)); Mock.Get(failureMessageEnricher).Verify(x => x.GetResultWithMessagesAsync <object>(It.IsAny <IQueryableValidationResult <object> >(), It.IsAny <CancellationToken>()), Times.Never); }
/// <inheritdoc/> public async Task <IQueryableValidationResult <TValidated> > ValidateAsync(TValidated validatedObject, ValidationOptions options = null, CancellationToken cancellationToken = default) { var resolvedOptions = optionsResolver.GetResolvedValidationOptions(options); var rules = ruleFactory.GetRulesWithDependencies(manifest.RootValue, validatedObject, resolvedOptions); var executor = await executorFactory.GetRuleExecutorAsync(resolvedOptions, cancellationToken).ConfigureAwait(false); var context = contextFactory.GetExecutionContext(rules, resolvedOptions); var ruleResults = await executor.ExecuteAllRulesAsync(context, cancellationToken).ConfigureAwait(false); return(new ValidationResult <TValidated>(ruleResults, manifest)); }
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)); }
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>()); }
public void NonGenericValidateAsyncShouldNotThrowIfBehaviourIsNeverAndResultContainsBothErrorsAndFailures(string validated, ValidationOptions options) { Assert.That(async() => await ExerciseNonGenericSut(validated, options, RuleThrowingBehaviour.Never, Error(), Fail()), Throws.Nothing); }
public void NonGenericValidateAsyncShouldNotThrowIfBehaviourIsOnFailureAndResultsContainNoErrorsOrFailures(string validated, ValidationOptions options) { Assert.That(async() => await ExerciseNonGenericSut(validated, options, RuleThrowingBehaviour.OnFailure, Pass()), Throws.Nothing); }
public void NonGenericValidateAsyncShouldThrowIfBehaviourIsOnFailureAndResultsContainAFailure(string validated, ValidationOptions options) { Assert.That(async() => await ExerciseNonGenericSut(validated, options, RuleThrowingBehaviour.OnFailure, Fail()), Throws.InstanceOf <ValidationException>()); }