Merge pull request #65 from JansthcirlU:61-fix-duplicate-node-adds-in-graph-and-subgraph-add-link

61-fix-duplicate-node-adds-in-graph-and-subgraph-add-link

Author: JansthcirlU

src/Mermaid.Flowcharts/Flowchart.cs

@@ -16,6 +16,7 @@ public class Flowchart : IMermaidPrintable
     public IEnumerable<Node> Nodes => _nodes.OfType<Node>();
     public IEnumerable<Subgraph> Subgraphs => _nodes.OfType<Subgraph>();
     public IEnumerable<Link> Links => _links.AsReadOnly();
+    public IEnumerable<INode> AllNodeChildren => _nodes.Concat(Subgraphs.SelectMany(subgraph => subgraph.AllNodeChildren));
     public IEnumerable<Node> AllNodes => Nodes.Concat(Subgraphs.SelectMany(subgraph => subgraph.AllNodes));
     public IEnumerable<Link> AllLinks => Links.Concat(Subgraphs.SelectMany(subgraph => subgraph.AllLinks));
 
@@ -41,10 +42,12 @@ public Flowchart AddNode(INode node)
 
     public Flowchart AddLink(Link link)
     {
-        _links.Add(link);
-        AddNode(link.Source);
-        AddNode(link.Destination);
-        return this;
+        if (AllNodeChildren.Any(link.Source.Equals) && AllNodeChildren.Any(link.Destination.Equals))
+        {
+            _links.Add(link);
+            return this;
+        }
+        throw new InvalidOperationException("Cannot add link to flowchart: the source and the destination nodes should both be present within the flowchart.");
     }
 
     public override string ToString()

src/Mermaid.Flowcharts/Subgraphs/Subgraph.cs

@@ -16,6 +16,7 @@ public record Subgraph : INode<Subgraph>
     public IEnumerable<Node> Nodes => _nodes.OfType<Node>();
     public IEnumerable<Subgraph> Subgraphs => _nodes.OfType<Subgraph>();
     public IEnumerable<Link> Links => _links.AsReadOnly();
+    public IEnumerable<INode> AllNodeChildren => _nodes.Concat(Subgraphs.SelectMany(subgraph => subgraph._nodes));
     public IEnumerable<Node> AllNodes => Nodes.Concat(Subgraphs.SelectMany(subgraph => subgraph.AllNodes));
     public IEnumerable<Link> AllLinks => Links.Concat(Subgraphs.SelectMany(subgraph => subgraph.AllLinks));
 
@@ -50,6 +51,11 @@ public static Subgraph Create(string identifier, string title, SubgraphDirection
 
     public Subgraph AddNode(INode node)
     {
+        if (Equals(node))
+        {
+            throw new ArgumentException("Cannot add subgraph as a node to itself.", nameof(node));
+        }
+
         if (node is Node nd && Nodes.Any(nd.Equals))
         {
             return this;
@@ -61,10 +67,12 @@ public Subgraph AddNode(INode node)
 
     public Subgraph AddLink(Link link)
     {
-        _links.Add(link);
-        AddNode(link.Source);
-        AddNode(link.Destination);
-        return this;
+        if (AllNodeChildren.Any(link.Source.Equals) && AllNodeChildren.Any(link.Destination.Equals))
+        {
+            _links.Add(link);
+            return this;
+        }
+        throw new InvalidOperationException("Cannot add link to subgraph: the source and the destination nodes should both be present within the subgraph.");
     }
 
     public override string ToString()

tests/Mermaid.Flowcharts.Tests/FlowchartTests.cs

@@ -45,38 +45,102 @@ public void Flowchart_ShouldContainTwoNodes_WhenTryingToAddTwoNodesWithDuplicate
     }
 
     [Fact]
-    public void Flowchart_ShouldAddLinkNode_WhenNodesAreNotPartOfSubgraphs()
+    public void Flowchart_WhenLinkNodesExist_ShouldAddLink()
     {
         // Arrange
         Flowchart flowchart = new();
-        Node source = Node.CreateNew<MermaidUnicodeText>(Guid.NewGuid().ToString());
-        Node destination = Node.CreateNew<MermaidUnicodeText>(Guid.NewGuid().ToString());
-        Link link = Link.Create(source, destination);
+        Node n1 = Node.CreateNew("Node 1");
+        Node n2 = Node.CreateNew("Node 2");
+        Link link = Link.Create(n1, n2);
 
         // Act
-        flowchart.AddLink(link);
+        flowchart
+            .AddNode(n1)
+            .AddNode(n2)
+            .AddLink(link);
 
         // Assert
-        Assert.NotEmpty(flowchart.Nodes);
-        Assert.Equal(2, flowchart.Nodes.Count());
+        Assert.NotEmpty(flowchart.AllNodes);
+        Assert.Equal(2, flowchart.AllNodes.Count());
+        Assert.Single(flowchart.Links);
     }
 
     [Fact]
-    public void Flowchart_ShouldNotAddLinkNode_WhenLinkNodesAlreadyExist()
+    public void Flowchart_WhenLinkNodesAreNestedButExist_ShouldAddLink()
     {
         // Arrange
         Flowchart flowchart = new();
-        Node source = Node.CreateNew<MermaidUnicodeText>(Guid.NewGuid().ToString());
-        Node destination = Node.CreateNew<MermaidUnicodeText>(Guid.NewGuid().ToString());
-        Link link = Link.Create(source, destination);
+        Subgraph sg1 = Subgraph.CreateNew("Subgraph 1");
+        Node sg1Node = Node.CreateNew("Node 1");
+        Subgraph sg2 = Subgraph.CreateNew("Subgraph 2");
+        Node sg2Node = Node.CreateNew("Node 2");
+        Link link = Link.Create(sg1Node, sg2Node);
 
         // Act
-        flowchart.AddNode(source);
-        flowchart.AddLink(link);
+        flowchart
+            .AddNode(sg1.AddNode(sg1Node))
+            .AddNode(sg2.AddNode(sg2Node))
+            .AddLink(link);
 
         // Assert
-        Assert.NotEmpty(flowchart.Nodes);
-        Assert.Equal(2, flowchart.Nodes.Count());
+        Assert.NotEmpty(flowchart.AllNodes);
+        Assert.Equal(2, flowchart.AllNodes.Count());
+        Assert.Single(flowchart.Links);
+    }
+
+    [Fact]
+    public void Flowchart_WhenLinkNodeIsSubgraphAndExists_ShouldAddLink()
+    {
+        // Arrange
+        Flowchart flowchart = new();
+        Node n = Node.CreateNew("n");
+        Subgraph subgraph = Subgraph.CreateNew("Subgraph");
+        Link link = Link.Create(n, subgraph);
+
+        // Act
+        flowchart
+            .AddNode(n)
+            .AddNode(subgraph)
+            .AddLink(link);
+
+        // Assert
+        Assert.NotEmpty(flowchart.AllNodeChildren);
+        Assert.Equal(2, flowchart.AllNodeChildren.Count());
+        Assert.Single(flowchart.Links);
+    }
+
+    [Fact]
+    public void Flowchart_WhenLinkSourceNotPresent_AddLinkShouldThrow()
+    {
+        // Arrange
+        Flowchart flowchart = new();
+        Node source = Node.CreateNew(Guid.NewGuid().ToString());
+        Node destination = Node.CreateNew(Guid.NewGuid().ToString());
+        Link link = Link.Create(source, destination);
+
+        // Act & Assert
+        flowchart.AddNode(destination); // Forgot to add source
+        InvalidOperationException exception = Assert.Throws<InvalidOperationException>(
+            () => flowchart.AddLink(link)
+        );
+        Assert.Contains("Cannot add link to flowchart: the source and the destination nodes should both be present within the flowchart.", exception.Message);
+    }
+
+    [Fact]
+    public void Flowchart_WhenLinkDestinationNotPresent_AddLinkShouldThrow()
+    {
+        // Arrange
+        Flowchart flowchart = new();
+        Node source = Node.CreateNew(Guid.NewGuid().ToString());
+        Node destination = Node.CreateNew(Guid.NewGuid().ToString());
+        Link link = Link.Create(source, destination);
+
+        // Act & Assert
+        flowchart.AddNode(source); // Forgot to add destination
+        InvalidOperationException exception = Assert.Throws<InvalidOperationException>(
+            () => flowchart.AddLink(link)
+        );
+        Assert.Contains("Cannot add link to flowchart: the source and the destination nodes should both be present within the flowchart.", exception.Message);
     }
 
     [Fact]
@@ -640,4 +704,105 @@ flowchart TD
         // Assert
         Assert.Equal(expected, actual);
     }
+
+    [Fact]
+    public void Flowchart_WhenNestedLinksParentToChild_ShouldNotAddDuplicateNodes()
+    {
+        // Arrange
+        Flowchart flowchart = new();
+        Node flowchartNode = Node.Create("n", "Inside flowchart");
+        Subgraph subgraph = Subgraph.Create("sg", "Subgraph");
+        Node subgraphNode = Node.Create("sgn", "Inside subgraph");
+        Link nToSgn = Link.Create(flowchartNode, subgraphNode);
+        Subgraph subsubgraph = Subgraph.Create("ssg", "Subsubgraph");
+        Node subsubgraphNode = Node.Create("ssgn", "Inside subsubgraph");
+        Link sgnToSsgn = Link.Create(subgraphNode, subsubgraphNode);
+        flowchart
+            .AddNode(flowchartNode)
+            .AddNode(
+                subgraph
+                    .AddNode(subgraphNode)
+                    .AddNode(
+                        subsubgraph
+                            .AddNode(subsubgraphNode)
+                        )
+                )
+            .AddLink(nToSgn)
+            .AddLink(sgnToSsgn);
+
+        string expected =
+        $"""
+        flowchart TD
+            n["Inside flowchart"]
+
+            subgraph sg ["Subgraph"]
+                sgn["Inside subgraph"]
+
+                subgraph ssg ["Subsubgraph"]
+                    ssgn["Inside subsubgraph"]
+                end
+            end
+
+            n ---> sgn
+            sgn ---> ssgn
+
+        """;
+
+        // Act
+        string actual = flowchart.ToMermaidString(0, "    ");
+
+        // Assert
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact]
+    public void Flowchart_WhenNestedLinksChildToParent_ShouldNotAddDuplicateNodes()
+    {
+        // Arrange
+        Flowchart flowchart = new();
+        Node flowchartNode = Node.Create("n", "Inside flowchart");
+        Subgraph subgraph = Subgraph.Create("sg", "Subgraph");
+        Node subgraphNode = Node.Create("sgn", "Inside subgraph");
+        Link sgnToN = Link.Create(subgraphNode, flowchartNode);
+        Subgraph subsubgraph = Subgraph.Create("ssg", "Subsubgraph");
+        Node subsubgraphNode = Node.Create("ssgn", "Inside subsubgraph");
+        Link ssgnToSgn = Link.Create(subsubgraphNode, subgraphNode);
+        flowchart
+            .AddNode(flowchartNode)
+            .AddNode(
+                subgraph
+                    .AddNode(subgraphNode)
+                    .AddNode(
+                        subsubgraph
+                            .AddNode(subsubgraphNode)
+                        )
+                    .AddLink(ssgnToSgn)
+                )
+            .AddLink(sgnToN);
+
+        string expected =
+        $"""
+        flowchart TD
+            n["Inside flowchart"]
+
+            subgraph sg ["Subgraph"]
+                sgn["Inside subgraph"]
+
+                subgraph ssg ["Subsubgraph"]
+                    ssgn["Inside subsubgraph"]
+                end
+
+                ssgn ---> sgn
+            end
+
+            sgn ---> n
+
+        """;
+
+        // Act
+        string actual = flowchart.ToMermaidString(0, "    ");
+
+        // Assert
+        Assert.Equal(expected, actual);
+    }
 }