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