Skip to content
Snippets Groups Projects
Commit 2069c54a authored by Manuel Kieweg's avatar Manuel Kieweg
Browse files

linter pleasing

parent 45d4f7ed
No related branches found
No related tags found
1 merge request!155Northbound Interface
Pipeline #72699 failed
Stage: .pre
Stage: test
Stage: build
Stage: apply
Stage: integration-test
Stage: .post
This commit is part of merge request !155. Comments created here will be created in the context of that merge request.
Hide whitespace changes
Inline Side-by-side
cli/grpc.go
+ 8
− 3
View file @ 2069c54a
......@@ -168,7 +168,7 @@ func commitConfirm(addr, pnd string, changes []*ppb.SetChange) (*ppb.SetResponse
// AddDevice adds a new device to the controller. The device name is optional.
// If no name is provided a name will be generated upon device creation.
func AddDevice(addr, username, password, pnd, deviceAddress, deviceName string, sbi spb.Type) error {
func AddDevice(addr, username, password, sbi, pnd, deviceAddress, deviceName string) error {
pndClient, err := nbi.PndClient(addr, grpcWithInsecure)
if err != nil {
return err
......@@ -180,13 +180,16 @@ func AddDevice(addr, username, password, pnd, deviceAddress, deviceName string,
{
Address: deviceAddress,
Sbi: &spb.SouthboundInterface{
Type: sbi,
Id: sbi,
},
DeviceName: deviceName,
TransportOption: &tpb.TransportOption{
Address: addr,
Username: username,
Password: password,
TransportOption: &tpb.TransportOption_GnmiTransportOption{
GnmiTransportOption: &tpb.GnmiTransportOption{},
},
},
},
},
......@@ -196,6 +199,8 @@ func AddDevice(addr, username, password, pnd, deviceAddress, deviceName string,
resp, err := pndClient.Set(ctx, req)
if err != nil {
return err
} else if resp.Status != ppb.SetResponse_OK {
log.Error(resp.Status)
}
log.Info(resp.String())
return nil
......@@ -211,7 +216,7 @@ func GetDevice(addr, pid, path string, did ...string) (*ppb.GetResponse, error)
}
var all bool
if len(did) != 0 {
if len(did) == 0 {
all = true
}
......
cli/grpc_test.go
+ 228
− 441
View file @ 2069c54a
......@@ -6,14 +6,15 @@ import (
"reflect"
"strconv"
"testing"
"time"
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/forks/google/gnmi"
nbi "code.fbi.h-da.de/cocsn/gosdn/northbound/server"
"code.fbi.h-da.de/cocsn/gosdn/nucleus"
"github.com/google/uuid"
"github.com/openconfig/ygot/ygot"
log "github.com/sirupsen/logrus"
"google.golang.org/grpc"
"k8s.io/apimachinery/pkg/util/rand"
......@@ -27,83 +28,59 @@ const testPid = "06aa4994-80f7-4751-99a4-6826b72d0057"
const testCuid = "cf628f4b-393d-44a5-affb-949dfe5c3c27"
const testDid = "1c37ff20-0169-44e0-bf37-b64787a979d5"
func startGrpcServer() (*grpc.Server, string, error) {
func startGrpcServer() (*grpc.Server, string, string, error) {
port := rand.IntnRange(1025, 65536)
sock := "localhost:" + strconv.Itoa(port)
pndc := nucleus.NewPndStore()
pid, err := uuid.Parse(testPid)
if err != nil {
return nil, "", err
return nil, "", "", err
}
pnd, err := nucleus.NewPND("testpnd", "test pnd", pid, nil)
sbi := nucleus.NewSBI(spb.Type_OPENCONFIG)
pnd, err := nucleus.NewPND("testpnd", "test pnd", pid, sbi)
if err != nil {
return nil, "", err
return nil, "", "", err
}
if err := pndc.Add(pnd); err != nil {
return nil, "", err
return nil, "", "", err
}
lis, err := net.Listen("tcp", sock)
if err != nil {
return nil, "", err
return nil, "", "", err
}
grpcServer := grpc.NewServer()
northbound := nbi.NewNBI(pndc)
pb.RegisterCoreServer(grpcServer, northbound.Core)
ppb.RegisterPndServer(grpcServer, northbound.Pnd)
go func() {
log.Fatal(grpcServer.Serve(lis))
if err := grpcServer.Serve(lis); err != nil {
log.Fatal(err)
}
}()
return grpcServer, sock, nil
return grpcServer, sock, sbi.ID().String(), nil
}
func TestAddDevice(t *testing.T) {
type args struct {
addr string
username string
password string
sbi string
pnd string
deviceName string
deviceAddress string
sbi spb.Type
deviceName string
}
tests := []struct {
name string
args args
wantErr bool
}{
{
name: "default",
args: args{
username: testUser,
password: testPassword,
pnd: testPid,
deviceName: "testDevice",
sbi: spb.Type_OPENCONFIG,
},
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
}
if err := AddDevice(
sock,
tt.args.username,
tt.args.password,
tt.args.pnd,
tt.args.deviceName,
tt.args.deviceAddress,
tt.args.sbi,
); (err != nil) != tt.wantErr {
if err := AddDevice(tt.args.addr, tt.args.username, tt.args.password, tt.args.sbi, tt.args.pnd, tt.args.deviceAddress, tt.args.deviceName); (err != nil) != tt.wantErr {
t.Errorf("AddDevice() error = %v, wantErr %v", err, tt.wantErr)
}
})
......@@ -112,6 +89,7 @@ func TestAddDevice(t *testing.T) {
func TestAddPnd(t *testing.T) {
type args struct {
addr string
name string
description string
sbi string
......@@ -121,81 +99,61 @@ func TestAddPnd(t *testing.T) {
args args
wantErr bool
}{
{
name: "default",
args: args{
name: "test",
description: "test",
sbi: "openconfig",
},
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
}
if err := AddPnd(sock, tt.args.name, tt.args.description, tt.args.sbi); (err != nil) != tt.wantErr {
if err := AddPnd(tt.args.addr, tt.args.name, tt.args.description, tt.args.sbi); (err != nil) != tt.wantErr {
t.Errorf("AddPnd() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestCapabilities(t *testing.T) {
type args struct {
a string
u string
p string
}
tests := []struct {
name string
args args
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := Capabilities(tt.args.a, tt.args.u, tt.args.p); (err != nil) != tt.wantErr {
t.Errorf("Capabilities() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestCommit(t *testing.T) {
type args struct {
addr string
pnd string
cuids []string
}
tests := []struct {
name string
args args
want ppb.SetResponseStatus
want *ppb.SetResponse
wantErr bool
}{
{
name: "default",
args: args{
pnd: testPid,
cuids: []string{
testCuid,
},
},
want: ppb.SetResponse_OK,
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
}
got, err := Commit(sock, tt.args.pnd, tt.args.cuids...)
if err != nil {
if !tt.wantErr {
t.Errorf("Commit() error = %v, wantErr %v", err, tt.wantErr)
}
got, err := Commit(tt.args.addr, tt.args.pnd, tt.args.cuids...)
if (err != nil) != tt.wantErr {
t.Errorf("Commit() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got.Status, tt.want) {
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("Commit() got = %v, want %v", got, tt.want)
}
})
......@@ -204,49 +162,26 @@ func TestCommit(t *testing.T) {
func TestConfirm(t *testing.T) {
type args struct {
addr string
pnd string
cuids []string
}
tests := []struct {
name string
args args
want ppb.SetResponseStatus
want *ppb.SetResponse
wantErr bool
}{
{
name: "default",
args: args{
pnd: testPid,
cuids: []string{
testCuid,
},
},
want: ppb.SetResponse_OK,
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
}
got, err := Confirm(sock, tt.args.pnd, tt.args.cuids...)
if err != nil {
if !tt.wantErr {
t.Errorf("Confirm() error = %v, wantErr %v", err, tt.wantErr)
}
got, err := Confirm(tt.args.addr, tt.args.pnd, tt.args.cuids...)
if (err != nil) != tt.wantErr {
t.Errorf("Confirm() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got.Status, tt.want) {
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("Confirm() got = %v, want %v", got, tt.want)
}
})
......@@ -255,6 +190,7 @@ func TestConfirm(t *testing.T) {
func TestDelete(t *testing.T) {
type args struct {
addr string
did string
pid string
path string
......@@ -262,35 +198,14 @@ func TestDelete(t *testing.T) {
tests := []struct {
name string
args args
want ppb.SetResponseStatus
want *ppb.SetResponse
wantErr bool
}{
{
name: "default",
args: args{
did: "",
pid: "",
path: "",
},
want: ppb.SetResponse_OK,
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
}
got, err := Delete(sock, tt.args.did, tt.args.pid, tt.args.path)
got, err := Delete(tt.args.addr, tt.args.did, tt.args.pid, tt.args.path)
if (err != nil) != tt.wantErr {
t.Errorf("Delete() error = %v, wantErr %v", err, tt.wantErr)
return
......@@ -304,7 +219,8 @@ func TestDelete(t *testing.T) {
func TestGetChanges(t *testing.T) {
type args struct {
pnd string
addr string
pnd string
}
tests := []struct {
name string
......@@ -312,36 +228,11 @@ func TestGetChanges(t *testing.T) {
want *ppb.GetResponse
wantErr bool
}{
{
name: "default",
args: args{
pnd: testPid,
},
want: &ppb.GetResponse{
Timestamp: time.Now().UnixNano(),
Pnd: &ppb.PrincipalNetworkDomain{},
Ond: nil,
Sbi: nil,
Change: nil,
},
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
}
got, err := GetChanges(sock, tt.args.pnd)
got, err := GetChanges(tt.args.addr, tt.args.pnd)
if (err != nil) != tt.wantErr {
t.Errorf("GetChanges() error = %v, wantErr %v", err, tt.wantErr)
return
......@@ -355,6 +246,7 @@ func TestGetChanges(t *testing.T) {
func TestGetDevice(t *testing.T) {
type args struct {
addr string
pid string
path string
did []string
......@@ -365,42 +257,11 @@ func TestGetDevice(t *testing.T) {
want *ppb.GetResponse
wantErr bool
}{
{
name: "default",
args: args{
pid: testPid,
path: testPath,
did: []string{testDid},
},
want: &ppb.GetResponse{
Timestamp: time.Now().UnixNano(),
Ond: []*ppb.OrchestratedNetworkingDevice{
{
Id: testDid,
Name: "testOnd",
Device: nil,
Sbi: nil,
},
},
},
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
}
got, err := GetDevice(sock, tt.args.pid, tt.args.path, tt.args.did...)
got, err := GetDevice(tt.args.addr, tt.args.pid, tt.args.path, tt.args.did...)
if (err != nil) != tt.wantErr {
t.Errorf("GetDevice() error = %v, wantErr %v", err, tt.wantErr)
return
......@@ -413,38 +274,20 @@ func TestGetDevice(t *testing.T) {
}
func TestGetIds(t *testing.T) {
type args struct {
addr string
}
tests := []struct {
name string
args args
want []*ppb.PrincipalNetworkDomain
wantErr bool
}{
{
name: "default",
want: []*ppb.PrincipalNetworkDomain{
{
Id: testPid,
Name: "testPnd",
Description: "testPnd",
},
},
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
}
got, err := GetIds(sock)
got, err := GetIds(tt.args.addr)
if (err != nil) != tt.wantErr {
t.Errorf("GetIds() error = %v, wantErr %v", err, tt.wantErr)
return
......@@ -458,6 +301,7 @@ func TestGetIds(t *testing.T) {
func TestGetPnd(t *testing.T) {
type args struct {
addr string
args []string
}
tests := []struct {
......@@ -466,37 +310,11 @@ func TestGetPnd(t *testing.T) {
want *pb.GetResponse
wantErr bool
}{
{
name: "default",
args: args{args: []string{testPid}},
want: &pb.GetResponse{
Timestamp: time.Now().UnixNano(),
Pnd: []*ppb.PrincipalNetworkDomain{
{
Id: testPid,
Name: "testPnd",
Description: "testPnd",
},
},
},
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
}
got, err := GetPnd(sock, tt.args.args...)
got, err := GetPnd(tt.args.addr, tt.args.args...)
if (err != nil) != tt.wantErr {
t.Errorf("GetPnd() error = %v, wantErr %v", err, tt.wantErr)
return
......@@ -509,30 +327,19 @@ func TestGetPnd(t *testing.T) {
}
func TestInit(t *testing.T) {
type args struct {
addr string
}
tests := []struct {
name string
args args
wantErr bool
}{
{
name: "default",
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
}
if err := Init(sock); (err != nil) != tt.wantErr {
if err := Init(tt.args.addr); (err != nil) != tt.wantErr {
t.Errorf("Init() error = %v, wantErr %v", err, tt.wantErr)
}
})
......@@ -541,6 +348,7 @@ func TestInit(t *testing.T) {
func TestReplace(t *testing.T) {
type args struct {
addr string
did string
pid string
path string
......@@ -552,36 +360,11 @@ func TestReplace(t *testing.T) {
want *ppb.SetResponse
wantErr bool
}{
{
name: "default",
args: args{
did: testDid,
pid: testPid,
path: testPath,
value: "ceos3000",
},
want: &ppb.SetResponse{
Timestamp: time.Now().UnixNano(),
Status: ppb.SetResponse_OK,
},
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
}
got, err := Replace(sock, tt.args.did, tt.args.pid, tt.args.path, tt.args.value)
got, err := Replace(tt.args.addr, tt.args.did, tt.args.pid, tt.args.path, tt.args.value)
if (err != nil) != tt.wantErr {
t.Errorf("Replace() error = %v, wantErr %v", err, tt.wantErr)
return
......@@ -593,8 +376,55 @@ func TestReplace(t *testing.T) {
}
}
func TestSubscribe(t *testing.T) {
type args struct {
address string
username string
password string
deviceName string
sample int64
heartbeat int64
args []string
}
tests := []struct {
name string
args args
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := Subscribe(tt.args.address, tt.args.username, tt.args.password, tt.args.deviceName, tt.args.sample, tt.args.heartbeat, tt.args.args...); (err != nil) != tt.wantErr {
t.Errorf("Subscribe() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestTarget(t *testing.T) {
type args struct {
bindAddr string
}
tests := []struct {
name string
args args
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := Target(tt.args.bindAddr); (err != nil) != tt.wantErr {
t.Errorf("Target() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestUpdate(t *testing.T) {
type args struct {
addr string
did string
pid string
path string
......@@ -606,36 +436,11 @@ func TestUpdate(t *testing.T) {
want *ppb.SetResponse
wantErr bool
}{
{
name: "default",
args: args{
did: testDid,
pid: testPid,
path: testPath,
value: "ceos3000",
},
want: &ppb.SetResponse{
Timestamp: time.Now().UnixNano(),
Status: ppb.SetResponse_OK,
},
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
}
got, err := Update(sock, tt.args.did, tt.args.pid, tt.args.path, tt.args.value)
got, err := Update(tt.args.addr, tt.args.did, tt.args.pid, tt.args.path, tt.args.value)
if (err != nil) != tt.wantErr {
t.Errorf("Update() error = %v, wantErr %v", err, tt.wantErr)
return
......@@ -647,8 +452,29 @@ func TestUpdate(t *testing.T) {
}
}
func Test_callback(t *testing.T) {
type args struct {
newConfig ygot.ValidatedGoStruct
}
tests := []struct {
name string
args args
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := callback(tt.args.newConfig); (err != nil) != tt.wantErr {
t.Errorf("callback() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func Test_commitConfirm(t *testing.T) {
type args struct {
addr string
pnd string
changes []*ppb.SetChange
}
......@@ -658,39 +484,11 @@ func Test_commitConfirm(t *testing.T) {
want *ppb.SetResponse
wantErr bool
}{
{
name: "default",
args: args{
pnd: testPid,
changes: []*ppb.SetChange{
{
Cuid: testCuid,
Op: ppb.SetChange_COMMIT,
},
},
},
want: &ppb.SetResponse{
Timestamp: time.Now().UnixNano(),
Status: ppb.SetResponse_OK,
},
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
}
got, err := commitConfirm(sock, tt.args.pnd, tt.args.changes)
got, err := commitConfirm(tt.args.addr, tt.args.pnd, tt.args.changes)
if (err != nil) != tt.wantErr {
t.Errorf("commitConfirm() error = %v, wantErr %v", err, tt.wantErr)
return
......@@ -703,48 +501,54 @@ func Test_commitConfirm(t *testing.T) {
}
func Test_getAllCore(t *testing.T) {
type args struct {
ctx context.Context
addr string
}
tests := []struct {
name string
args args
want *pb.GetResponse
wantErr bool
}{
{
name: "default",
want: &pb.GetResponse{
Timestamp: time.Now().UnixNano(),
Pnd: []*ppb.PrincipalNetworkDomain{
{
Id: testPid,
Name: "testPnd",
Description: "testPnd",
},
},
},
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
got, err := getAllCore(tt.args.ctx, tt.args.addr)
if (err != nil) != tt.wantErr {
t.Errorf("getAllCore() error = %v, wantErr %v", err, tt.wantErr)
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("getAllCore() got = %v, want %v", got, tt.want)
}
})
}
}
ctx := context.Background()
got, err := getAllCore(ctx, sock)
func Test_newServer(t *testing.T) {
type args struct {
model *gnmi.Model
config []byte
}
tests := []struct {
name string
args args
want *server
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := newServer(tt.args.model, tt.args.config)
if (err != nil) != tt.wantErr {
t.Errorf("getAllCore() error = %v, wantErr %v", err, tt.wantErr)
t.Errorf("newServer() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("getAllCore() got = %v, want %v", got, tt.want)
t.Errorf("newServer() got = %v, want %v", got, tt.want)
}
})
}
......@@ -752,8 +556,9 @@ func Test_getAllCore(t *testing.T) {
func Test_sendChangeRequest(t *testing.T) {
type args struct {
pid string
req *ppb.ChangeRequest
addr string
pid string
req *ppb.ChangeRequest
}
tests := []struct {
name string
......@@ -761,69 +566,51 @@ func Test_sendChangeRequest(t *testing.T) {
want *ppb.SetResponse
wantErr bool
}{
{
name: "update",
args: args{
pid: testPid,
req: &ppb.ChangeRequest{
Id: testCuid,
Path: testPath,
Value: "ceos3000",
ApiOp: ppb.ApiOperation_UPDATE,
},
},
want: nil,
wantErr: false,
},
{
name: "replace",
args: args{
pid: testPid,
req: &ppb.ChangeRequest{
Id: testCuid,
Path: testPath,
Value: "ceos3000",
ApiOp: ppb.ApiOperation_REPLACE,
},
},
want: nil,
wantErr: false,
},
{
name: "delete",
args: args{
pid: testPid,
req: &ppb.ChangeRequest{
Id: testCuid,
Path: testPath,
ApiOp: ppb.ApiOperation_DELETE,
},
},
want: nil,
wantErr: false,
},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server, sock, err := startGrpcServer()
if err != nil {
if !tt.wantErr {
t.Error("startGrpcServer() error = cannot start grpc server")
}
got, err := sendChangeRequest(tt.args.addr, tt.args.pid, tt.args.req)
if (err != nil) != tt.wantErr {
t.Errorf("sendChangeRequest() error = %v, wantErr %v", err, tt.wantErr)
return
}
defer server.Stop()
if tt.name == "unreachable" {
sock = unreachable
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("sendChangeRequest() got = %v, want %v", got, tt.want)
}
})
}
}
got, err := sendChangeRequest(sock, tt.args.pid, tt.args.req)
func Test_server_Get(t *testing.T) {
type fields struct {
Server *gnmi.Server
}
type args struct {
ctx context.Context
req *pb.GetRequest
}
tests := []struct {
name string
fields fields
args args
want *pb.GetResponse
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := &server{
Server: tt.fields.Server,
}
got, err := s.Get(tt.args.ctx, tt.args.req)
if (err != nil) != tt.wantErr {
t.Errorf("sendChangeRequest() error = %v, wantErr %v", err, tt.wantErr)
t.Errorf("Get() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("sendChangeRequest() got = %v, want %v", got, tt.want)
t.Errorf("Get() got = %v, want %v", got, tt.want)
}
})
}
......
cmd/addDevice.go
+ 1
− 3
View file @ 2069c54a
......@@ -32,8 +32,6 @@ POSSIBILITY OF SUCH DAMAGE.
package cmd
import (
spb "code.fbi.h-da.de/cocsn/api/go/gosdn/southbound"
"code.fbi.h-da.de/cocsn/gosdn/cli"
"github.com/spf13/cobra"
)
......@@ -51,10 +49,10 @@ if they diverge from the default credentials.`,
apiEndpoint,
username,
password,
cliSbi,
cliPnd,
address,
deviceName,
spb.Type_OPENCONFIG,
)
},
}
......
controller.go
+ 3
− 1
View file @ 2069c54a
......@@ -74,7 +74,9 @@ func startGrpcServer() error {
pb.RegisterCoreServer(c.grpcServer, c.nbi.Core)
ppb.RegisterPndServer(c.grpcServer, c.nbi.Pnd)
go func() {
log.Fatal(c.grpcServer.Serve(lis))
if err := c.grpcServer.Serve(lis); err != nil {
log.Fatal(err)
}
}()
return nil
}
......
northbound/server/core.go
+ 17
− 1
View file @ 2069c54a
......@@ -6,6 +6,8 @@ import (
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/nucleus"
"github.com/google/uuid"
)
......@@ -45,5 +47,19 @@ func (s core) Get(ctx context.Context, request *pb.GetRequest) (*pb.GetResponse,
}
func (s core) Set(ctx context.Context, request *pb.SetRequest) (*pb.SetResponse, error) {
panic("implement me")
for _, r := range request.Pnd {
sbi := nucleus.NewSBI(spb.Type_OPENCONFIG)
pnd, err := nucleus.NewPND(r.Name, r.Description, uuid.New(), sbi)
if err != nil {
return nil, err
}
if err := pndc.Add(pnd); err != nil {
return nil, err
}
}
return &pb.SetResponse{
Timestamp: time.Now().UnixNano(),
Status: pb.SetResponse_OK,
}, nil
}
northbound/server/nbi.go
+ 1
− 1
View file @ 2069c54a
......@@ -6,7 +6,7 @@ import (
var pndc *nucleus.PndStore
// NewNBI receives a PndStore and returns a nre gRPC *NorthboundInterface
// NewNBI receives a PndStore and returns a new gRPC *NorthboundInterface
func NewNBI(pnds *nucleus.PndStore) *NorthboundInterface {
pndc = pnds
return &NorthboundInterface{
......
northbound/server/pnd.go
+ 32
− 13
View file @ 2069c54a
......@@ -46,6 +46,9 @@ func handleGetPnd(pid uuid.UUID) (*ppb.GetResponse, error) {
return nil, err
}
sbis, err := fillSbis(pnd, true)
if err != nil {
return nil, err
}
return &ppb.GetResponse{
Timestamp: time.Now().UnixNano(),
Pnd: &ppb.PrincipalNetworkDomain{
......@@ -65,6 +68,9 @@ func handleGetSbi(pid uuid.UUID, req *ppb.GetRequest_Sbi) (*ppb.GetResponse, err
return nil, err
}
sbis, err := fillSbis(pnd, req.Sbi.GetAll(), req.Sbi.Sid...)
if err != nil {
return nil, err
}
return &ppb.GetResponse{
Timestamp: time.Now().UnixNano(),
Sbi: sbis,
......@@ -89,6 +95,9 @@ func handleGetOnd(pid uuid.UUID, req *ppb.GetRequest_Ond) (*ppb.GetResponse, err
return nil, err
}
onds, err := fillOnds(pnd, req.Ond.All, req.Ond.Did...)
if err != nil {
return nil, err
}
return &ppb.GetResponse{
Timestamp: time.Now().UnixNano(),
Ond: onds,
......@@ -101,6 +110,9 @@ func handleGetChange(pid uuid.UUID, req *ppb.GetRequest_Change) (*ppb.GetRespons
return nil, err
}
changes, err := fillChanges(pnd, req.Change.All, req.Change.Cuid...)
if err != nil {
return nil, err
}
return &ppb.GetResponse{
Timestamp: time.Now().UnixNano(),
Change: changes,
......@@ -228,29 +240,29 @@ func fillChanges(pnd nucleus.PrincipalNetworkDomain, all bool, cuid ...string) (
func (p pnd) Set(ctx context.Context, request *ppb.SetRequest) (*ppb.SetResponse, error) {
pid, err := uuid.Parse(request.Pid)
if err != nil {
return nil, err
return handleSetError(), err
}
pnd, err := pndc.Get(pid)
if err != nil {
return nil, err
return handleSetError(), err
}
ondResp, err := handleSetOnd(pnd, request.Ond)
if err != nil {
return nil, err
return handleSetError(), err
}
sbiResp, err := handleSetSbi(pnd, request.Sbi)
if err != nil {
return nil, err
return handleSetError(), err
}
changeResp, err := handleSetChange(pnd, request.Change)
if err != nil {
return nil, err
return handleSetError(), err
}
changeRequestResp, err := handleChangeRequest(pnd, request.ChangeRequest)
if err != nil {
return nil, err
return handleSetError(), err
}
return &ppb.SetResponse{
Timestamp: time.Now().UnixNano(),
......@@ -268,10 +280,10 @@ func handleSetOnd(pnd nucleus.PrincipalNetworkDomain, req []*ppb.SetOnd) (*ppb.S
for _, r := range req {
sid, err := uuid.Parse(r.Sbi.Id)
if err != nil {
return nil, err
return handleSetError(), err
}
if err := pnd.AddDevice(r.DeviceName, r.TransportOption, sid); err != nil {
return nil, err
return handleSetError(), err
}
}
return &ppb.SetResponse{
......@@ -291,16 +303,16 @@ func handleSetChange(pnd nucleus.PrincipalNetworkDomain, req []*ppb.SetChange) (
for _, r := range req {
cuid, err := uuid.Parse(r.Cuid)
if err != nil {
return nil, err
return handleSetError(), err
}
switch r.Op {
case ppb.SetChange_COMMIT:
if err := pnd.Commit(cuid); err != nil {
return nil, err
return handleSetError(), err
}
case ppb.SetChange_CONFIRM:
if err := pnd.Confirm(cuid); err != nil {
return nil, err
return handleSetError(), err
}
default:
return nil, &errors.ErrInvalidParameters{
......@@ -319,10 +331,10 @@ func handleChangeRequest(pnd nucleus.PrincipalNetworkDomain, req []*ppb.ChangeRe
for _, r := range req {
did, err := uuid.Parse(r.Id)
if err != nil {
return nil, err
return handleSetError(), err
}
if err := pnd.ChangeOND(did, r.ApiOp, r.Path, r.Value); err != nil {
return nil, err
return handleSetError(), err
}
}
return &ppb.SetResponse{
......@@ -330,3 +342,10 @@ func handleChangeRequest(pnd nucleus.PrincipalNetworkDomain, req []*ppb.ChangeRe
Status: ppb.SetResponse_OK,
}, nil
}
func handleSetError() *ppb.SetResponse {
return &ppb.SetResponse{
Timestamp: time.Now().UnixNano(),
Status: ppb.SetResponse_ERROR,
}
}
northbound/server/server_test.go 0 → 100644
+ 520
− 0
View file @ 2069c54a
package server
import (
"context"
"reflect"
"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/nucleus"
"github.com/google/uuid"
)
func TestNewNBI(t *testing.T) {
pndc := nucleus.NewPndStore()
type args struct {
pnds *nucleus.PndStore
}
tests := []struct {
name string
args args
want *NorthboundInterface
}{
{
name: "default",
args: args{
pnds: pndc,
},
want: &NorthboundInterface{
Pnd: &pnd{},
Core: &core{},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := NewNBI(tt.args.pnds); !reflect.DeepEqual(got, tt.want) {
t.Errorf("NewNBI() = %v, want %v", got, tt.want)
}
})
}
}
func Test_core_Get(t *testing.T) {
type fields struct {
UnimplementedCoreServer pb.UnimplementedCoreServer
}
type args struct {
ctx context.Context
request *pb.GetRequest
}
tests := []struct {
name string
fields fields
args args
want *pb.GetResponse
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := core{
UnimplementedCoreServer: tt.fields.UnimplementedCoreServer,
}
got, err := s.Get(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Get() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("Get() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_core_Set(t *testing.T) {
type fields struct {
UnimplementedCoreServer pb.UnimplementedCoreServer
}
type args struct {
ctx context.Context
request *pb.SetRequest
}
tests := []struct {
name string
fields fields
args args
want *pb.SetResponse
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
s := core{
UnimplementedCoreServer: tt.fields.UnimplementedCoreServer,
}
got, err := s.Set(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Set() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("Set() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_fillChanges(t *testing.T) {
type args struct {
pnd nucleus.PrincipalNetworkDomain
all bool
cuid []string
}
tests := []struct {
name string
args args
want []*ppb.Change
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := fillChanges(tt.args.pnd, tt.args.all, tt.args.cuid...)
if (err != nil) != tt.wantErr {
t.Errorf("fillChanges() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("fillChanges() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_fillOnds(t *testing.T) {
type args struct {
pnd nucleus.PrincipalNetworkDomain
all bool
did []string
}
tests := []struct {
name string
args args
want []*ppb.OrchestratedNetworkingDevice
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := fillOnds(tt.args.pnd, tt.args.all, tt.args.did...)
if (err != nil) != tt.wantErr {
t.Errorf("fillOnds() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("fillOnds() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_fillSbis(t *testing.T) {
type args struct {
pnd nucleus.PrincipalNetworkDomain
all bool
sid []string
}
tests := []struct {
name string
args args
want []*spb.SouthboundInterface
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := fillSbis(tt.args.pnd, tt.args.all, tt.args.sid...)
if (err != nil) != tt.wantErr {
t.Errorf("fillSbis() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("fillSbis() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_handleChangeRequest(t *testing.T) {
type args struct {
pnd nucleus.PrincipalNetworkDomain
req []*ppb.ChangeRequest
}
tests := []struct {
name string
args args
want *ppb.SetResponse
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := handleChangeRequest(tt.args.pnd, tt.args.req)
if (err != nil) != tt.wantErr {
t.Errorf("handleChangeRequest() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("handleChangeRequest() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_handleGetChange(t *testing.T) {
type args struct {
pid uuid.UUID
req *ppb.GetRequest_Change
}
tests := []struct {
name string
args args
want *ppb.GetResponse
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := handleGetChange(tt.args.pid, tt.args.req)
if (err != nil) != tt.wantErr {
t.Errorf("handleGetChange() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("handleGetChange() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_handleGetOnd(t *testing.T) {
type args struct {
pid uuid.UUID
req *ppb.GetRequest_Ond
}
tests := []struct {
name string
args args
want *ppb.GetResponse
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := handleGetOnd(tt.args.pid, tt.args.req)
if (err != nil) != tt.wantErr {
t.Errorf("handleGetOnd() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("handleGetOnd() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_handleGetPnd(t *testing.T) {
type args struct {
pid uuid.UUID
}
tests := []struct {
name string
args args
want *ppb.GetResponse
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := handleGetPnd(tt.args.pid)
if (err != nil) != tt.wantErr {
t.Errorf("handleGetPnd() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("handleGetPnd() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_handleGetSbi(t *testing.T) {
type args struct {
pid uuid.UUID
req *ppb.GetRequest_Sbi
}
tests := []struct {
name string
args args
want *ppb.GetResponse
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := handleGetSbi(tt.args.pid, tt.args.req)
if (err != nil) != tt.wantErr {
t.Errorf("handleGetSbi() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("handleGetSbi() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_handleSetChange(t *testing.T) {
type args struct {
pnd nucleus.PrincipalNetworkDomain
req []*ppb.SetChange
}
tests := []struct {
name string
args args
want *ppb.SetResponse
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := handleSetChange(tt.args.pnd, tt.args.req)
if (err != nil) != tt.wantErr {
t.Errorf("handleSetChange() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("handleSetChange() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_handleSetError(t *testing.T) {
tests := []struct {
name string
want *ppb.SetResponse
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := handleSetError(); !reflect.DeepEqual(got, tt.want) {
t.Errorf("handleSetError() = %v, want %v", got, tt.want)
}
})
}
}
func Test_handleSetOnd(t *testing.T) {
type args struct {
pnd nucleus.PrincipalNetworkDomain
req []*ppb.SetOnd
}
tests := []struct {
name string
args args
want *ppb.SetResponse
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := handleSetOnd(tt.args.pnd, tt.args.req)
if (err != nil) != tt.wantErr {
t.Errorf("handleSetOnd() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("handleSetOnd() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_handleSetSbi(t *testing.T) {
type args struct {
pnd nucleus.PrincipalNetworkDomain
req []*ppb.SetSbi
}
tests := []struct {
name string
args args
want *ppb.SetResponse
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := handleSetSbi(tt.args.pnd, tt.args.req)
if (err != nil) != tt.wantErr {
t.Errorf("handleSetSbi() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("handleSetSbi() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_pnd_Get(t *testing.T) {
type fields struct {
UnimplementedPndServer ppb.UnimplementedPndServer
}
type args struct {
ctx context.Context
request *ppb.GetRequest
}
tests := []struct {
name string
fields fields
args args
want *ppb.GetResponse
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
p := pnd{
UnimplementedPndServer: tt.fields.UnimplementedPndServer,
}
got, err := p.Get(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Get() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("Get() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_pnd_Set(t *testing.T) {
type fields struct {
UnimplementedPndServer ppb.UnimplementedPndServer
}
type args struct {
ctx context.Context
request *ppb.SetRequest
}
tests := []struct {
name string
fields fields
args args
want *ppb.SetResponse
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
p := pnd{
UnimplementedPndServer: tt.fields.UnimplementedPndServer,
}
got, err := p.Set(tt.args.ctx, tt.args.request)
if (err != nil) != tt.wantErr {
t.Errorf("Set() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("Set() got = %v, want %v", got, tt.want)
}
})
}
}
func Test_stringToUUID(t *testing.T) {
type args struct {
sid []string
}
tests := []struct {
name string
args args
want []uuid.UUID
wantErr bool
}{
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := stringToUUID(tt.args.sid)
if (err != nil) != tt.wantErr {
t.Errorf("stringToUUID() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("stringToUUID() got = %v, want %v", got, tt.want)
}
})
}
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment