Add basic application framework and example application to show interaction between events an NBI

Depends on:

• !340 (merged)
• !344 (merged)
• !349 (merged)
• !342 (merged)

controller/northbound/server/topology_test.go

+package server
+
+import (
+	"context"
+	"reflect"
+	"testing"
+
+	apb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/topology"
+	eventservice "code.fbi.h-da.de/danet/gosdn/controller/eventService"
+	"code.fbi.h-da.de/danet/gosdn/controller/topology"
+	"code.fbi.h-da.de/danet/gosdn/controller/topology/links"
+	"code.fbi.h-da.de/danet/gosdn/controller/topology/nodes"
+	"code.fbi.h-da.de/danet/gosdn/controller/topology/ports"
+	"code.fbi.h-da.de/danet/gosdn/controller/topology/store"
+	"github.com/google/uuid"
+)
+
+func getTestNodeService() nodes.Service {
+	eventService := eventservice.NewMockEventService()
+
+	nodeStore := store.NewGenericStore[nodes.Node]()
+	nodeService := nodes.NewNodeService(nodeStore, eventService)
+
+	return nodeService
+}
+
+func getTestPortService() ports.Service {
+	eventService := eventservice.NewMockEventService()
+
+	portStore := store.NewGenericStore[ports.Port]()
+	portService := ports.NewPortService(portStore, eventService)
+
+	return portService
+}
+
+func getTestTopologyService() topology.Service {
+	eventService := eventservice.NewMockEventService()
+
+	nodeStore := store.NewGenericStore[nodes.Node]()
+	nodeService := nodes.NewNodeService(nodeStore, eventService)
+
+	portStore := store.NewGenericStore[ports.Port]()
+	portService := ports.NewPortService(portStore, eventService)
+
+	linkStore := store.NewGenericStore[links.Link]()
+	topologyService := topology.NewTopologyService(linkStore, nodeService, portService, eventService)
+
+	return topologyService
+}
+
+func getTestTopologyServer() *Topology {
+	eventService := eventservice.NewMockEventService()
+
+	nodeStore := store.NewGenericStore[nodes.Node]()
+	nodeService := nodes.NewNodeService(nodeStore, eventService)
+
+	portStore := store.NewGenericStore[ports.Port]()
+	portService := ports.NewPortService(portStore, eventService)
+
+	linkStore := store.NewGenericStore[links.Link]()
+	topologyService := topology.NewTopologyService(linkStore, nodeService, portService, eventService)
+
+	s := NewTopologyServer(topologyService, nodeService, portService)
+
+	return s
+}
+
+func getTestLink() *apb.Link {
+	return &apb.Link{
+		Name: "test-link",
+		SourceNode: &apb.Node{
+			Name: "test-source-node",
+		},
+		SourcePort: &apb.Port{},
+		TargetNode: &apb.Node{
+			Name: "test-target-node",
+		},
+		TargetPort: &apb.Port{},
+	}
+}
+func TestNewTopologyServer(t *testing.T) {
+	type args struct {
+		service     topology.Service
+		nodeService nodes.Service
+		portService ports.Service
+	}
+	tests := []struct {
+		name string
+		args args
+		want *Topology
+	}{
+		{
+			name: "should create a new topology service",
+			args: args{
+				service:     getTestTopologyService(),
+				nodeService: getTestNodeService(),
+				portService: getTestPortService(),
+			},
+			want: getTestTopologyServer(),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := NewTopologyServer(tt.args.service, tt.args.nodeService, tt.args.portService); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("NewTopologyServer() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestTopology_AddLink(t *testing.T) {
+	type args struct {
+		ctx     context.Context
+		request *apb.AddLinkRequest
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *apb.AddLinkResponse
+		wantErr bool
+	}{
+		{
+			name: "should add a new link",
+			args: args{
+				ctx: context.TODO(),
+				request: &apb.AddLinkRequest{
+					Link: getTestLink(),
+				},
+			},
+			want: &apb.AddLinkResponse{
+				Status: apb.Status_STATUS_OK,
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tr := getTestTopologyServer()
+			got, err := tr.AddLink(tt.args.ctx, tt.args.request)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Topology.AddLink() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got.Status, tt.want.Status) {
+				t.Errorf("Topology.AddLink() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestTopology_GetTopology(t *testing.T) {
+	type fields struct {
+		UnimplementedTopologyServiceServer apb.UnimplementedTopologyServiceServer
+		topologyService                    topology.Service
+		nodeService                        nodes.Service
+		portService                        ports.Service
+	}
+	type args struct {
+		ctx     context.Context
+		request *apb.GetTopologyRequest
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    *apb.GetTopologyResponse
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tr := Topology{
+				UnimplementedTopologyServiceServer: tt.fields.UnimplementedTopologyServiceServer,
+				topologyService:                    tt.fields.topologyService,
+				nodeService:                        tt.fields.nodeService,
+				portService:                        tt.fields.portService,
+			}
+			got, err := tr.GetTopology(tt.args.ctx, tt.args.request)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Topology.GetTopology() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("Topology.GetTopology() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestTopology_ensureNodeAndPortExists(t *testing.T) {
+	type fields struct {
+		UnimplementedTopologyServiceServer apb.UnimplementedTopologyServiceServer
+		topologyService                    topology.Service
+		nodeService                        nodes.Service
+		portService                        ports.Service
+	}
+	type args struct {
+		incomingNode *apb.Node
+		incomingPort *apb.Port
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    nodes.Node
+		want1   ports.Port
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tr := Topology{
+				UnimplementedTopologyServiceServer: tt.fields.UnimplementedTopologyServiceServer,
+				topologyService:                    tt.fields.topologyService,
+				nodeService:                        tt.fields.nodeService,
+				portService:                        tt.fields.portService,
+			}
+			got, got1, err := tr.ensureNodeAndPortExists(tt.args.incomingNode, tt.args.incomingPort)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Topology.ensureNodeAndPortExists() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("Topology.ensureNodeAndPortExists() got = %v, want %v", got, tt.want)
+			}
+			if !reflect.DeepEqual(got1, tt.want1) {
+				t.Errorf("Topology.ensureNodeAndPortExists() got1 = %v, want %v", got1, tt.want1)
+			}
+		})
+	}
+}
+
+func Test_getExistingOrCreateNewUUIDFromString(t *testing.T) {
+	type args struct {
+		id string
+	}
+	tests := []struct {
+		name string
+		args args
+		want uuid.UUID
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := getExistingOrCreateNewUUIDFromString(tt.args.id); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("getExistingOrCreateNewUUIDFromString() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}