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/pnd_test.go

@@ -2,7 +2,6 @@ package server
 
 import (
 	"context"
-	"os"
 	"reflect"
 	"testing"
 	"time"
@@ -14,14 +13,12 @@ import (
 	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/southbound"
 	"code.fbi.h-da.de/danet/gosdn/controller/mocks"
 	"code.fbi.h-da.de/danet/gosdn/controller/nucleus"
-	"code.fbi.h-da.de/danet/gosdn/controller/rbac"
 	"code.fbi.h-da.de/danet/gosdn/models/generated/openconfig"
 	"github.com/golang/protobuf/proto"
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/google/uuid"
 	"github.com/openconfig/gnmi/proto/gnmi"
-	log "github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/mock"
 )
 
@@ -42,32 +39,59 @@ var mockPnd *mocks.NetworkDomain
 var mockDevice device.Device
 var sbiStore southbound.Store
 
-func TestMain(m *testing.M) {
-	log.SetReportCaller(true)
+func initUUIDs(t *testing.T) {
 	var err error
 	pndUUID, err = uuid.Parse(pndID)
 	if err != nil {
-		log.Fatal(err)
+		t.Fatal(err)
 	}
 
 	sbiUUID, err = uuid.Parse(sbiID)
 	if err != nil {
-		log.Fatal(err)
+		t.Fatal(err)
 	}
 
 	pendingChangeUUID, err = uuid.Parse(pendingChangeID)
 	if err != nil {
-		log.Fatal(err)
+		t.Fatal(err)
 	}
 
 	committedChangeUUID, err = uuid.Parse(committedChangeID)
 	if err != nil {
-		log.Fatal(err)
+		t.Fatal(err)
 	}
 
 	deviceUUID, err = uuid.Parse(ondID)
 	if err != nil {
-		log.Fatal(err)
+		t.Fatal(err)
+	}
+}
+
+func getTestCoreServer(t *testing.T) *core {
+	var err error
+	pndUUID, err = uuid.Parse(pndID)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	sbiUUID, err = uuid.Parse(sbiID)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	pendingChangeUUID, err = uuid.Parse(pendingChangeID)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	committedChangeUUID, err = uuid.Parse(committedChangeID)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	deviceUUID, err = uuid.Parse(ondID)
+	if err != nil {
+		t.Fatal(err)
 	}
 
 	mockDevice = &nucleus.CommonDevice{
@@ -84,14 +108,14 @@ func TestMain(m *testing.M) {
 
 	sbi, err := nucleus.NewSBI(spb.Type_TYPE_OPENCONFIG, sbiUUID)
 	if err != nil {
-		log.Fatal(err)
+		t.Fatal(err)
 	}
 	mockDevice.(*nucleus.CommonDevice).SetSBI(sbi)
 	mockDevice.(*nucleus.CommonDevice).SetTransport(&mocks.Transport{})
 	mockDevice.(*nucleus.CommonDevice).SetName(hostname)
 	sbiStore = nucleus.NewSbiStore(pndUUID)
 	if err := sbiStore.Add(mockDevice.SBI()); err != nil {
-		log.Fatal(err)
+		t.Fatal(err)
 	}
 
 	mockChange := &mocks.Change{}
@@ -115,21 +139,96 @@ func TestMain(m *testing.M) {
 	mockPnd.On("ChangeOND", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(uuid.Nil, nil)
 	mockPnd.On("Request", mock.Anything, mock.Anything).Return(nil, nil)
 
-	pndc = nucleus.NewMemoryPndStore()
-	if err := pndc.Add(mockPnd); err != nil {
-		log.Fatal(err)
+	pndStore := nucleus.NewMemoryPndStore()
+	if err := pndStore.Add(mockPnd); err != nil {
+		t.Fatal(err)
 	}
 
-	// everyting auth related
-	userService = rbac.NewUserService(rbac.NewMemoryUserStore())
-	roleService = rbac.NewRoleService(rbac.NewMemoryRoleStore())
-	err = clearAndCreateAuthTestSetup()
+	c := NewCoreServer(pndStore)
+
+	return c
+}
+
+func getTestPndServer(t *testing.T) *pndServer {
+	var err error
+	pndUUID, err = uuid.Parse(pndID)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	sbiUUID, err = uuid.Parse(sbiID)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	pendingChangeUUID, err = uuid.Parse(pendingChangeID)
 	if err != nil {
-		log.Fatal(err)
+		t.Fatal(err)
 	}
-	jwt = rbac.NewJWTManager("", 1*time.Minute)
 
-	os.Exit(m.Run())
+	committedChangeUUID, err = uuid.Parse(committedChangeID)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	deviceUUID, err = uuid.Parse(ondID)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	mockDevice = &nucleus.CommonDevice{
+		Model: &openconfig.Device{
+			System: &openconfig.OpenconfigSystem_System{
+				Config: &openconfig.OpenconfigSystem_System_Config{
+					Hostname:   &hostname,
+					DomainName: &domainname,
+				},
+			},
+		},
+		UUID: deviceUUID,
+	}
+
+	sbi, err := nucleus.NewSBI(spb.Type_TYPE_OPENCONFIG, sbiUUID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mockDevice.(*nucleus.CommonDevice).SetSBI(sbi)
+	mockDevice.(*nucleus.CommonDevice).SetTransport(&mocks.Transport{})
+	mockDevice.(*nucleus.CommonDevice).SetName(hostname)
+	sbiStore = nucleus.NewSbiStore(pndUUID)
+	if err := sbiStore.Add(mockDevice.SBI()); err != nil {
+		t.Fatal(err)
+	}
+
+	mockChange := &mocks.Change{}
+	mockChange.On("Age").Return(time.Hour)
+	mockChange.On("State").Return(ppb.ChangeState_CHANGE_STATE_INCONSISTENT)
+
+	mockPnd = &mocks.NetworkDomain{}
+	mockPnd.On("ID").Return(pndUUID)
+	mockPnd.On("GetName").Return("test")
+	mockPnd.On("GetDescription").Return("test")
+	mockPnd.On("GetSBIs").Return(sbiStore)
+	mockPnd.On("GetSBI", mock.Anything).Return(mockDevice.SBI(), nil)
+	mockPnd.On("Devices").Return([]uuid.UUID{deviceUUID})
+	mockPnd.On("PendingChanges").Return([]uuid.UUID{pendingChangeUUID})
+	mockPnd.On("CommittedChanges").Return([]uuid.UUID{committedChangeUUID})
+	mockPnd.On("GetChange", mock.Anything).Return(mockChange, nil)
+	mockPnd.On("AddDevice", mock.Anything, mock.Anything, mock.Anything).Return(nil)
+	mockPnd.On("GetDevice", mock.Anything).Return(mockDevice, nil)
+	mockPnd.On("Commit", mock.Anything).Return(nil)
+	mockPnd.On("Confirm", mock.Anything).Return(nil)
+	mockPnd.On("ChangeOND", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(uuid.Nil, nil)
+	mockPnd.On("Request", mock.Anything, mock.Anything).Return(nil, nil)
+
+	pndStore := nucleus.NewMemoryPndStore()
+	if err := pndStore.Add(mockPnd); err != nil {
+		t.Fatal(err)
+	}
+
+	c := NewPndServer(pndStore)
+
+	return c
 }
 
 // TODO: We should re-add all tests for changes.
@@ -165,10 +264,9 @@ func Test_pnd_Get(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			p := core{
-				UnimplementedCoreServiceServer: pb.UnimplementedCoreServiceServer{},
-			}
-			resp, err := p.GetPnd(tt.args.ctx, tt.args.request)
+			c := getTestCoreServer(t)
+
+			resp, err := c.GetPnd(tt.args.ctx, tt.args.request)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Get() error = %v, wantErr %v", err, tt.wantErr)
 				return
@@ -184,6 +282,8 @@ func Test_pnd_Get(t *testing.T) {
 }
 
 func Test_pnd_GetPath(t *testing.T) {
+	initUUIDs(t)
+
 	opts := cmp.Options{
 		cmpopts.SortSlices(
 			func(x, y *gnmi.Update) bool {
@@ -209,9 +309,9 @@ func Test_pnd_GetPath(t *testing.T) {
 				ctx: context.Background(),
 				request: &ppb.GetPathRequest{
 					Timestamp: time.Now().UnixNano(),
-					Did:       mockDevice.ID().String(),
+					Did:       deviceUUID.String(),
 					Path:      "system/config/hostname",
-					Pid:       mockPnd.ID().String(),
+					Pid:       pndUUID.String(),
 				},
 			},
 			want: []*gnmi.Notification{
@@ -247,9 +347,9 @@ func Test_pnd_GetPath(t *testing.T) {
 				ctx: context.Background(),
 				request: &ppb.GetPathRequest{
 					Timestamp: time.Now().UnixNano(),
-					Did:       mockDevice.ID().String(),
+					Did:       deviceUUID.String(),
 					Path:      "system",
-					Pid:       mockPnd.ID().String(),
+					Pid:       pndUUID.String(),
 				},
 			},
 			want: []*gnmi.Notification{
@@ -279,9 +379,9 @@ func Test_pnd_GetPath(t *testing.T) {
 				ctx: context.Background(),
 				request: &ppb.GetPathRequest{
 					Timestamp: time.Now().UnixNano(),
-					Did:       mockDevice.ID().String(),
+					Did:       deviceUUID.String(),
 					Path:      "this/path/is/not/valid",
-					Pid:       mockPnd.ID().String(),
+					Pid:       pndUUID.String(),
 				},
 			},
 			want:    []*gnmi.Notification{},
@@ -290,9 +390,7 @@ func Test_pnd_GetPath(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			s := pndServer{
-				UnimplementedPndServiceServer: ppb.UnimplementedPndServiceServer{},
-			}
+			s := getTestPndServer(t)
 			resp, err := s.GetPath(tt.args.ctx, tt.args.request)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("GetPath() error = %v, wantErr %v", err, tt.wantErr)