public void ForMemberShouldThrowIfTheResultManifestHasNoChildrenOfThatName([ManifestModel] ValidationManifest manifest)
{
manifest.ValidatedType = typeof(string);
var sut = new ValidationResult <string>(Enumerable.Empty <ValidationRuleResult>(), manifest);
Assert.That(() => sut.ForMember(x => x.Length), Throws.ArgumentException);
}
/// <inheritdoc/>
public IValidator GetValidator(ValidationManifest manifest)
{
var validator = BaseValidatorFactory.GetValidator(manifest);
var messaageValidator = MessageSupportWrapper.GetValidatorWithMessageSupport(validator);
return(ExceptionBehaviourWrapper.WrapValidator(messaageValidator));
}
public async Task RecursiveValidationShouldReturnaResultFromADescendentObjectValidatedUsingTheSameManifestAsAnAncestor([IntegrationTesting] IGetsValidator validatorFactory)
{
var manifest = new ValidationManifest
{
ValidatedType = typeof(Node),
RootValue = new ManifestValue
{
ValidatedType = typeof(Node),
IdentityAccessor = obj => ((Node)obj).Identity,
Children = new[] {
new ManifestValue
{
ValidatedType = typeof(NodeChild),
IdentityAccessor = obj => ((NodeChild)obj).Identity,
AccessorFromParent = obj => ((Node)obj).Child,
},
new ManifestValue
{
ValidatedType = typeof(string),
AccessorFromParent = obj => ((Node)obj).Name,
}
}
}
};
var nameValue = manifest.RootValue.Children.Single(x => x.ValidatedType == typeof(string));
var nameRule = new ManifestRule(nameValue, new ManifestRuleIdentifier(nameValue, typeof(MatchesRegex)))
{
RuleConfiguration = obj => ((MatchesRegex)obj).Pattern = "^Foo",
};
nameValue.Rules.Add(nameRule);
var childValue = manifest.RootValue.Children.Single(x => x.ValidatedType == typeof(NodeChild));
var recursiveValue = new RecursiveManifestValue(manifest.RootValue)
{
AccessorFromParent = obj => ((NodeChild)obj).Node,
};
childValue.Children.Add(recursiveValue);
var validatedObject = new Node
{
Child = new NodeChild
{
Node = new Node
{
Child = new NodeChild {
Node = new Node {
Name = "Invalid"
}
}
}
}
};
var sut = validatorFactory.GetValidator <Node>(manifest);
var result = await sut.ValidateAsync(validatedObject);
Assert.That(result, Has.One.Matches <ValidationRuleResult>(r => r.Outcome == RuleOutcome.Failed && Equals(r.ValidatedValue, "Invalid")));
}
public void ValidatingACircularReferenceShouldNotThrowOrTimeOut([IntegrationTesting] IGetsValidator validatorFactory)
{
var manifest = new ValidationManifest
{
ValidatedType = typeof(Node),
RootValue = new ManifestValue
{
ValidatedType = typeof(Node),
IdentityAccessor = obj => ((Node)obj).Identity,
Children = new[] {
new ManifestValue
{
ValidatedType = typeof(NodeChild),
IdentityAccessor = obj => ((NodeChild)obj).Identity,
AccessorFromParent = obj => ((Node)obj).Child,
},
new ManifestValue
{
ValidatedType = typeof(string),
AccessorFromParent = obj => ((Node)obj).Name,
}
}
}
};
var nameValue = manifest.RootValue.Children.Single(x => x.ValidatedType == typeof(string));
var nameRule = new ManifestRule(nameValue, new ManifestRuleIdentifier(nameValue, typeof(MatchesRegex)))
{
RuleConfiguration = obj => ((MatchesRegex)obj).Pattern = "^Foo",
};
nameValue.Rules.Add(nameRule);
var childValue = manifest.RootValue.Children.Single(x => x.ValidatedType == typeof(NodeChild));
var recursiveValue = new RecursiveManifestValue(manifest.RootValue)
{
AccessorFromParent = obj => ((NodeChild)obj).Node,
};
childValue.Children.Add(recursiveValue);
var validatedObject = new Node
{
Child = new NodeChild
{
Node = new Node
{
Child = new NodeChild {
Node = new Node {
Name = "Invalid"
}
}
}
}
};
validatedObject.Child.Node.Child.Node.Child = validatedObject.Child;
var sut = validatorFactory.GetValidator <Node>(manifest);
Assert.That(() => sut.ValidateAsync(validatedObject).Wait(300), Is.True, "Validation completes within 300ms");
}
public void GetValidatorNonGenericShouldReturnValidatorManifest([Frozen] IGetsValidatorFromManifest validatorFromManifestFactory,
BaseValidatorFactory sut,
[ManifestModel] ValidationManifest manifest,
IValidator validator)
{
Mock.Get(validatorFromManifestFactory).Setup(x => x.GetValidator(manifest)).Returns(validator);
Assert.That(() => sut.GetValidator(manifest), Is.SameAs(validator));
}
/// <summary>
/// Initialises a new generic instance of <see cref="ValidationResult{TValidated}"/>.
/// </summary>
/// <param name="ruleResults">The rule results.</param>
/// <param name="manifest">The validation manifest.</param>
/// <exception cref="ArgumentException">If <paramref name="manifest"/> is for a type that is not compatible with <typeparamref name="TValidated"/>.</exception>
/// <exception cref="ArgumentNullException">If either parameter is <see langword="null" />.</exception>
public ValidationResult(IEnumerable <ValidationRuleResult> ruleResults, ValidationManifest manifest) : base(ruleResults, manifest)
{
if (!typeof(TValidated).IsAssignableFrom(manifest.ValidatedType))
{
var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("ValidationResultMustBeOfCorrectType"),
typeof(TValidated).FullName,
manifest.ValidatedType.FullName);
throw new ArgumentException(message, nameof(manifest));
}
}
/// <summary>
/// Initialises a new instance of <see cref="ValidationResult"/>.
/// </summary>
/// <param name="ruleResults">The rule results.</param>
/// <param name="manifest">The validation manifest</param>
/// <exception cref="ArgumentNullException">If either parameter is <see langword="null" />.</exception>
protected ValidationResult(IEnumerable <ValidationRuleResult> ruleResults, ValidationManifest manifest)
{
if (ruleResults is null)
{
throw new ArgumentNullException(nameof(ruleResults));
}
RuleResults = ruleResults.ToList();
Passed = RuleResults.All(r => r.Outcome == RuleOutcome.Passed);
Manifest = manifest ?? throw new ArgumentNullException(nameof(manifest));
}
public void GetValidatorShouldReturnCorrectGenericValidatorForManifest(IGetsValidator factory,
StubValidator validator,
[ManifestModel] ValidationManifest manifest)
{
Mock.Get(factory)
.Setup(x => x.GetValidator(manifest))
.Returns(validator);
manifest.ValidatedType = typeof(ValidatedObject);
Assert.That(() => factory.GetValidator <ValidatedObject>(manifest), Is.SameAs(validator));
}
/// <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));
}
public void ConstructorShouldThrowIfInstantiatedForAnIncompatibleType([ManifestModel] ValidationManifest manifest)
{
manifest.ValidatedType = typeof(string);
Assert.That(() => new ValidationResult <int>(Enumerable.Empty <ValidationRuleResult>(), manifest), Throws.ArgumentException);
}
public void ConstructorShouldNotThrowIfInstantiatedForACompatible([ManifestModel] ValidationManifest manifest)
{
manifest.ValidatedType = typeof(string);
Assert.That(() => new ValidationResult <object>(Enumerable.Empty <ValidationRuleResult>(), manifest), Throws.Nothing);
}
public void ForMatchingMemberItemShouldThrowIfTheResultManifestHasNoChildrenOfThatName([ManifestModel] ValidationManifest manifest, Person person, Pet pet)
{
person.Pets.Add(pet);
manifest.ValidatedType = typeof(Person);
var sut = new ValidationResult <Person>(Enumerable.Empty <ValidationRuleResult>(), manifest);
Assert.That(() => sut.ForMatchingMemberItem(x => x.Pets, pet),
Throws.ArgumentException.And.Message.Contains("does not contain any values for a member named"));
}
/// <inheritdoc/> public IValidator GetValidator(ValidationManifest manifest) => validatorFromManifestProvider.GetValidator(manifest);
public void ForMatchingMemberItemShouldThrowIfTheRequestedMemberIsNotACollectionItem([ManifestModel] ValidationManifest manifest,
[ManifestModel] ManifestValue value,
Person person,
Pet pet)
{
person.Pets.Add(pet);
manifest.ValidatedType = typeof(Person);
manifest.RootValue.Children.Add(value);
value.MemberName = nameof(Person.Pets);
value.CollectionItemValue = null;
var sut = new ValidationResult <Person>(Enumerable.Empty <ValidationRuleResult>(), manifest);
Assert.That(() => sut.ForMatchingMemberItem(x => x.Pets, pet),
Throws.ArgumentException.And.Message.Contains("but in order to use ForMatchingMemberItem, that value must represent a collection of items"));
}
public void GetValidatorGenericShouldReturnGenericValidatorFromCreatedManifest([Frozen] IGetsManifestFromBuilder manifestFromBuilderProvider,
[Frozen] IGetsValidatorFromManifest validatorFromManifestFactory,
BaseValidatorFactory sut,
IBuildsValidator <object> builder,
[ManifestModel] ValidationManifest manifest)
{
Mock.Get(manifestFromBuilderProvider).Setup(x => x.GetManifest(builder)).Returns(manifest);
var validator = new Mock <IValidator <object> >();
var nonGenericValidator = validator.As <IValidator>();
Mock.Get(validatorFromManifestFactory).Setup(x => x.GetValidator(manifest)).Returns(nonGenericValidator.Object);
Assert.That(() => sut.GetValidator(builder), Is.SameAs(nonGenericValidator.Object));
}
public void PolymorphicAsShouldThrowIfTheManifestDoesNotHaveAMatchingPolymorphicType([ManifestModel] ValidationManifest manifest,
[ManifestModel] ManifestValue value)
{
manifest.ValidatedType = typeof(Person);
manifest.RootValue = value;
value.ValidatedType = typeof(Person);
value.PolymorphicTypes.Clear();
var sut = new ValidationResult <Person>(Enumerable.Empty <ValidationRuleResult>(), manifest);
Assert.That(() => sut.PolymorphicAs <Employee>(),
Throws.ArgumentException.And.Message.StartsWith("The validation manifest value (for CSF.Validation.IntegrationTests.Person) must contain a polymorphic"));
}
public void GetValidatorShouldThrowIfManifestTypeIsNotCorrectForValidatedType(IGetsValidator factory,
[ManifestModel] ValidationManifest manifest)
{
manifest.ValidatedType = typeof(string);
Assert.That(() => factory.GetValidator <ValidatedObject>(manifest), Throws.ArgumentException);
}
public void GetValidatorFromManifestModelShouldReturnValidatorUsingManifestCreatedFromModelWrappedInThrowingBehaviour([Frozen, AutofixtureServices] IServiceProvider serviceProvider,
[Frozen] IGetsBaseValidator baseValidatorFactory,
[Frozen] IWrapsValidatorWithExceptionBehaviour exceptionBehaviourWrapper,
[Frozen] IWrapsValidatorWithMessageSupport messageWrapper,
[Frozen] IGetsValidationManifestFromModel manifestFromModelProvider,
ValidatorFactory sut,
[ManifestModel] Value manifestModel,
Type validatedType,
[ManifestModel] ValidationManifest manifest,
IValidator baseValidator)
{
var expectedValidatorMock = new Mock <IValidator <ValidatedObject> >();
var expectedValidator = expectedValidatorMock.As <IValidator>().Object;
var messageValidatorMock = new Mock <IValidator <ValidatedObject> >();
var messageValidator = messageValidatorMock.As <IValidator>().Object;
Mock.Get(manifestFromModelProvider).Setup(x => x.GetValidationManifest(manifestModel, validatedType)).Returns(manifest);
Mock.Get(baseValidatorFactory).Setup(x => x.GetValidator(manifest)).Returns(baseValidator);
Mock.Get(messageWrapper).Setup(x => x.GetValidatorWithMessageSupport(baseValidator)).Returns(messageValidator);
Mock.Get(exceptionBehaviourWrapper).Setup(x => x.WrapValidator(messageValidator)).Returns(expectedValidator);
Assert.That(() => sut.GetValidator(manifestModel, validatedType), Is.SameAs(expectedValidator));
}
