/// <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));
});
}
