feat(tests): add tests and fix things

Author: rozanecm

go.mod

@@ -2,4 +2,7 @@ module github.com/jmCodeCraft/go-network
 
 go 1.21.1
 
-require github.com/mroth/weightedrand v1.0.0
+require (
+	github.com/jinzhu/copier v0.4.0
+	github.com/mroth/weightedrand v1.0.0
+)

go.sum

@@ -1,2 +1,4 @@
+github.com/jinzhu/copier v0.4.0 h1:w3ciUoD19shMCRargcpm0cm91ytaBhDvuRpz1ODO/U8=
+github.com/jinzhu/copier v0.4.0/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg=
 github.com/mroth/weightedrand v1.0.0 h1:V8JeHChvl2MP1sAoXq4brElOcza+jxLkRuwvtQu8L3E=
 github.com/mroth/weightedrand v1.0.0/go.mod h1:3p2SIcC8al1YMzGhAIoXD+r9olo/g/cdJgAD905gyNE=

io/io.go

@@ -18,11 +18,15 @@ type IGraphFormatReader interface {
 	AddNodesToGraph(g *model.UndirectedGraph, nodes []model.Node)
 }
 
-type AdjacencyListReader struct{ IGraphFormatReader } // DONE
-type EdgeListReader struct{ IGraphFormatReader }      // DONE
+type GraphFormatReader struct {
+	IGraphFormatReader IGraphFormatReader
+}
+
+type AdjacencyListReader struct{ GraphFormatReader } // DONE
+type EdgeListReader struct{ GraphFormatReader }      // DONE
 
-func (strategy *IGraphFormatReader) Read(reader io.Reader) model.UndirectedGraph {
-	ng := model.UndirectedGraph{}
+func (strategy *GraphFormatReader) Read(reader io.Reader) (*model.UndirectedGraph, error) {
+	ng := &model.UndirectedGraph{}
 
 	csvReader := csv.NewReader(reader)
 	lineCount := 0
@@ -32,37 +36,40 @@ func (strategy *IGraphFormatReader) Read(reader io.Reader) model.UndirectedGraph
 			if errors.Is(err, io.EOF) {
 				break
 			}
-			return nil
+			return nil, fmt.Errorf("error reading csv: %w", err)
 		}
 		slog.Info(fmt.Sprintf("read: %+v", read))
 		nodes := lineToList(read)
-		IGraphFormatReader.AddNodesToGraph(ng, nodes)
+		strategy.IGraphFormatReader.AddNodesToGraph(ng, nodes)
 		lineCount++
 	}
-	return ng
+	return ng, nil
 }
 
-func (strategy *IGraphFormatReader) ReadFromFile(filename string) model.UndirectedGraph {
+func (strategy *GraphFormatReader) ReadFromFile(filename string) (*model.UndirectedGraph, error) {
 	readFile, err := os.Open(filename)
 	if err != nil {
-		return fmt.Errorf("error opening file: %w", err)
+		return nil, fmt.Errorf("error opening file: %w", err)
 	}
 
-	ng := strategy.Read(readFile)
+	ng, err := strategy.Read(readFile)
+	if err != nil {
+		return nil, fmt.Errorf("error reading file: %w", err)
+	}
 
 	err = readFile.Close()
 	if err != nil {
-		return fmt.Errorf("error closing file: %w", err)
+		return nil, fmt.Errorf("error closing file: %w", err)
 	}
-	return ng
+	return ng, nil
 }
 
 func (a *AdjacencyListReader) AddNodesToGraph(g *model.UndirectedGraph, nodes []model.Node) {
-	g.AddEdgesFromIntEdgeList(model.Node(nodes[0]), nodes[1:])
+	g.AddEdgesFromIntEdgeList(nodes[0], nodes[1:])
 }
 
 func (a *EdgeListReader) AddNodesToGraph(g *model.UndirectedGraph, nodes []model.Node) {
-	g.AddEdge(model.Edge{nodes[0], nodes[1]})
+	g.AddEdge(model.Edge{Node1: nodes[0], Node2: nodes[1]})
 }
 
 /*

io/io_test.go

@@ -1,16 +1,9 @@
 package io
 
 import (
-	"bytes"
 	"testing"
 )
 
-func TestFromAdjacencyList(t *testing.T) {
-	var buffer bytes.Buffer
-	buffer.WriteString("1,2\n2,3\n3,4\n")
-	FromAdjacencyList(&buffer)
-}
-
 func TestLinetoList(t *testing.T) {
 	list := lineToList([]string{"1", "2", "3"})
 

model/generator_classic.go

@@ -14,24 +14,39 @@ func CompleteGraph(numberOfNodes int) *UndirectedGraph {
 }
 
 // LadderGraph returns the Ladder graph of length n and 2n nodes
-func LadderGraph(nodesInSinglePath int) (g UndirectedGraph) {
-	g = UndirectedGraph{}
-	edgesLadder1 := Pairwise(Range(nodesInSinglePath, 2*nodesInSinglePath))
-	for i := 0; i <= len(edgesLadder1); i++ {
-		g.AddEdge(edgesLadder1[i])
+func LadderGraph(nodesInSinglePath int) *UndirectedGraph {
+	g := &UndirectedGraph{}
+
+	// Generate and add edges for the ladder structure
+	for _, edge := range Pairwise(Range(nodesInSinglePath, 2*nodesInSinglePath)) {
+		g.AddEdge(edge)
 	}
-	for i := 0; i <= nodesInSinglePath; i++ {
+
+	// Add rung edges between the two paths of the ladder
+	for i := 0; i < nodesInSinglePath; i++ {
 		g.AddEdge(Edge{
 			Node1: Node(i),
 			Node2: Node(i + nodesInSinglePath),
 		})
+
+		if i != nodesInSinglePath-1 {
+			g.AddEdge(Edge{
+				Node1: Node(i + nodesInSinglePath),
+				Node2: Node(i + nodesInSinglePath + 1),
+			})
+			g.AddEdge(Edge{
+				Node1: Node(i),
+				Node2: Node(i + 1),
+			})
+		}
 	}
+
 	return g
 }
 
 // CircularLadderGraph returns the circular ladder graph $CL_n$ of length n
-func CircularLadderGraph(nodesInSinglePath int) (g UndirectedGraph) {
-	g = LadderGraph(nodesInSinglePath)
+func CircularLadderGraph(nodesInSinglePath int) *UndirectedGraph {
+	g := LadderGraph(nodesInSinglePath)
 	g.AddEdge(Edge{
 		Node2: Node(nodesInSinglePath - 1),
 	})

model/generator_classic_test.go

@@ -1,6 +1,8 @@
 package model
 
 import (
+	"fmt"
+	"reflect"
 	"testing"
 )
 
@@ -57,3 +59,173 @@ func TestCompleteGraph(t *testing.T) {
 		})
 	}
 }
+
+func TestLadderGraph(t *testing.T) {
+	testCases := []struct {
+		nodes         int
+		expectedNodes map[Node]bool
+		expectedEdges map[Node][]Node
+	}{
+		{
+			nodes:         0,
+			expectedNodes: map[Node]bool{},
+			expectedEdges: map[Node][]Node{},
+		},
+		{
+			nodes: 3,
+			expectedNodes: map[Node]bool{
+				0: true, 1: true, 2: true, 3: true, 4: true, 5: true,
+			},
+			expectedEdges: map[Node][]Node{
+				0: {1, 3},
+				1: {0, 2, 4},
+				2: {1, 5},
+				3: {0, 4},
+				4: {1, 3, 5},
+				5: {2, 4},
+			},
+		},
+		{
+			nodes: 5,
+			expectedNodes: map[Node]bool{
+				0: true, 1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true,
+			},
+			expectedEdges: map[Node][]Node{
+				0:  {1},
+				1:  {0, 2},
+				2:  {1, 3},
+				3:  {2, 4},
+				4:  {3, 5},
+				5:  {4, 6},
+				6:  {5, 7},
+				7:  {6, 8},
+				8:  {7, 9},
+				9:  {8, 10},
+				10: {9},
+			},
+		},
+		{
+			nodes: 2,
+			expectedNodes: map[Node]bool{
+				0: true, 1: true, 2: true,
+			},
+			expectedEdges: map[Node][]Node{
+				0: {1},
+				1: {0, 2},
+				2: {1},
+			},
+		},
+		{
+			nodes: 1,
+			expectedNodes: map[Node]bool{
+				0: true, 1: true,
+			},
+			expectedEdges: map[Node][]Node{
+				0: {1},
+				1: {0},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(fmt.Sprintf("Nodes: %d", tc.nodes), func(t *testing.T) {
+			g := LadderGraph(tc.nodes)
+			validateGraph(t, g, tc.expectedNodes, tc.expectedEdges)
+		})
+	}
+}
+
+func TestCircularLadderGraph(t *testing.T) {
+	// Test case 1: Basic Test
+	nodesInSinglePath := 4
+	g := CircularLadderGraph(nodesInSinglePath)
+	expectedNodes := map[Node]bool{1: true, 2: true, 3: true, 4: true, 5: true, 6: true}
+	expectedEdges := map[Node][]Node{
+		1: {2, 6},
+		2: {1, 3},
+		3: {2, 4},
+		4: {3, 5},
+		5: {4, 6},
+		6: {1, 5},
+	}
+	validateGraph(t, g, expectedNodes, expectedEdges)
+
+	// Test case 2: Edge Case Test
+	nodesInSinglePath = 2
+	g = CircularLadderGraph(nodesInSinglePath)
+	expectedNodes = map[Node]bool{1: true, 2: true, 3: true}
+	expectedEdges = map[Node][]Node{
+		1: {2, 3},
+		2: {1, 3},
+		3: {1, 2},
+	}
+	validateGraph(t, g, expectedNodes, expectedEdges)
+
+	// Test case 3: Larger Graph Test
+	nodesInSinglePath = 6
+	g = CircularLadderGraph(nodesInSinglePath)
+	expectedNodes = map[Node]bool{1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true, 12: true}
+	expectedEdges = map[Node][]Node{
+		1:  {2, 12},
+		2:  {1, 3},
+		3:  {2, 4},
+		4:  {3, 5},
+		5:  {4, 6},
+		6:  {5, 7},
+		7:  {6, 8},
+		8:  {7, 9},
+		9:  {8, 10},
+		10: {9, 11},
+		11: {10, 12},
+		12: {1, 11},
+	}
+	validateGraph(t, g, expectedNodes, expectedEdges)
+
+	// Test case 4: Connectivity Test
+	// Validate if all nodes are properly connected
+	for node, neighbors := range g.Edges {
+		for _, neighbor := range neighbors {
+			if !contains(g.Edges[neighbor], node) {
+				t.Errorf("Test case 4 failed: Nodes %d and %d are not properly connected", node, neighbor)
+			}
+		}
+	}
+
+	// Test case 5: Node Existence Test
+	// Validate if all expected nodes exist
+	for node := range expectedNodes {
+		if !g.Nodes[node] {
+			t.Errorf("Test case 5 failed: Expected node %d does not exist in the generated graph", node)
+		}
+	}
+}
+
+// Helper function to validate the generated graph
+func validateGraph(t *testing.T, g *UndirectedGraph, expectedNodes map[Node]bool, expectedEdges map[Node][]Node) {
+	// Validate nodes
+	if len(g.Nodes) != len(expectedNodes) {
+		t.Errorf("Nodes mismatch, expected: %v, got: %v", expectedNodes, g.Nodes)
+	} else {
+		for node := range expectedNodes {
+			if !g.Nodes[node] {
+				t.Errorf("Nodes mismatch, expected: %v, got: %v", expectedNodes, g.Nodes)
+			}
+		}
+	}
+	// Validate edges
+	for node, edges := range expectedEdges {
+		if !reflect.DeepEqual(g.Edges[node], edges) {
+			t.Errorf("Edges mismatch for node %d, expected: %v, got: %v. Full graph: %v", node, edges, g.Edges[node], g)
+		}
+	}
+}
+
+// Helper function to check if a node exists in a slice
+func contains(slice []Node, value Node) bool {
+	for _, item := range slice {
+		if item == value {
+			return true
+		}
+	}
+	return false
+}