/// <summary> /// Gets the validated value. /// </summary> /// <param name="basis">A validated-value basis.</param> /// <returns>A validated value.</returns> public ValidatedValue GetValidatedValue(ValidatedValueBasis basis) { var valueIdentity = GetIdentity(basis); var value = new ValidatedValue { ManifestValue = basis.ManifestValue, ValueResponse = basis.ValidatedValueResponse, ValueIdentity = valueIdentity, ParentValue = basis.Parent, CollectionItemOrder = basis.CollectionOrder, }; value.Rules = basis.GetManifestRules() .Select(manifestRule => new ExecutableRule { ValidatedValue = value, ManifestRule = manifestRule, RuleLogic = validationLogicFactory.GetValidationLogic(manifestRule), RuleIdentifier = new RuleIdentifier(manifestRule, valueIdentity), }) .ToList(); return(value); }
public void GetValidatedValueShouldGetIdentityFromAccessorIfThereIsOne(ValidatedValueFromBasisFactory sut, [ExecutableModel] ValidatedValueBasis basis, int identity) { ((ManifestValueBase)basis.ManifestValue).IdentityAccessor = obj => identity; Assert.That(() => sut.GetValidatedValue(basis).ValueIdentity, Is.EqualTo(identity)); }
IList <ValidatedValue> GetValidatedValues(ValidatedValueBasis basis) { if (!(basis.ManifestValue is ManifestCollectionItem)) { var value = valueFromBasisFactory.GetValidatedValue(basis); if (!(basis.Parent is null)) { basis.Parent.ChildValues.Add(value); } return(new[] { value }); } var values = enumerableProvider .GetEnumerableItems(basis.GetActualValue(), basis.ManifestValue.ValidatedType) .Select((x, idx) => new ValidatedValueBasis(basis.ManifestValue, new SuccessfulGetValueToBeValidatedResponse(x), basis.Parent, idx)) .Select(valueFromBasisFactory.GetValidatedValue) .ToList(); if (!(basis.Parent is null)) { basis.Parent.CollectionItems = values; } return(values); }
void FindAndAddChildrenToOpenList(ValidatedValueBasis currentBasis, ValidatedValue currentValue, Queue <ValidatedValueBasis> openList, ResolvedValidationOptions options) { if (!currentValue.ValueResponse.IsSuccess) { return; } var actualValue = currentValue.GetActualValue(); if (!(currentBasis.ManifestValue.CollectionItemValue is null || actualValue is null)) { openList.Enqueue(new ValidatedValueBasis(currentBasis.ManifestValue.CollectionItemValue, currentValue.ValueResponse, currentValue)); } foreach (var childManifestValue in currentBasis.GetChildManifestValues()) { var valueResponse = valueProvider.GetValueToBeValidated(childManifestValue, actualValue, options); openList.Enqueue(new ValidatedValueBasis(childManifestValue, valueResponse, currentValue)); } }
static object GetIdentity(ValidatedValueBasis basis) { var actualValue = basis.GetActualValue(); if (actualValue is null) { return(null); } return(basis.ManifestValue.IdentityAccessor is null ? null : basis.ManifestValue.IdentityAccessor(actualValue)); }
public void GetChildManifestValuesShouldCombineApplicablePolymorphicValuesWithManifestValue([ManifestModel] ManifestValue value, [ManifestModel] ManifestPolymorphicType type1, [ManifestModel] ManifestPolymorphicType type2, [ManifestModel] ManifestPolymorphicType type3, [ManifestModel] ManifestValue child1, [ManifestModel] ManifestValue child2, [ManifestModel] ManifestValue child3, [ManifestModel] ManifestValue child4) { value.ValidatedType = typeof(Person); type1.ValidatedType = typeof(Employee); type2.ValidatedType = typeof(Manager); type3.ValidatedType = typeof(Cleaner); value.Children = new[] { child1 }; type1.Children = new[] { child2 }; type2.Children = new[] { child3 }; type3.Children = new[] { child4 }; value.PolymorphicTypes = new[] { type1, type2, type3 }; var response = new SuccessfulGetValueToBeValidatedResponse(new Manager()); var sut = new ValidatedValueBasis(value, response, null); Assert.That(() => sut.GetChildManifestValues(), Is.EquivalentTo(new[] { child1, child2, child3 })); }
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 GetValidatedValueShouldLeaveIdentityNullIfThereIsNoAccessor(ValidatedValueFromBasisFactory sut, [ExecutableModel] ValidatedValueBasis basis) { ((ManifestValueBase)basis.ManifestValue).IdentityAccessor = null; Assert.That(() => sut.GetValidatedValue(basis).ValueIdentity, Is.Null); }
public void GetValidatedValueShouldReturnAValidatedValueWithCorrectBasicPropertyValues(ValidatedValueFromBasisFactory sut, [ExecutableModel] ValidatedValueBasis basis) { var result = sut.GetValidatedValue(basis); Assert.Multiple(() => { Assert.That(result, Has.Property(nameof(ValidatedValue.ManifestValue)).SameAs(basis.ManifestValue)); Assert.That(result, Has.Property(nameof(ValidatedValue.ValueResponse)).SameAs(basis.ValidatedValueResponse)); Assert.That(result, Has.Property(nameof(ValidatedValue.ParentValue)).SameAs(basis.Parent)); Assert.That(result, Has.Property(nameof(ValidatedValue.CollectionItemOrder)).EqualTo(basis.CollectionOrder)); }); }