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