grpc_test.go

package cli

import (
	"context"
	"net"
	"testing"

	pb "code.fbi.h-da.de/cocsn/api/go/gosdn/core"
	ppb "code.fbi.h-da.de/cocsn/api/go/gosdn/pnd"
	spb "code.fbi.h-da.de/cocsn/api/go/gosdn/southbound"
	"code.fbi.h-da.de/cocsn/gosdn/mocks"
	nbi "code.fbi.h-da.de/cocsn/gosdn/northbound/server"
	"code.fbi.h-da.de/cocsn/gosdn/nucleus"
	"code.fbi.h-da.de/cocsn/yang-models/generated/openconfig"
	"github.com/google/uuid"
	log "github.com/sirupsen/logrus"
	"github.com/stretchr/testify/mock"
	"google.golang.org/grpc"
	"google.golang.org/grpc/test/bufconn"
)

/*
Based on this StackOverflow answer: https://stackoverflow.com/a/52080545/4378176
*/

const bufSize = 1024 * 1024
const bufnet = "bufnet"
const pndID = "2043519e-46d1-4963-9a8e-d99007e104b8"
const changeID = "0992d600-f7d4-4906-9559-409b04d59a5f"
const sbiID = "f6fd4b35-f039-4111-9156-5e4501bb8a5a"
const ondID = "7e0ed8cc-ebf5-46fa-9794-741494914883"

var pndStore *nucleus.PndStore
var lis *bufconn.Listener

func init() {
	dialOptions = []grpc.DialOption{
		grpc.WithContextDialer(bufDialer),
		grpc.WithInsecure(),
	}
	lis = bufconn.Listen(bufSize)
	s := grpc.NewServer()
	pndStore = nucleus.NewPndStore()

	pndUUID, err := uuid.Parse(pndID)
	if err != nil {
		log.Fatal(err)
	}

	changeUUID, err := uuid.Parse(changeID)
	if err != nil {
		log.Fatal(err)
	}

	deviceUUID, err := uuid.Parse(ondID)
	if err != nil {
		log.Fatal(err)
	}

	mockPnd := mocks.PrincipalNetworkDomain{}
	mockPnd.On("ID").Return(pndUUID)
	mockPnd.On("GetName").Return("test")
	mockPnd.On("GetDescription").Return("test")
	mockPnd.On("PendingChanges").Return([]uuid.UUID{changeUUID})
	mockPnd.On("CommittedChanges").Return([]uuid.UUID{changeUUID})
	mockPnd.On("GetChange", mock.Anything).Return(&nucleus.Change{}, nil)
	mockPnd.On("AddDevice", mock.Anything, mock.Anything, mock.Anything).Return(nil)
	mockPnd.On("GetDevice", mock.Anything).Return(&nucleus.Device{
		UUID:     deviceUUID,
		GoStruct: &openconfig.Device{},
	}, 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(nil)

	if err := pndStore.Add(&mockPnd); err != nil {
		log.Fatal(err)
	}
	northbound := nbi.NewNBI(pndStore)
	pb.RegisterCoreServer(s, northbound.Core)
	ppb.RegisterPndServer(s, northbound.Pnd)
	go func() {
		if err := s.Serve(lis); err != nil {
			log.Fatalf("Server exited with error: %v", err)
		}
	}()
}

func bufDialer(context.Context, string) (net.Conn, error) {
	return lis.Dial()
}

func Test_Init(t *testing.T) {
	if err := Init(bufnet); err != nil {
		t.Error(err)
	}
}

func Test_GetIds(t *testing.T) {
	resp, err := GetIds(bufnet)
	if err != nil {
		t.Error(err)
		return
	}
	log.Info(resp)
}

func Test_AddPnd(t *testing.T) {
	sbi := nucleus.NewSBI(spb.Type_OPENCONFIG)
	resp, err := AddPnd(bufnet, "test", "test pnd", sbi.ID().String())
	if err != nil {
		t.Error(err)
		return
	}
	log.Info(resp)
}

func Test_GetPnd(t *testing.T) {
	resp, err := GetPnd(bufnet, pndID)
	if err != nil {
		t.Error(err)
		return
	}
	got := resp.Pnd[0].Id
	if got != pndID {
		t.Errorf("PND ID is %v, expected %v", got, pndID)
	}
}

func Test_GetChanges(t *testing.T) {
	resp, err := GetChanges(bufnet, pndID)
	if err != nil {
		t.Error(err)
		return
	}
	log.Info(resp)
}

func Test_CommitConfirm(t *testing.T) {
	resp, err := Commit(bufnet, pndID, changeID)
	if err != nil {
		t.Error(err)
		return
	}
	log.Info(resp)

	resp, err = Confirm(bufnet, pndID, changeID)
	if err != nil {
		t.Error(err)
		return
	}
	log.Info(resp)

}

func Test_AddDevice(t *testing.T) {
	resp, err := AddDevice(bufnet, "test", "test", sbiID, pndID, "test", "test")
	if err != nil {
		t.Error(err)
		return
	}
	log.Info(resp)
}

func Test_GetDevice(t *testing.T) {
	resp, err := GetDevice(bufnet, pndID, "", ondID)
	if err != nil {
		t.Error(err)
		return
	}
	got := resp.Ond[0].Id
	if got != ondID {
		t.Errorf("PND ID is %v, expected %v", got, ondID)
	}
}

func Test_Update(t *testing.T) {
	resp, err := Update(bufnet, ondID, pndID, "", "")
	if err != nil {
		t.Error(err)
		return
	}
	log.Info(resp)
}

func Test_Replace(t *testing.T) {
	resp, err := Replace(bufnet, ondID, pndID, "", "")
	if err != nil {
		t.Error(err)
		return
	}
	log.Info(resp)
}

func Test_Delete(t *testing.T) {
	resp, err := Delete(bufnet, ondID, pndID, "")
	if err != nil {
		t.Error(err)
		return
	}
	log.Info(resp)
}