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 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 })); }
/// <summary> /// Initialises an instance of <see cref="ExecutableRuleAndDependencies"/>. /// </summary> /// <param name="executableRule">The rule.</param> /// <param name="dependencies">The rule's dependencies.</param> /// <param name="dependedUponBy">A collection of rules which depend upon <paramref name="executableRule"/>.</param> /// <exception cref="System.ArgumentNullException">If <paramref name="executableRule"/> is <see langword="null"/>.</exception> public ExecutableRuleAndDependencies(ExecutableRule executableRule, IEnumerable <ExecutableRule> dependencies = null, IEnumerable <ExecutableRule> dependedUponBy = null) { ExecutableRule = executableRule ?? throw new System.ArgumentNullException(nameof(executableRule)); Dependencies = new List <ExecutableRule>(dependencies ?? Enumerable.Empty <ExecutableRule>()); DependedUponBy = new List <ExecutableRule>(dependedUponBy ?? Enumerable.Empty <ExecutableRule>()); }
internal static async Task <ValidationRuleResult> ExecuteRuleAsync(ExecutableRule rule, IExeucutesSingleRule ruleExecutor, IRuleExecutionContext executionContext, CancellationToken cancellationToken) { var result = await ruleExecutor.ExecuteRuleAsync(rule, cancellationToken).ConfigureAwait(false); rule.Result = result; executionContext.HandleValidationRuleResult(rule); return(result); }
public async Task ExecuteRuleAsyncShouldGetContextFromFactory([Frozen] IGetsRuleContext contextFactory, [RuleContext] RuleContext context, [ExecutableModel] ExecutableRule rule, SingleRuleExecutor sut, [RuleResult] RuleResult expectedResult) { RuleContext capturedContext = null; Mock.Get(rule.RuleLogic) .Setup(x => x.GetResultAsync(It.IsAny <object>(), It.IsAny <object>(), It.IsAny <RuleContext>(), It.IsAny <CancellationToken>())) .Callback((object v1, object v2, RuleContext context, CancellationToken t) => capturedContext = context) .Returns(() => Task.FromResult(expectedResult)); Mock.Get(contextFactory).Setup(x => x.GetRuleContext(rule)).Returns(context); await sut.ExecuteRuleAsync(rule); Assert.That(capturedContext, Is.SameAs(context)); }
/// <inheritdoc/> public async Task <ValidationRuleResult> ExecuteRuleAsync(ExecutableRule rule, CancellationToken cancellationToken = default) { cancellationToken.ThrowIfCancellationRequested(); var context = contextFactory.GetRuleContext(rule); var timeout = rule.RuleLogic.GetTimeout(); using (var ruleTokenSource = timeout.HasValue ? new CancellationTokenSource(timeout.Value) : new CancellationTokenSource()) using (var combinedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, ruleTokenSource.Token)) { var ruleTask = rule.RuleLogic.GetResultAsync(rule.ValidatedValue.GetActualValue(), rule.ValidatedValue.ParentValue?.GetActualValue(), context, combinedTokenSource.Token); var result = await WaitForResultAsync(ruleTask, combinedTokenSource.Token, timeout).ConfigureAwait(false); return(new ValidationRuleResult(result, context, rule.RuleLogic)); } }
public async Task ExecuteRuleAsyncShouldReturnResultCreatedFromRuleLogic([Frozen] IGetsRuleContext contextFactory, [RuleContext] RuleContext context, [ExecutableModel] ExecutableRule rule, SingleRuleExecutor sut, [RuleResult] RuleResult expectedResult) { Mock.Get(rule.RuleLogic) .Setup(x => x.GetResultAsync(It.IsAny <object>(), It.IsAny <object>(), It.IsAny <RuleContext>(), It.IsAny <CancellationToken>())) .Returns(() => Task.FromResult(expectedResult)); Mock.Get(contextFactory).Setup(x => x.GetRuleContext(rule)).Returns(context); var result = await sut.ExecuteRuleAsync(rule); Assert.Multiple(() => { Assert.That(result.Data, Is.SameAs(expectedResult.Data), nameof(ValidationRuleResult.Data)); Assert.That(result.Outcome, Is.EqualTo(expectedResult.Outcome), nameof(ValidationRuleResult.Outcome)); }); }
/// <inheritdoc /> public void HandleValidationRuleResult(ExecutableRule rule) { if (rule.Result is null) { var message = String.Format(GetExceptionMessage("RuleResultMustNotBeNull"), nameof(ExecutableRule.Result)); throw new ArgumentException(message, nameof(rule)); } lock (syncRoot) { if (rule.Result.Outcome != RuleOutcome.Passed) { RemoveRuleAndAllDependentsFromPending(rule); } else { pendingRules.Remove(rule); } } }
/// <summary> /// When the specified <paramref name="rule"/> has failed then this rule and all of its dependencies must be /// removed from the collection of pending rules. Additionally, any rules removed in this way that do not yet /// have a <see cref="ExecutableRule.Result"/> must be marked with a result indicating /// <see cref="RuleOutcome.DependencyFailed"/>. /// </summary> /// <param name="rule">The rule which has failed validation in some manner.</param> void RemoveRuleAndAllDependentsFromPending(ExecutableRule rule) { var openList = new Queue <ExecutableRule>(GetRuleAndDependencies(rule).DependedUponBy); while (openList.Any()) { var current = openList.Dequeue(); pendingRules.Remove(current); var ruleAndDependencies = GetRuleAndDependencies(current); if (ruleAndDependencies.ExecutableRule.Result is null) { ruleAndDependencies.ExecutableRule.Result = new RuleResult(RuleOutcome.DependencyFailed); dependencyFailures.Add(ruleAndDependencies.ExecutableRule); } foreach (var dependedUpon in ruleAndDependencies.DependedUponBy) { openList.Enqueue(dependedUpon); } } }
static IEnumerable <ExecutableRule> GetDependencies(ExecutableRule rule) { return((from dependencyId in rule.ManifestRule.DependencyRules select GetDependency(dependencyId, rule)) .ToList()); }
public void GetRulesWhoseDependenciesHaveFailedShouldReturnCorrectRulesAfterHandleValidationRuleResult([ExecutableModel] ExecutableRule rule1, [ExecutableModel] ExecutableRule rule2, [ExecutableModel] ExecutableRule rule3, [ExecutableModel] ExecutableRule rule4) { var rulesAndDeps = new[] { new ExecutableRuleAndDependencies(rule1, new[] { rule2 }), new ExecutableRuleAndDependencies(rule2, new[] { rule3 }, new[] { rule1 }), new ExecutableRuleAndDependencies(rule3, null, new[] { rule2 }), new ExecutableRuleAndDependencies(rule4) }; var sut = GetSut(rulesAndDeps); rule3.Result = Fail(); sut.HandleValidationRuleResult(rule3); Assert.That(() => sut.GetRulesWhoseDependenciesHaveFailed(), Is.EquivalentTo(new[] { rule2, rule1 })); }
public void GetCircularDependenciesShouldReturnTwoWhenThereAreTwoCircularDependencies([ExecutableModel] ExecutableRule rule1, [ExecutableModel] ExecutableRule rule2, [ExecutableModel] ExecutableRule rule3, [ExecutableModel] ExecutableRule rule4, CircularDependencyDetector sut) { var rulesAndDependencies = new[] { new ExecutableRuleAndDependencies(rule1, new[] { rule2, }), new ExecutableRuleAndDependencies(rule2, new[] { rule1 }), new ExecutableRuleAndDependencies(rule3, new[] { rule4 }), new ExecutableRuleAndDependencies(rule4, new[] { rule3 }), }; Assert.That(() => sut.GetCircularDependencies(rulesAndDependencies).ToList(), Has.Count.EqualTo(2)); }
public void GetRulesWhichMayBeExecutedShouldNotReturnRulesWhichAlreadyHaveResults([ExecutableModel] ExecutableRule rule1, [ExecutableModel] ExecutableRule rule2, [ExecutableModel] ExecutableRule rule3, [ExecutableModel] ExecutableRule rule4, [ExecutableModel] ExecutableRule rule5) { rule1.Result = Pass(); rule2.Result = Fail(); rule3.Result = Error(); rule4.Result = new RuleResult(RuleOutcome.DependencyFailed); var rulesAndDeps = new[] { new ExecutableRuleAndDependencies(rule1), new ExecutableRuleAndDependencies(rule2), new ExecutableRuleAndDependencies(rule3), new ExecutableRuleAndDependencies(rule4), new ExecutableRuleAndDependencies(rule5) }; var sut = GetSut(rulesAndDeps); Assert.That(() => sut.GetRulesWhichMayBeExecuted(), Is.EquivalentTo(new[] { rule5 })); }
public void GetRulesWhichMayBeExecutedShouldNotReturnRulesWhichHaveFailedValues([ExecutableModel] ExecutableRule rule1, [ExecutableModel] ExecutableRule rule2, [ExecutableModel] ExecutableRule rule3, [ExecutableModel] ExecutableRule rule4, [ExecutableModel] ExecutableRule rule5) { rule1.ValidatedValue.ValueResponse = new IgnoredGetValueToBeValidatedResponse(); rule2.ValidatedValue.ValueResponse = new SuccessfulGetValueToBeValidatedResponse(new object()); rule3.ValidatedValue.ValueResponse = new ErrorGetValueToBeValidatedResponse(new Exception()); rule4.ValidatedValue.ValueResponse = new SuccessfulGetValueToBeValidatedResponse(new object()); rule5.ValidatedValue.ValueResponse = new ErrorGetValueToBeValidatedResponse(new Exception()); var rulesAndDeps = new[] { new ExecutableRuleAndDependencies(rule1), new ExecutableRuleAndDependencies(rule2), new ExecutableRuleAndDependencies(rule3), new ExecutableRuleAndDependencies(rule4), new ExecutableRuleAndDependencies(rule5) }; var sut = GetSut(rulesAndDeps); Assert.That(() => sut.GetRulesWhichMayBeExecuted(), Is.EquivalentTo(new[] { rule2, rule4 })); }
public async Task ExecuteRuleAsyncShouldReturnErrorResultWithTimeoutIfRuleTakesTooLongToExecute([Frozen] IGetsRuleContext contextFactory, [RuleContext] RuleContext context, [ExecutableModel] ExecutableRule rule, SingleRuleExecutor sut) { var timeout = TimeSpan.FromMilliseconds(100); Mock.Get(rule.RuleLogic).Setup(x => x.GetTimeout()).Returns(timeout); Mock.Get(rule.RuleLogic) .Setup(x => x.GetResultAsync(It.IsAny <object>(), It.IsAny <object>(), It.IsAny <RuleContext>(), It.IsAny <CancellationToken>())) .Returns(() => Task.Run(async() => { await Task.Delay(200); return(CommonResults.Pass()); })); Mock.Get(contextFactory).Setup(x => x.GetRuleContext(rule)).Returns(context); var result = await sut.ExecuteRuleAsync(rule); Assert.Multiple(() => { Assert.That(result.Outcome, Is.EqualTo(RuleOutcome.Errored), "Result has error outcome"); Assert.That(result.Data, Does.ContainKey(RuleResult.RuleTimeoutDataKey), "Result has a rule-timeout data key"); if (result.Data.TryGetValue(RuleResult.RuleTimeoutDataKey, out var timeoutData)) { Assert.That(timeoutData, Is.EqualTo(timeout), "Timeout data is equal"); } }); }
public void GetRulesWhichMayBeExecutedShouldReturnRulesWhichMayBeExecutedBecauseTheirDependenciesPassed([ExecutableModel] ExecutableRule rule1, [ExecutableModel] ExecutableRule rule2, [ExecutableModel] ExecutableRule rule3, [ExecutableModel] ExecutableRule rule4) { var rulesAndDeps = new[] { new ExecutableRuleAndDependencies(rule1, new[] { rule2 }), new ExecutableRuleAndDependencies(rule2, new[] { rule3 }, new[] { rule1 }), new ExecutableRuleAndDependencies(rule3, dependedUponBy: new[] { rule2 }), new ExecutableRuleAndDependencies(rule4) }; var sut = GetSut(rulesAndDeps); rule3.Result = Pass(); sut.HandleValidationRuleResult(rule3); Assert.That(() => sut.GetRulesWhichMayBeExecuted(), Is.EquivalentTo(new[] { rule2, rule4 })); }
public void GetCircularDependenciesShouldReturnAnEmptyCollectionIfThereAreNoCircularDependencies([ExecutableModel] ExecutableRule rule1, [ExecutableModel] ExecutableRule rule2, [ExecutableModel] ExecutableRule rule3, [ExecutableModel] ExecutableRule rule4, CircularDependencyDetector sut) { var rulesAndDependencies = new[] { new ExecutableRuleAndDependencies(rule1, new[] { rule2, rule3 }), new ExecutableRuleAndDependencies(rule2), new ExecutableRuleAndDependencies(rule3, new[] { rule2 }), new ExecutableRuleAndDependencies(rule4), }; Assert.That(() => sut.GetCircularDependencies(rulesAndDependencies), Is.Empty); }
public void GetCircularDependenciesShouldReturnACircularDependencyWithTheCorrectChainOfRules([ExecutableModel] ExecutableRule rule1, [ExecutableModel] ExecutableRule rule2, [ExecutableModel] ExecutableRule rule3, [ExecutableModel] ExecutableRule rule4, CircularDependencyDetector sut) { var rulesAndDependencies = new[] { new ExecutableRuleAndDependencies(rule1, new[] { rule2, }), new ExecutableRuleAndDependencies(rule2, new[] { rule3 }), new ExecutableRuleAndDependencies(rule3, new[] { rule4 }), new ExecutableRuleAndDependencies(rule4, new[] { rule1 }), }; Assert.That(() => sut.GetCircularDependencies(rulesAndDependencies).Single().DependencyChain, Is.EqualTo(new [] { rule1, rule2, rule3, rule4, rule1 })); }
public async Task ExecuteAllRulesAsyncShouldNotIncludeErrorResultsForIgnoredValues(IRuleExecutionContext executionContext, [Frozen] IExecutesAllRules wrapped, ResultsForErroredValuesExecutionDecorator sut, ErrorGetValueToBeValidatedResponse response1, IgnoredGetValueToBeValidatedResponse response2, [ExecutableModel] ExecutableRule rule1, [ExecutableModel] ExecutableRule rule2, [ExecutableModel] ExecutableRule rule3) { Mock.Get(wrapped) .Setup(x => x.ExecuteAllRulesAsync(executionContext, default)) .Returns(Task.FromResult <IReadOnlyCollection <ValidationRuleResult> >(Array.Empty <ValidationRuleResult>())); var ruleAndDependencies1 = new ExecutableRuleAndDependencies(rule1); var ruleAndDependencies2 = new ExecutableRuleAndDependencies(rule2); var ruleAndDependencies3 = new ExecutableRuleAndDependencies(rule3); rule1.ValidatedValue.ValueResponse = response1; rule2.ValidatedValue.ValueResponse = response1; rule3.ValidatedValue.ValueResponse = response2; Mock.Get(executionContext) .SetupGet(x => x.AllRules) .Returns(new[] { ruleAndDependencies1, ruleAndDependencies2, ruleAndDependencies3 }); var result = await sut.ExecuteAllRulesAsync(executionContext); Assert.Multiple(() => { Assert.That(result, Has.One.Matches <ValidationRuleResult>(v => v.Outcome == RuleOutcome.Errored && v.Exception == response1.Exception), "First response present"); Assert.That(result, Has.Count.EqualTo(1), "Correct count"); }); }
public void GetRulesWithDependenciesShouldNotReturnAnyDependenciesForARuleWhichHasNone([Frozen] IGetsAllExecutableRules executableRulesProvider, [ManifestModel] ManifestValue manifestValue, object objectToBeValidated, [ExecutableModel] ExecutableRule rule, ExecutableRulesAndDependenciesProvider sut, ResolvedValidationOptions validationOptions) { Mock.Get(executableRulesProvider) .Setup(x => x.GetExecutableRules(manifestValue, objectToBeValidated, validationOptions)) .Returns(new [] { rule }); var result = sut.GetRulesWithDependencies(manifestValue, objectToBeValidated, validationOptions); Assert.That(result.Single().Dependencies, Is.Empty); }
public void ExecuteRuleAsyncShouldReturnPassResultWithTimeoutIfRuleCompletesInATimelyManner([Frozen] IGetsRuleContext contextFactory, [RuleContext] RuleContext context, [ExecutableModel] ExecutableRule rule, SingleRuleExecutor sut) { var timeout = TimeSpan.FromMilliseconds(300); Mock.Get(rule.RuleLogic).Setup(x => x.GetTimeout()).Returns(timeout); Mock.Get(rule.RuleLogic) .Setup(x => x.GetResultAsync(It.IsAny <object>(), It.IsAny <object>(), It.IsAny <RuleContext>(), It.IsAny <CancellationToken>())) .Returns(() => Task.Run(async() => { await Task.Delay(50); return(CommonResults.Pass()); })); Mock.Get(contextFactory).Setup(x => x.GetRuleContext(rule)).Returns(context); Assert.That(() => sut.ExecuteRuleAsync(rule), Is.PassingValidationResult); }
public void ExecuteRuleAsyncShouldThrowIfCancellationIsRequestedWithoutExecutingRuleLogic([Frozen] IGetsRuleContext contextFactory, [RuleContext] RuleContext context, [ExecutableModel] ExecutableRule rule, SingleRuleExecutor sut, [AlreadyCancelled] CancellationToken token) { Mock.Get(contextFactory).Setup(x => x.GetRuleContext(rule)).Returns(context); Assert.That(async() => await sut.ExecuteRuleAsync(rule, token), Throws.InstanceOf <OperationCanceledException>()); Mock.Get(rule.RuleLogic) .Verify(x => x.GetResultAsync(It.IsAny <object>(), It.IsAny <object>(), It.IsAny <RuleContext>(), It.IsAny <CancellationToken>()), Times.Never); }
ExecutableRuleAndDependencies GetRuleAndDependencies(ExecutableRule rule) => allRules[rule];
static ExecutableRule GetDependency(ManifestRuleIdentifier dependencyIdentifier, ExecutableRule rule) { var matchingValidatedValue = GetCandidateValidatedValueMatches(dependencyIdentifier, rule) .FirstOrDefault(x => !(x is null)); if (matchingValidatedValue is null) { var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("CannotGetMatchingValueForDependency"), rule.ManifestRule.Identifier, dependencyIdentifier); throw new ValidationException(message); } var dependency = matchingValidatedValue.Rules .FirstOrDefault(valueRule => Equals(valueRule.ManifestRule.Identifier, dependencyIdentifier)); if (dependency == null) { var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("DependencyRuleNotOnMatchingValue"), rule.ManifestRule.Identifier, dependencyIdentifier); throw new ValidationException(message); } return(dependency); }
public void GetRulesWhichMayBeExecutedShouldNotReturnRulesWhichHaveUnresolvedDependencies([ExecutableModel] ExecutableRule rule1, [ExecutableModel] ExecutableRule rule2, [ExecutableModel] ExecutableRule rule3, [ExecutableModel] ExecutableRule rule4) { var rulesAndDeps = new[] { new ExecutableRuleAndDependencies(rule1, new[] { rule2 }), new ExecutableRuleAndDependencies(rule2, new[] { rule3 }, new[] { rule1 }), new ExecutableRuleAndDependencies(rule3, null, new[] { rule2 }), new ExecutableRuleAndDependencies(rule4) }; var sut = GetSut(rulesAndDeps); Assert.That(() => sut.GetRulesWhichMayBeExecuted(), Is.EquivalentTo(new[] { rule3, rule4 })); }
static IEnumerable <ValidatedValue> GetCandidateValidatedValueMatches(ManifestRuleIdentifier dependencyIdentifier, ExecutableRule rule) { for (var currentValue = rule.ValidatedValue; currentValue != null; currentValue = currentValue.ParentValue) { yield return(GetMatchingValidatedValue(dependencyIdentifier, currentValue)); } }
public async Task ExecuteRuleAsyncShouldExecuteRuleLogicWithCorrectValidatedInstances([Frozen] IGetsRuleContext contextFactory, [RuleContext] RuleContext context, [ExecutableModel] ExecutableRule rule, SingleRuleExecutor sut, ValidatedValue validatedValue, ValidatedValue parentValue, [RuleResult] RuleResult expectedResult) { rule.ValidatedValue = validatedValue; validatedValue.ParentValue = parentValue; Mock.Get(contextFactory).Setup(x => x.GetRuleContext(rule)).Returns(context); Mock.Get(rule.RuleLogic) .Setup(x => x.GetResultAsync(It.IsAny <object>(), It.IsAny <object>(), It.IsAny <RuleContext>(), It.IsAny <CancellationToken>())) .Returns(() => Task.FromResult(expectedResult)); await sut.ExecuteRuleAsync(rule); Mock.Get(rule.RuleLogic) .Verify(x => x.GetResultAsync(validatedValue.GetActualValue(), parentValue.GetActualValue(), It.IsAny <RuleContext>(), It.IsAny <CancellationToken>()), Times.Once); }
public async Task ExecuteAllRulesAsyncShouldReturnAResultForEachRuleWithFailedDependencies([Frozen] IExecutesAllRules wrapped, [Frozen] IGetsRuleContext contextFactory, ResultsForRulesWithFailedDependenciesExecutionDecorator sut, IRuleExecutionContext executionContext, [ExecutableModel] ExecutableRule rule1, [ExecutableModel] ExecutableRule rule2, [RuleContext] RuleContext context) { Mock.Get(wrapped) .Setup(x => x.ExecuteAllRulesAsync(executionContext, default)) .Returns(Task.FromResult <IReadOnlyCollection <ValidationRuleResult> >(Array.Empty <ValidationRuleResult>())); Mock.Get(executionContext) .Setup(x => x.GetRulesWhoseDependenciesHaveFailed()) .Returns(new[] { rule1, rule2 }); Mock.Get(contextFactory) .Setup(x => x.GetRuleContext(It.IsAny <ExecutableRule>())) .Returns(context); rule1.Result = new RuleResult(RuleOutcome.DependencyFailed); rule2.Result = new RuleResult(RuleOutcome.DependencyFailed); var results = await sut.ExecuteAllRulesAsync(executionContext); Assert.Multiple(() => { Assert.That(results, Has.Count.EqualTo(2), "Count of results"); Assert.That(results.Select(x => x.ValidationLogic).ToList(), Is.EqualTo(new[] { rule1.RuleLogic, rule2.RuleLogic }), "Correct rules used, identified by their logic instances."); }); }
public void GetExecutableRulesShouldReturnAFlattenedListOfRulesIncludingCollectionItemRules([Frozen] IGetsValidatedValue validatedValueProvider, [ExecutableModel] ValidatedValue rootValue, [ExecutableModel] ValidatedValue childVal1, [ExecutableModel] ValidatedValue childVal2, [ExecutableModel] ValidatedValue collectionValue1, [ExecutableModel] ValidatedValue collectionValue2, [ExecutableModel] ExecutableRule rule1, [ExecutableModel] ExecutableRule rule2, [ExecutableModel] ExecutableRule rule3, [ExecutableModel] ExecutableRule rule4, [ExecutableModel] ExecutableRule rule5, [ExecutableModel] ExecutableRule rule6, ExecutableRulesFromValidatedValueProvider sut, [ManifestModel] ManifestValue manifestValue, object valueToBeValidated, ResolvedValidationOptions validationOptions) { rootValue.ChildValues.Add(childVal1); rootValue.ChildValues.Add(childVal2); childVal2.CollectionItems.Add(collectionValue1); childVal2.CollectionItems.Add(collectionValue2); rootValue.Rules.Add(rule1); childVal1.Rules.Add(rule2); childVal1.Rules.Add(rule3); childVal2.Rules.Add(rule4); collectionValue1.Rules.Add(rule5); collectionValue2.Rules.Add(rule6); Mock.Get(validatedValueProvider).Setup(x => x.GetValidatedValue(manifestValue, valueToBeValidated, validationOptions)).Returns(rootValue); var expected = new[] { rule1, rule2, rule3, rule4, rule5, rule6 }; Assert.That(() => sut.GetExecutableRules(manifestValue, valueToBeValidated, validationOptions), Is.EquivalentTo(expected)); }