/// <inheritdoc/>
public IManifestItem GetManifestItem(ModelToManifestConversionContext context)
{
if (context.ConversionType != ModelToManifestConversionType.Manifest)
{
return(next.GetManifestItem(context));
}
var manifestValue = new ManifestValue
{
Parent = context.ParentManifestValue,
MemberName = context.MemberName,
AccessorFromParent = context.AccessorFromParent,
ValidatedType = context.ValidatedType,
};
if (context.CurrentValue is Value val)
{
manifestValue.AccessorExceptionBehaviour = val.AccessorExceptionBehaviour;
}
if (context.ParentManifestValue != null)
{
context.ParentManifestValue.Children.Add(manifestValue);
}
return(manifestValue);
}
/// <summary>
/// Converts all of the hierarchy of <see cref="Value"/> instances within the specified context into
/// an equivalent hierarchy of <see cref="CSF.Validation.Manifest.ManifestValue"/>, which are returned
/// as a result object.
/// </summary>
/// <param name="context">A conversion context.</param>
/// <returns>A result object containing the converted manifest values.</returns>
/// <exception cref="ValidatorBuildingException">If the input value(s) are not valid for creating a validation manifest.</exception>
/// <exception cref="System.ArgumentNullException">If the <paramref name="context"/> is <see langword="null"/>.</exception>
public ModelToManifestValueConversionResult ConvertAllValues(ModelToManifestConversionContext context)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
var openList = new Queue <ModelToManifestConversionContext>(new[] { context });
var result = new ModelToManifestValueConversionResult();
while (openList.Count != 0)
{
var current = openList.Dequeue();
var value = contextToItemConverter.GetManifestItem(current);
if (result.RootValue is null && value is ManifestValue manifestValue)
{
result.RootValue = manifestValue;
}
FindAndAddChildrenToOpenList(openList, current, value);
result.ConvertedValues.Add(new ModelAndManifestValuePair
{
ModelValue = current.CurrentValue,
ManifestValue = value,
});
}
return(result);
}
/// <inheritdoc/>
public IManifestItem GetManifestItem(ModelToManifestConversionContext context)
{
var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("UnexpectedModelToManifestConversionType"),
nameof(ModelToManifestConversionType));
throw new ArgumentException(message, nameof(context));
}
public void GetManifestItemShouldThrowIfAncestorIsNegative([ManifestModel] ModelToManifestConversionContext context,
ContextToRecursiveManifestItemConverter sut)
{
context.ConversionType = ModelToManifestConversionType.RecursiveManifestValue;
context.CurrentValue.ValidateRecursivelyAsAncestor = -1;
Assert.That(() => sut.GetManifestItem(context), Throws.InstanceOf <ValidationException>());
}
public void GetManifestItemShouldThrowIfNotEnoughAncestors([ManifestModel] ModelToManifestConversionContext context,
ContextToRecursiveManifestItemConverter sut,
[ManifestModel] ManifestValue parent,
[ManifestModel] ManifestValue grandparent)
{
parent.Parent = grandparent;
context.ParentManifestValue = parent;
grandparent.Parent = null;
context.ConversionType = ModelToManifestConversionType.RecursiveManifestValue;
context.CurrentValue.ValidateRecursivelyAsAncestor = 3;
Assert.That(() => sut.GetManifestItem(context), Throws.InstanceOf <ValidationException>());
}
void FindAndAddChildrenToOpenList(Queue <ModelToManifestConversionContext> openList, ModelToManifestConversionContext currentContext, IManifestItem parent)
{
if (!(currentContext.CurrentValue.CollectionItemValue is null))
{
var validatedType = validatedTypeProvider.GetValidatedType(parent.ValidatedType, true);
var collectionItem = new ModelToManifestConversionContext
{
CurrentValue = currentContext.CurrentValue.CollectionItemValue,
MemberName = currentContext.MemberName,
ParentManifestValue = parent,
ValidatedType = validatedType,
ConversionType = currentContext.CurrentValue.CollectionItemValue.ValidateRecursivelyAsAncestor.HasValue
? ModelToManifestConversionType.RecursiveManifestValue
: ModelToManifestConversionType.CollectionItem,
};
openList.Enqueue(collectionItem);
}
foreach (var child in currentContext.CurrentValue.Children)
{
var accessor = accessorFactory.GetAccessorFunction(parent.ValidatedType, child.Key);
var collectionItem = new ModelToManifestConversionContext
{
CurrentValue = child.Value,
AccessorFromParent = accessor.AccessorFunction,
MemberName = child.Key,
ParentManifestValue = parent,
ValidatedType = accessor.ExpectedType,
ConversionType = child.Value.ValidateRecursivelyAsAncestor.HasValue
? ModelToManifestConversionType.RecursiveManifestValue
: ModelToManifestConversionType.Manifest,
};
openList.Enqueue(collectionItem);
}
if (currentContext.CurrentValue is IHasPolymorphicValues hasPolyValues)
{
foreach (var polyValue in hasPolyValues.PolymorphicValues)
{
var polymorphicItem = new ModelToManifestConversionContext
{
CurrentValue = polyValue.Value,
ParentManifestValue = parent,
PolymorphicTypeName = polyValue.Key,
ConversionType = ModelToManifestConversionType.PolymorphicType,
};
openList.Enqueue(polymorphicItem);
}
}
}
/// <inheritdoc/>
public IManifestItem GetManifestItem(ModelToManifestConversionContext context)
{
var result = wrapped.GetManifestItem(context);
var identityMember = context.CurrentValue.IdentityMemberName;
if (result is ManifestValueBase valueBase && !String.IsNullOrWhiteSpace(identityMember))
{
var accessorFunction = accessorFactory.GetAccessorFunction(context.ValidatedType, identityMember).AccessorFunction;
valueBase.IdentityAccessor = accessorFunction;
}
return(result);
}
public void GetManifestItemShouldReturnAPolymorphicType([ManifestModel] ModelToManifestConversionContext context,
ContextToManifestPolymorphicTypeConverter sut,
[ManifestModel] ManifestValue parent)
{
context.ConversionType = ModelToManifestConversionType.PolymorphicType;
context.ParentManifestValue = parent;
context.PolymorphicTypeName = "System.String";
var result = sut.GetManifestItem(context);
Assert.Multiple(() =>
{
Assert.That(result, Is.InstanceOf <ManifestPolymorphicType>(), "Correct type");
Assert.That(result.Parent, Is.SameAs(parent), "Correct parent item");
Assert.That(result.ValidatedType, Is.EqualTo(typeof(string)), "Correct polymorphic type");
Assert.That(parent.PolymorphicTypes, Does.Contain(result), "Result added as one of parent's polymorphic types");
});
}
public void GetManifestItemShouldReturnACollectionItem([ManifestModel] ModelToManifestConversionContext context,
ContextToManifestCollectionItemConverter sut,
[ManifestModel] ManifestValue parent,
[ManifestModel] ManifestValue grandparent)
{
context.ConversionType = ModelToManifestConversionType.CollectionItem;
context.ParentManifestValue = parent;
parent.Parent = grandparent;
var result = sut.GetManifestItem(context);
Assert.Multiple(() =>
{
Assert.That(result, Is.InstanceOf <ManifestCollectionItem>(), "Correct type");
Assert.That(result.Parent, Is.SameAs(grandparent), "Correct parent item");
Assert.That(result.ValidatedType, Is.EqualTo(context.ValidatedType), "Correct validated type");
Assert.That(parent.CollectionItemValue, Is.SameAs(result), "Result added as parent's collection value");
});
}
/// <inheritdoc/>
public IManifestItem GetManifestItem(ModelToManifestConversionContext context)
{
if (context.ConversionType != ModelToManifestConversionType.CollectionItem)
{
return(next.GetManifestItem(context));
}
var collectionItem = new ManifestCollectionItem
{
Parent = context.ParentManifestValue.Parent,
ValidatedType = context.ValidatedType,
};
if (context.ParentManifestValue is ManifestValueBase mvb)
{
mvb.CollectionItemValue = collectionItem;
}
return(collectionItem);
}
public void GetManifestItemShouldReturnARecuriveManifestItem([ManifestModel] ModelToManifestConversionContext context,
ContextToRecursiveManifestItemConverter sut,
[ManifestModel] ManifestValue parent,
[ManifestModel] ManifestValue grandparent)
{
parent.Parent = grandparent;
context.ParentManifestValue = parent;
context.ConversionType = ModelToManifestConversionType.RecursiveManifestValue;
context.CurrentValue.ValidateRecursivelyAsAncestor = 2;
var result = sut.GetManifestItem(context);
Assert.Multiple(() =>
{
Assert.That(result, Is.InstanceOf <RecursiveManifestValue>(), "Correct type");
Assert.That(result, Has.Property(nameof(RecursiveManifestValue.WrappedValue)).SameAs(grandparent), "Correct wrapped value");
Assert.That(result, Has.Property(nameof(IManifestValue.MemberName)).EqualTo(context.MemberName), "Correct member name");
Assert.That(result, Has.Property(nameof(IManifestValue.AccessorFromParent)).EqualTo(context.AccessorFromParent), "Correct accessor");
Assert.That(parent.Children, Does.Contain(result), "Parent contains the result");
});
}
static IManifestItem GetAncestor(ModelToManifestConversionContext context)
{
var ancestorLevels = context.CurrentValue.ValidateRecursivelyAsAncestor.Value;
try
{
return(context.ParentManifestValue.GetAncestor(ancestorLevels - 1));
}
catch (ArgumentOutOfRangeException ex)
{
var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("AncestorLevelsMustNotBeLessThanOne"),
nameof(ValueBase.ValidateRecursivelyAsAncestor));
throw new ValidationException(message, ex);
}
catch (InvalidOperationException ex)
{
var message = String.Format(Resources.ExceptionMessages.GetExceptionMessage("NotEnoughAncestorsForAncestorLevels"),
nameof(ValueBase.ValidateRecursivelyAsAncestor),
nameof(ValueBase));
throw new ValidationException(message, ex);
}
}
/// <inheritdoc/>
public IManifestItem GetManifestItem(ModelToManifestConversionContext context)
{
if (context.ConversionType != ModelToManifestConversionType.RecursiveManifestValue)
{
return(next.GetManifestItem(context));
}
var ancestor = GetAncestor(context);
var recursiveItem = new RecursiveManifestValue(ancestor)
{
AccessorFromParent = context.AccessorFromParent,
MemberName = context.MemberName,
Parent = context.ParentManifestValue,
};
if (context.ParentManifestValue != null)
{
context.ParentManifestValue.Children.Add(recursiveItem);
}
return(recursiveItem);
}
/// <inheritdoc/>
public IManifestItem GetManifestItem(ModelToManifestConversionContext context)
{
if (context.ConversionType != ModelToManifestConversionType.PolymorphicType)
{
return(next.GetManifestItem(context));
}
var validatedType = Type.GetType(context.PolymorphicTypeName, true);
var polymorphicType = new ManifestPolymorphicType
{
Parent = context.ParentManifestValue,
ValidatedType = validatedType,
};
if (context.ParentManifestValue is IHasPolymorphicTypes polyParent)
{
polyParent.PolymorphicTypes.Add(polymorphicType);
}
return(polymorphicType);
}
public void GetManifestItemShouldReturnAManifestValue([ManifestModel] ModelToManifestConversionContext context,
ContextToManifestValueConverter sut,
[ManifestModel] ManifestValue parent)
{
context.ConversionType = ModelToManifestConversionType.Manifest;
context.ParentManifestValue = parent;
context.PolymorphicTypeName = "System.String";
var result = sut.GetManifestItem(context);
Assert.Multiple(() =>
{
Assert.That(result, Is.InstanceOf <ManifestValue>(), "Correct type");
Assert.That(result.Parent, Is.SameAs(parent), "Correct parent item");
Assert.That(result, Has.Property(nameof(ManifestValue.MemberName)).EqualTo(context.MemberName), "Correct member name");
Assert.That(result, Has.Property(nameof(ManifestValue.AccessorFromParent)).EqualTo(context.AccessorFromParent), "Correct accessor");
Assert.That(result.ValidatedType, Is.EqualTo(context.ValidatedType), "Correct validated type");
Assert.That(result,
Has.Property(nameof(ManifestValue.AccessorExceptionBehaviour)).EqualTo(((Value)context.CurrentValue).AccessorExceptionBehaviour),
"Correct accessor exception behaviour");
Assert.That(parent.Children, Does.Contain(result), "Result added as one of parent's children");
});
}
public void ConvertAllValuesShouldSuccessfullyConvertAMultiLevelValueHierarchy([Frozen] IGetsAccessorFunction accessorFactory,
[Frozen] IGetsValidatedType validatedTypeProvider,
[Frozen] IGetsManifestItemFromModelToManifestConversionContext itemFactory,
ModelValueToManifestValueConverter sut,
[ManifestModel] ModelToManifestConversionContext context,
IManifestItem item,
AccessorFunctionAndType accessor)
{
Mock.Get(accessorFactory)
.Setup(x => x.GetAccessorFunction(It.IsAny <Type>(), It.IsAny <string>()))
.Returns(accessor);
Mock.Get(validatedTypeProvider)
.Setup(x => x.GetValidatedType(It.IsAny <Type>(), It.IsAny <bool>()))
.Returns((Type t, bool b) => t);
Mock.Get(itemFactory)
.Setup(x => x.GetManifestItem(It.IsAny <ModelToManifestConversionContext>())).Returns(item);
context.CurrentValue = new Value
{
Children = new Dictionary <string, Value>
{
{ "Foo", new Value
{
Children = new Dictionary <string, Value>
{
{ "Foo", new Value() },
{ "Bar", new Value {
ValidateRecursivelyAsAncestor = 1
} },
{ "Baz", new Value
{
CollectionItemValue = new CollectionItemValue(),
} },
},
PolymorphicValues = new Dictionary <string, PolymorphicValue>
{
{ "System.String", new PolymorphicValue() },
}
} },
{ "Bar", new Value() },
}
};
sut.ConvertAllValues(context);
Assert.Multiple(() =>
{
Mock.Get(itemFactory)
.Verify(x => x.GetManifestItem(It.Is <ModelToManifestConversionContext>(c => c.ConversionType == ModelToManifestConversionType.Manifest)),
Times.Exactly(5));
Mock.Get(itemFactory)
.Verify(x => x.GetManifestItem(It.Is <ModelToManifestConversionContext>(c => c.ConversionType == ModelToManifestConversionType.PolymorphicType)),
Times.Exactly(1));
Mock.Get(itemFactory)
.Verify(x => x.GetManifestItem(It.Is <ModelToManifestConversionContext>(c => c.ConversionType == ModelToManifestConversionType.CollectionItem)),
Times.Exactly(1));
Mock.Get(itemFactory)
.Verify(x => x.GetManifestItem(It.Is <ModelToManifestConversionContext>(c => c.ConversionType == ModelToManifestConversionType.RecursiveManifestValue)),
Times.Exactly(1));
});
Mock.Get(itemFactory)
.Verify(x => x.GetManifestItem(It.IsAny <ModelToManifestConversionContext>()), Times.Exactly(8));
}
