principalNetworkDomain_test.go

package nucleus

import (
	"errors"
	"io"
	"reflect"
	"testing"

	"code.fbi.h-da.de/danet/gosdn/api/go/gosdn/csbi"
	ppb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/pnd"
	spb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/southbound"
	tpb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/transport"
	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/device"
	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/networkdomain"
	"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/store"
	"code.fbi.h-da.de/danet/yang-models/generated/openconfig"
	"github.com/google/uuid"
	gpb "github.com/openconfig/gnmi/proto/gnmi"
	"github.com/openconfig/ygot/ygot"
	log "github.com/sirupsen/logrus"
	"github.com/stretchr/testify/mock"
)

func TestNewPND(t *testing.T) {
	p := newPnd()

	type args struct {
		name        string
		description string
		pid         uuid.UUID
	}
	tests := []struct {
		name    string
		args    args
		want    networkdomain.NetworkDomain
		wantErr bool
	}{
		{
			name: "default",
			args: args{
				name:        "default",
				description: "default test pnd",
				pid:         defaultPndID,
			},
			want:    &p,
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := NewPND(tt.args.name, tt.args.description, tt.args.pid, nil, nil)
			if (err != nil) != tt.wantErr {
				t.Errorf("NewPND() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got.GetName() != tt.want.GetName() {
				t.Errorf("NewPND.GetName() = %v, want %v", got, tt.want)
			}
			if got.ID() != tt.want.ID() {
				t.Errorf("NewPND.ID() = %v, want %v", got, tt.want)
			}
			if got.GetDescription() != tt.want.GetDescription() {
				t.Errorf("NewPND.GetDescription() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_destroy(t *testing.T) {
	tests := []struct {
		name    string
		wantErr bool
	}{
		{name: "dummy", wantErr: false},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := destroy(); (err != nil) != tt.wantErr {
				t.Errorf("destroy() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func Test_pndImplementation_AddDevice(t *testing.T) {
	type args struct {
		device interface{}
		name   string
		opts   *tpb.TransportOption
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "default",
			args: args{
				name: "fridolin",
				opts: &tpb.TransportOption{
					TransportOption: &tpb.TransportOption_GnmiTransportOption{
						GnmiTransportOption: &tpb.GnmiTransportOption{},
					},
				},
			},
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pnd := newPnd()
			if err := pnd.addSbi(&OpenConfig{id: defaultSbiID}); err != nil {
				t.Error(err)
			}

			err := pnd.AddDevice(tt.args.name, tt.args.opts, defaultSbiID)
			if (err != nil) != tt.wantErr {
				t.Errorf("AddDevice() error = %v, wantErr %v", err, tt.wantErr)
			}

			if tt.name != "fails wrong type" {
				if err == nil {
					d, err := pnd.devices.Get(store.Query{Name: tt.args.name})
					if err != nil {
						t.Errorf("AddDevice() error = %v", err)
						return
					}
					if d.Name() != tt.args.name {
						t.Errorf("AddDevice() got = %v, want %v", d.Name(), tt.args.name)
					}
					if err := pnd.devices.Delete(d); err != nil {
						t.Error(err)
					}
				}
			}
		})
	}
}

// TODO: refactor test to use store interface instead if direct access.
func Test_pndImplementation_AddSbi(t *testing.T) {
	type args struct {
		sbi southbound.SouthboundInterface
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "default",
			args: args{
				sbi: &OpenConfig{
					id: defaultSbiID,
				},
			},
			wantErr: false,
		},
		// {
		// 	name: "already exists",
		// 	args: args{
		// 		sbi: &OpenConfig{
		// 			id: defaultSbiID,
		// 		},
		// 	},
		// 	wantErr: true,
		// },
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pnd := newPnd()
			err := pnd.AddSbi(tt.args.sbi)
			if (err != nil) != tt.wantErr {
				t.Errorf("AddSbi() error = %v, wantErr %v", err, tt.wantErr)
			}
			if tt.name != "fails wrong type" {
				if err == nil {
					sbi, err := pnd.sbic.Get(store.Query{ID: defaultSbiID})
					if err != nil {
						t.Errorf("AddSbi() SBI %v not in device store %v",
							tt.args.sbi, sbi)
					}
					if err := pnd.sbic.Delete(sbi); err != nil {
						t.Error(err)
					}
				}
			}
		})
	}
}

func Test_pndImplementation_Destroy(t *testing.T) {
	type fields struct {
		name        string
		description string
		sbi         southbound.SbiStore
		devices     device.Store
	}