Added some tests

route/path.go

@@ -2,11 +2,11 @@ package route
 
 import (
 	"fmt"
-	"log"
 
 	bnet "github.com/bio-routing/bio-rd/net"
 )
 
+// Path represents a network path
 type Path struct {
 	Type        uint8
 	StaticPath  *StaticPath
@@ -46,6 +46,7 @@ func (p *Path) Select(q *Path) int8 {
 	panic("Unknown path type")
 }
 
+// ECMP checks if path p and q are equal enough to be considered for ECMP usage
 func (p *Path) ECMP(q *Path) bool {
 	switch p.Type {
 	case BGPPathType:
@@ -59,6 +60,7 @@ func (p *Path) ECMP(q *Path) bool {
 	panic("Unknown path type")
 }
 
+// Equal checks if paths p and q are equal
 func (p *Path) Equal(q *Path) bool {
 	if p == nil || q == nil {
 		return false
@@ -162,9 +164,7 @@ func (p *Path) NextHop() bnet.IP {
 		return p.StaticPath.NextHop
 	case NetlinkPathType:
 		return p.NetlinkPath.NextHop
-	default:
-		log.Panic("Type %d not implemented (yet)", p.Type)
 	}
 
-	return bnet.IP{}
+	panic("Unknown path type")
 }

route/path_test.go

@@ -3,9 +3,169 @@ package route
 import (
 	"testing"
 
+	bnet "github.com/bio-routing/bio-rd/net"
 	"github.com/stretchr/testify/assert"
 )
 
+func TestPathNextHop(t *testing.T) {
+	tests := []struct {
+		name     string
+		p        *Path
+		expected bnet.IP
+	}{
+		{
+			name: "BGP Path",
+			p: &Path{
+				Type: BGPPathType,
+				BGPPath: &BGPPath{
+					NextHop: bnet.IPv4(123),
+				},
+			},
+			expected: bnet.IPv4(123),
+		},
+		{
+			name: "Static Path",
+			p: &Path{
+				Type: StaticPathType,
+				StaticPath: &StaticPath{
+					NextHop: bnet.IPv4(456),
+				},
+			},
+			expected: bnet.IPv4(456),
+		},
+		{
+			name: "Netlink Path",
+			p: &Path{
+				Type: NetlinkPathType,
+				NetlinkPath: &NetlinkPath{
+					NextHop: bnet.IPv4(1000),
+				},
+			},
+			expected: bnet.IPv4(1000),
+		},
+	}
+
+	for _, test := range tests {
+		res := test.p.NextHop()
+		assert.Equal(t, test.expected, res, test.name)
+	}
+}
+
+func TestPathCopy(t *testing.T) {
+	tests := []struct {
+		name     string
+		p        *Path
+		expected *Path
+	}{
+		{
+			name: "nil test",
+		},
+	}
+
+	for _, test := range tests {
+		res := test.p.Copy()
+		assert.Equal(t, test.expected, res, test.name)
+	}
+}
+
+func TestEqual(t *testing.T) {
+	tests := []struct {
+		name     string
+		p        *Path
+		q        *Path
+		expected bool
+	}{
+		{
+			name:     "Different types",
+			p:        &Path{Type: 100},
+			q:        &Path{Type: 200},
+			expected: false,
+		},
+	}
+
+	for _, test := range tests {
+		res := test.p.Equal(test.q)
+		assert.Equalf(t, test.expected, res, test.name)
+	}
+}
+
+func TestSelect(t *testing.T) {
+	tests := []struct {
+		name     string
+		p        *Path
+		q        *Path
+		expected int8
+	}{
+		{
+			name:     "All nil",
+			expected: 0,
+		},
+		{
+			name:     "p nil",
+			q:        &Path{},
+			expected: -1,
+		},
+		{
+			name:     "q nil",
+			p:        &Path{},
+			expected: 1,
+		},
+		{
+			name:     "p > q",
+			p:        &Path{Type: 20},
+			q:        &Path{Type: 10},
+			expected: 1,
+		},
+		{
+			name:     "p < q",
+			p:        &Path{Type: 10},
+			q:        &Path{Type: 20},
+			expected: -1,
+		},
+		{
+			name: "Static",
+			p: &Path{
+				Type:       StaticPathType,
+				StaticPath: &StaticPath{},
+			},
+			q: &Path{
+				Type:       StaticPathType,
+				StaticPath: &StaticPath{},
+			},
+			expected: 0,
+		},
+		{
+			name: "BGP",
+			p: &Path{
+				Type:    BGPPathType,
+				BGPPath: &BGPPath{},
+			},
+			q: &Path{
+				Type:    BGPPathType,
+				BGPPath: &BGPPath{},
+			},
+			expected: 0,
+		},
+		{
+			name: "Netlink",
+			p: &Path{
+				Type:        NetlinkPathType,
+				NetlinkPath: &NetlinkPath{},
+			},
+			q: &Path{
+				Type:        NetlinkPathType,
+				NetlinkPath: &NetlinkPath{},
+			},
+			expected: 0,
+		},
+	}
+
+	for _, test := range tests {
+		res := test.p.Select(test.q)
+		assert.Equalf(t, test.expected, res, "Test %q", test.name)
+	}
+}
+
 func TestPathsDiff(t *testing.T) {
 	tests := []struct {
 		name     string