public void TreeIsMappedAccordingToSchemeRules()
{
var typeCollection = TypeCollection.Create(typeof(TreeMapperTests).Assembly);
var context = Context.Create(typeCollection, FieldSource.Properties);
var tree = context.MapTree($"{typeof(TreeMapperTests).FullName}+IRootInterface");
var expectedTree = TreeDefinitionBuilder.Create($"{typeof(TreeMapperTests).FullName}+IRootInterface", b =>
{
var rootAlias = b.PushAlias(
$"{typeof(TreeMapperTests).FullName}+IRootInterface",
$"{typeof(TreeMapperTests).FullName}+TestNodeB");
var innerAlias = b.PushAlias(
$"{typeof(TreeMapperTests).FullName}+IInnerInterface",
$"{typeof(TreeMapperTests).FullName}+TestNodeA",
$"{typeof(TreeMapperTests).FullName}+TestNodeB");
b.PushNode($"{typeof(TreeMapperTests).FullName}+TestNodeB", nb =>
{
nb.PushNumberField("Field1");
nb.PushAliasField("Field2", innerAlias);
});
b.PushNode($"{typeof(TreeMapperTests).FullName}+TestNodeA", nb =>
{
nb.PushStringField("Field1");
nb.PushNumberField("Field2");
nb.PushBooleanField("Field3");
nb.PushAliasField("Field4", innerAlias, isArray: true);
nb.PushAliasField("Field5", innerAlias);
});
});
Assert.Equal(expectedTree, tree);
}
/// <summary>
/// Map a class structure to a tree-definition.
/// </summary>
/// <param name="context">Context to use during mapping</param>
/// <param name="rootAliasIdentifier">Identifier for the root-alias of the tree</param>
/// <exception cref="Exceptions.MissingTypeException">
/// Thrown when the type for the root-alias cannot be found in the context.
/// </exception>
/// <exception cref="Exceptions.MappingFailureException">
/// Thrown when an error occurs during mapping.
/// </exception>
/// <returns>Newly created immutable tree-definition</returns>
public static TreeDefinition MapTree(this Context context, string rootAliasIdentifier)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (string.IsNullOrEmpty(rootAliasIdentifier))
{
throw new ArgumentException($"Alias-type '{rootAliasIdentifier}' is not valid", nameof(rootAliasIdentifier));
}
if (!context.Types.TryGetType(rootAliasIdentifier, out var rootAliasType))
{
throw new Exceptions.MissingTypeException(rootAliasIdentifier);
}
try
{
return(TreeDefinitionBuilder.Create(rootAliasIdentifier, b =>
{
// Map the root alias
var rootAlias = b.MapAlias(context, rootAliasType);
// Map the nodes in the root-alias
b.MapNodes(context, rootAlias);
}));
}
catch (Exception e)
{
throw new Exceptions.MappingFailureException(e);
}
}
public void EnumsCanBeMappedMultipleTimes(Type enumType)
{
var context = CreateContext();
TreeDefinitionBuilder.Create("AliasA", b =>
{
b.PushAlias("AliasA", "NodeA");
b.PushNode("NodeA");
var definitionA = EnumMapper.MapEnum(b, context, enumType);
var definitionB = EnumMapper.MapEnum(b, context, enumType);
Assert.Equal(definitionA, definitionB);
});
}
public void NodeIsMappedAccordingToSchemeRules()
{
var typeCollection = TypeCollection.Create(typeof(NodeMapperTests).Assembly);
var context = Context.Create(typeCollection, FieldSource.Properties);
var tree = TreeDefinitionBuilder.Create($"{typeof(NodeMapperTests).FullName}+TestNodeA", b =>
{
b.MapNode(context, typeof(TestNodeA));
});
var expectedTree = TreeDefinitionBuilder.Create($"{typeof(NodeMapperTests).FullName}+TestNodeA", b =>
{
var nodeA = b.PushAlias(
$"{typeof(NodeMapperTests).FullName}+TestNodeA",
$"{typeof(NodeMapperTests).FullName}+TestNodeA");
var nodeB = b.PushAlias(
$"{typeof(NodeMapperTests).FullName}+TestNodeB",
$"{typeof(NodeMapperTests).FullName}+TestNodeB");
var nodeAorB = b.PushAlias(
$"{typeof(NodeMapperTests).FullName}+ITestInterface",
$"{typeof(NodeMapperTests).FullName}+TestNodeA",
$"{typeof(NodeMapperTests).FullName}+TestNodeB");
var @enum = b.PushEnum(
$"{typeof(NodeMapperTests).FullName}+TestEnum",
("A", 0),
("B", 1));
b.PushNode($"{typeof(NodeMapperTests).FullName}+TestNodeA", nb =>
{
nb.PushStringField("Field1");
nb.PushNumberField("Field2");
nb.PushBooleanField("Field3");
nb.PushEnumField("Field4", @enum);
nb.PushAliasField("Field5", nodeA, isArray: true);
nb.PushAliasField("Field6", nodeB);
});
b.PushNode($"{typeof(NodeMapperTests).FullName}+TestNodeB", nb =>
{
nb.PushNumberField("Field1");
nb.PushAliasField("Field2", nodeAorB);
});
});
private static IEnumerable <(TreeDefinition tree, string json)> GetTestTreeJsonPairs()
{
yield return
(
tree : TreeDefinitionBuilder.Create("AliasA", b =>
{
b.PushAlias("AliasA", "NodeA");
b.PushNode("NodeA", nb =>
{
nb.Comment = "This is a usefull node";
});
}),
json : @"{
""rootAlias"": ""AliasA"",
""aliases"": [
{ ""identifier"": ""AliasA"", ""values"": [ ""NodeA"" ] }
],
""enums"": [ ],
""nodes"": [
{
""nodeType"": ""NodeA"",
""comment"": ""This is a usefull node"",
""fields"": []
}
]
}"
);
yield return
(
tree : TreeDefinitionBuilder.Create("Alias", b =>
{
var alias = b.PushAlias("Alias", "NodeA", "NodeB");
var @enum = b.PushEnum("Enum", ("A", 0), ("B", 1));
b.PushNode("NodeA");
b.PushNode("NodeB", bn =>
{
bn.PushBooleanField("field1");
bn.PushStringField("field2");
bn.PushNumberField("field3", isArray: true);
bn.PushAliasField("field4", alias, isArray: true);
bn.PushEnumField("field5", @enum, isArray: true);
});
}),
public void EnumTypesAreMappedAccordingToSchemeRules(Type enumType, BuildEnum referenceBuilder)
{
var context = CreateContext();
var tree = TreeDefinitionBuilder.Create("AliasA", b =>
{
b.PushAlias("AliasA", "NodeA");
b.PushNode("NodeA");
EnumMapper.MapEnum(b, context, enumType);
});
var expectedTree = TreeDefinitionBuilder.Create("AliasA", b =>
{
b.PushAlias("AliasA", "NodeA");
b.PushNode("NodeA");
referenceBuilder(b);
});
Assert.Equal(expectedTree, tree);
}
private static TreeDefinition CreateTestScheme() => TreeDefinitionBuilder.Create("AliasA", b =>
{
var aliasA = b.PushAlias("AliasA", "NodeA");
var enumA = b.PushEnum("EnumA", ("Option1", 1), ("Option2", 2));
public void ThrowsIfTooBigEnumValueIsPushed() => Assert.Throws <InvalidEnumValueException>(() =>
TreeDefinitionBuilder.Create("AliasA", b =>
{
var context = CreateContext();
b.PushAlias("AliasA", "NodeA");
b.PushNode("NodeA");
EnumMapper.MapEnum(b, context, typeof(BigLongEnum));
}));
public void ThrowsIfAliasReferencesMissingNode() => Assert.Throws <NodeNotFoundException>(() =>
TreeDefinitionBuilder.Create("AliasA", b =>
{
b.PushAlias("AliasA", "NodeB");
b.PushNode("NodeA");
}));
public void ThrowsIfAliasIsEmpty() => Assert.Throws <EmptyAliasException>(() =>
TreeDefinitionBuilder.Create("AliasA", b =>
{
b.PushAlias("AliasA");
b.PushNode("NodeA");
}));
public void ThrowsIfDuplicateAliasIsPushed() => Assert.Throws <DuplicateAliasIdentifierException>(() =>
TreeDefinitionBuilder.Create("AliasA", b =>
{
b.PushAlias("AliasA", "NodeA");
b.PushAlias("AliasA", "NodeA");
b.PushNode("NodeA");
}));
public void ThrowsIfRootAliasDoesntExist() => Assert.Throws <AliasNotFoundException>(() =>
TreeDefinitionBuilder.Create("AliasA", b =>
{
b.PushNode("NodeA");
}));
