public void GetResultAsyncShouldReturnResultFromWrappedRuleIfItDoesNotThrow([Frozen] IValidationLogic wrapped,
ExceptionHandlingRuleLogicDecorator sut,
object value,
object parentValue,
[RuleContext] RuleContext context,
[RuleResult] RuleResult result)
{
Mock.Get(wrapped)
.Setup(x => x.GetResultAsync(value, parentValue, context, It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(result));
Assert.That(async() => await sut.GetResultAsync(value, parentValue, context, default), Is.SameAs(result));
}
/// <summary>
/// Initializes a new instance of the <see cref="ValidationRuleResult"/> class.
/// </summary>
/// <remarks>
/// <para>
/// This constructor copies-information-from and then enriches a <see cref="RuleResult"/> with further information.
/// </para>
/// </remarks>
/// <param name="result">The rule result.</param>
/// <param name="ruleContext">The rule context.</param>
/// <param name="validationLogic">The validation logic for the rule.</param>
/// <param name="message">The human-readable validation feedback message.</param>
public ValidationRuleResult(RuleResult result,
RuleContext ruleContext,
IValidationLogic validationLogic,
string message = default) : base(result)
{
RuleContext = ruleContext;
ValidationLogic = validationLogic;
Identifier = ruleContext?.RuleIdentifier;
RuleInterface = ruleContext?.RuleInterface;
ValidatedValue = ruleContext?.ActualValue;
Message = message;
}
public void GetResultAsyncShouldNotThrowIfWrappedRuleThrows([Frozen] IValidationLogic wrapped,
ExceptionHandlingRuleLogicDecorator sut,
object value,
object parentValue,
[RuleContext] RuleContext context,
Exception exception)
{
Mock.Get(wrapped)
.Setup(x => x.GetResultAsync(value, parentValue, context, It.IsAny <CancellationToken>()))
.Throws(exception);
Assert.That(async() => await sut.GetResultAsync(value, parentValue, context, default), Throws.Nothing);
}
public void GetFailureMessageAsyncShouldCallWrappedServiceWithOneGenericType([Frozen] IGetsFailureMessage <string> wrapped,
FailureMessageProviderAdapter <string> sut,
[RuleResult] RuleResult ruleResult,
[ManifestModel] ManifestRule rule,
Type ruleInterface,
RuleIdentifier id,
string actualValue,
string expectedResult,
IValidationLogic validationLogic)
{
var context = new RuleContext(rule, id, actualValue, Enumerable.Empty <ValueContext>(), ruleInterface);
var validationRuleResult = new ValidationRuleResult(ruleResult, context, validationLogic);
Mock.Get(wrapped).Setup(x => x.GetFailureMessageAsync(actualValue, validationRuleResult, default)).Returns(Task.FromResult(expectedResult));
Assert.That(async() => await sut.GetFailureMessageAsync(validationRuleResult), Is.EqualTo(expectedResult));
}
public async Task GetResultAsyncShouldReturnErroredResultIfWrappedRuleThrows([Frozen] IValidationLogic wrapped,
ExceptionHandlingRuleLogicDecorator sut,
object value,
object parentValue,
[RuleContext] RuleContext context,
Exception exception)
{
Mock.Get(wrapped)
.Setup(x => x.GetResultAsync(value, parentValue, context, It.IsAny <CancellationToken>()))
.Throws(exception);
var result = await sut.GetResultAsync(value, parentValue, context, default);
Assert.Multiple(() =>
{
Assert.That(result, Has.Property(nameof(RuleResult.Outcome)).EqualTo(RuleOutcome.Errored));
Assert.That(result, Has.Property(nameof(RuleResult.Exception)).SameAs(exception));
});
}
public void CanGetFailureMessageShouldCallWrappedServiceWithOneGenericType([Frozen] IHasFailureMessageUsageCriteria <string> wrapped,
FailureMessageCriteriaAdapter <string> sut,
[RuleResult] RuleResult ruleResult,
[ManifestModel] ManifestRule rule,
Type ruleInterface,
RuleIdentifier id,
string actualValue,
bool expectedResult,
IValidationLogic validationLogic)
{
var context = new RuleContext(rule, id, actualValue, Enumerable.Empty <ValueContext>(), ruleInterface);
var validationRuleResult = new ValidationRuleResult(ruleResult, context, validationLogic);
Mock.Get(wrapped).Setup(x => x.CanGetFailureMessage(actualValue, validationRuleResult)).Returns(expectedResult);
var actualResult = sut.CanGetFailureMessage(validationRuleResult);
Assert.Multiple(() =>
{
Assert.That(actualResult, Is.EqualTo(expectedResult), "Actual result matches expected");
Mock.Get(wrapped).Verify(x => x.CanGetFailureMessage(actualValue, validationRuleResult), Times.Once, "Wrapped service was called");
});
}
public void GetValidatedValueShouldGetAnExecutableRuleUsingTheLogicFactoryFromEachManifestRule([Frozen] IGetsValidationLogic validationLogicFactory,
ValidatedValueFromBasisFactory sut,
[ExecutableModel] ValidatedValueBasis basis,
[ManifestModel] ManifestRule rule1,
[ManifestModel] ManifestRule rule2,
IValidationLogic logic1,
IValidationLogic logic2)
{
Mock.Get(validationLogicFactory).Setup(x => x.GetValidationLogic(rule1)).Returns(logic1);
Mock.Get(validationLogicFactory).Setup(x => x.GetValidationLogic(rule2)).Returns(logic2);
basis.ManifestValue.Rules.Add(rule1);
basis.ManifestValue.Rules.Add(rule2);
var result = sut.GetValidatedValue(basis);
Assert.That(result.Rules.Select(x => x.RuleLogic).ToList(), Is.EqualTo(new[] { logic1, logic2 }));
}
public void GetExpressionShouldReturnAnExpressionWhichReturnsTrueForAResultWhichMatchesTheCurrentContextWithAValue([ManifestModel] ManifestRule rule,
[RuleId] RuleIdentifier ruleIdentifier,
object actualValue,
Type ruleInterface,
[RuleResult] RuleResult ruleResult,
IValidationLogic logic)
{
((ManifestValueBase)rule.ManifestValue).IdentityAccessor = null;
var context = new RuleContext(rule, ruleIdentifier, actualValue, Enumerable.Empty <ValueContext>(), ruleInterface);
var validationRuleResult = new ValidationRuleResult(ruleResult, context, logic);
var sut = new RuleResultIsForDescendentOfValue(rule.ManifestValue, actualValue);
Assert.That(() => sut.Matches(validationRuleResult), Is.True);
}
public void GetExpressionShouldReturnAnExpressionWhichReturnsFalseForAResultWhichMatchesAnAncestorContextWhenAllowAncestorsIsFalse([ManifestModel] ManifestValue value,
[ManifestModel] ManifestValue otherValue,
[ManifestModel] ManifestRule rule,
[RuleId] RuleIdentifier ruleIdentifier,
object identity,
object actualValue,
Type ruleInterface,
[RuleResult] RuleResult ruleResult,
IValidationLogic logic)
{
value.IdentityAccessor = null;
var context = new RuleContext(rule, ruleIdentifier, actualValue, new [] { new ValueContext(identity, actualValue, value) }, ruleInterface);
var validationRuleResult = new ValidationRuleResult(ruleResult, context, logic);
var sut = new RuleResultIsForDescendentOfValue(value, false);
Assert.That(() => sut.Matches(validationRuleResult), Is.False);
}
/// <summary>
/// Initialises an instance of <see cref="ExceptionHandlingRuleLogicDecorator"/>.
/// </summary>
/// <param name="wrapped">The rule logic to be wrapped by the current instance.</param>
public ExceptionHandlingRuleLogicDecorator(IValidationLogic wrapped)
{
this.wrapped = wrapped ?? throw new ArgumentNullException(nameof(wrapped));
}
public void GetRulesWithDependenciesShouldReturnAnObjectWithDependencyExecutableRulesWhereItHasADependencyUponAParentValue([Frozen] IGetsAllExecutableRules executableRulesProvider,
[ManifestModel] ManifestValue manifestValue,
object objectToBeValidated,
IValidationLogic logic,
ManifestRule manifestRule,
ManifestRule manifestDependency,
[ExecutableModel] ValidatedValue validatedValue,
[ExecutableModel] ValidatedValue parentValue,
ExecutableRulesAndDependenciesProvider sut,
ResolvedValidationOptions validationOptions)
{
var rule = new ExecutableRule {
ValidatedValue = validatedValue, ManifestRule = manifestRule, RuleLogic = logic
};
validatedValue.ParentValue = parentValue;
var dependency = new ExecutableRule {
ValidatedValue = parentValue, ManifestRule = manifestDependency, RuleLogic = logic
};
parentValue.ManifestValue = manifestDependency.Identifier.ManifestValue;
parentValue.Rules.Add(dependency);
Mock.Get(executableRulesProvider)
.Setup(x => x.GetExecutableRules(manifestValue, objectToBeValidated, validationOptions))
.Returns(new [] { rule, dependency });
rule.ManifestRule.DependencyRules.Clear();
rule.ManifestRule.DependencyRules.Add(manifestDependency.Identifier);
var result = sut.GetRulesWithDependencies(manifestValue, objectToBeValidated, validationOptions);
Assert.That(result.First(x => x.ExecutableRule == rule).Dependencies, Is.EqualTo(new[] { dependency }));
}
public void IsMatchShouldReturnFalseIfActualValidatedTypeIsNotASubclassOfAttributeType([RuleResult] RuleResult result,
[ManifestModel] ManifestRule rule,
Type ruleType,
object objectId,
object actualValue,
IValidationLogic validationLogic)
{
var id = new RuleIdentifier(ruleType, typeof(Employee), objectId);
var context = new RuleContext(rule, id, actualValue, Enumerable.Empty <ValueContext>(), typeof(string));
var ruleResult = new ValidationRuleResult(result, context, validationLogic);
var sut = new FailureMessageStrategyAttribute
{
ValidatedType = typeof(string),
};
Assert.That(() => sut.IsMatch(ruleResult), Is.False);
}
public ValidateController(IValidationLogic validation)
{
_validationLogic = validation;
}
ValidationRuleResult GetValidationRuleResult(RuleResult result, ManifestRule manifestRule, RuleIdentifier ruleIdentifier, IValidationLogic logic)
{
var valueContext = new ValueContext(Guid.NewGuid(), ParentValue, manifestRule.ManifestValue);
var context = new RuleContext(manifestRule, ruleIdentifier, ValidatedValue, new [] { valueContext }, RuleInterface);
return(new ValidationRuleResult(result, context, logic));
}
static IValidationLogic WrapWithExceptionHandlingDecorator(IValidationLogic logic) => new ExceptionHandlingRuleLogicDecorator(logic);
public void IsMatchShouldReturnTrueIfActualParentValidatedTypeIsASubclassOfAttributeParentType([RuleResult] RuleResult result,
[ManifestModel] ManifestRule rule,
Type type,
object objectId,
object actualValue,
IValidationLogic validationLogic)
{
var id = new RuleIdentifier(type, type, objectId);
var context = new RuleContext(rule, id, actualValue, new [] { new ValueContext(objectId, actualValue, new ManifestValue {
ValidatedType = typeof(Employee)
}) }, typeof(string));
var ruleResult = new ValidationRuleResult(result, context, validationLogic);
var sut = new FailureMessageStrategyAttribute
{
ParentValidatedType = typeof(Person),
};
Assert.That(() => sut.IsMatch(ruleResult), Is.True);
}
public void GetRulesWithDependenciesShouldThrowIfTheMatchingValueDoesNotHaveTheSpecifiedRule([Frozen] IGetsAllExecutableRules executableRulesProvider,
[ManifestModel] ManifestValue manifestValue,
object objectToBeValidated,
IValidationLogic logic,
ManifestRule manifestRule,
ManifestRule manifestDependency,
[ExecutableModel] ValidatedValue validatedValue,
[ExecutableModel] ValidatedValue parentValue,
ExecutableRulesAndDependenciesProvider sut,
ResolvedValidationOptions validationOptions)
{
var rule = new ExecutableRule {
ValidatedValue = validatedValue, ManifestRule = manifestRule, RuleLogic = logic
};
validatedValue.ParentValue = parentValue;
var dependency = new ExecutableRule {
ValidatedValue = parentValue, ManifestRule = manifestDependency, RuleLogic = logic
};
parentValue.ManifestValue = manifestDependency.Identifier.ManifestValue;
Mock.Get(executableRulesProvider)
.Setup(x => x.GetExecutableRules(manifestValue, objectToBeValidated, validationOptions))
.Returns(new [] { rule, dependency });
rule.ManifestRule.DependencyRules.Clear();
rule.ManifestRule.DependencyRules.Add(manifestDependency.Identifier);
Assert.That(() => sut.GetRulesWithDependencies(manifestValue, objectToBeValidated, validationOptions), Throws.InstanceOf <ValidationException>());
}
public void IsMatchShouldReturnFalseIfTheRuleInterfaceIsSpecifiedButDoesNotMatch([RuleResult] RuleResult result,
[ManifestModel] ManifestRule rule,
RuleIdentifier id,
object actualValue,
IValidationLogic validationLogic)
{
var context = new RuleContext(rule, id, actualValue, Enumerable.Empty <ValueContext>(), typeof(string));
var ruleResult = new ValidationRuleResult(result, context, validationLogic);
var sut = new FailureMessageStrategyAttribute
{
RuleInterface = typeof(int),
};
Assert.That(() => sut.IsMatch(ruleResult), Is.False);
}
