southbound_test.go

package nucleus

import (
	"code.fbi.h-da.de/cocsn/gosdn/nucleus/util"
	"code.fbi.h-da.de/cocsn/yang-models/generated/openconfig"
	"github.com/google/uuid"
	gpb "github.com/openconfig/gnmi/proto/gnmi"
	"github.com/openconfig/ygot/ygot"
	"github.com/openconfig/ygot/ytypes"
	log "github.com/sirupsen/logrus"
	"reflect"
	"testing"
)

func testSetupSbi() {
	var err error
	aristaUUID, err = uuid.Parse("d3795249-579c-4be7-8818-29f113cb86ee")
	if err != nil {
		log.Fatal(err)
	}

	ocUUID, err = uuid.Parse("5e252b70-38f2-4c99-a0bf-1b16af4d7e67")
	if err != nil {
		log.Fatal(err)
	}
}

var aristaUUID uuid.UUID
var ocUUID uuid.UUID

func TestOpenConfig_Id(t *testing.T) {
	type fields struct {
		transport Transport
		schema    *ytypes.Schema
		id        uuid.UUID
	}
	tests := []struct {
		name   string
		fields fields
		want   uuid.UUID
	}{
		{
			name: "default",
			fields: fields{
				transport: nil,
				schema:    nil,
				id:        ocUUID,
			},
			want: ocUUID,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			oc := &OpenConfig{
				transport: tt.fields.transport,
				schema:    tt.fields.schema,
				id:        tt.fields.id,
			}
			if got := oc.Id(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("Id() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestOpenConfig_SbiIdentifier(t *testing.T) {
	type fields struct {
		transport Transport
		schema    *ytypes.Schema
		id        uuid.UUID
	}
	tests := []struct {
		name   string
		fields fields
		want   string
	}{
		{name: "default", fields: fields{}, want: "openconfig"},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			oc := &OpenConfig{
				transport: tt.fields.transport,
				schema:    tt.fields.schema,
				id:        tt.fields.id,
			}
			if got := oc.SbiIdentifier(); got != tt.want {
				t.Errorf("SbiIdentifier() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestOpenConfig_Schema(t *testing.T) {
	schema, err := openconfig.Schema()
	if err != nil {
		t.Error(err)
	}
	type fields struct {
		transport Transport
		schema    *ytypes.Schema
		id        uuid.UUID
	}
	tests := []struct {
		name   string
		fields fields
		want   *ytypes.Schema
	}{
		{name: "default", fields: fields{}, want: schema},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			oc := &OpenConfig{
				transport: tt.fields.transport,
				schema:    tt.fields.schema,
				id:        tt.fields.id,
			}
			got := oc.Schema().SchemaTree
			if !reflect.DeepEqual(got, tt.want.SchemaTree) {
				t.Errorf("Schema() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_unmarshal(t *testing.T) {
	type args struct {
		path string
		goStruct interface{}
		opt      []ytypes.UnmarshalOpt
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "fail",
			args: args{
				goStruct: &openconfig.Device{},
				path: "../test/resp-interfaces-interface-arista-ceos",
			},
			wantErr: true,
		},
		{
			name: "root w/opts",
			args: args{
				path:     "../test/resp-full-node-arista-ceos",
				goStruct: &openconfig.Device{},
				opt:      []ytypes.UnmarshalOpt{&ytypes.IgnoreExtraFields{}},
			},
			wantErr: false,
		},
		{
			name: "root w/o opts",
			args: args{
				path:     "../test/resp-full-node-arista-ceos",
				goStruct: &openconfig.Device{},
				opt:      nil,
			},
			wantErr: true,
		},
		{
			name: "interfaces w/opts",
			args: args{
				path:     "../test/resp-interfaces-arista-ceos",
				goStruct: &openconfig.Device{},
				opt:      []ytypes.UnmarshalOpt{&ytypes.IgnoreExtraFields{}},
			},
			wantErr: false,
		},
		{
			name: "interfaces w/o opts",
			args: args{
				path:     "../test/resp-interfaces-arista-ceos",
				goStruct: &openconfig.Device{},
				opt:      nil,
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			resp := &gpb.GetResponse{}
			err := util.Read(tt.args.path, resp)
			if err != nil {
				t.Error(err)
			}
			fields := extraxtPathElements(resp.Notification[0].Update[0].Path)
			bytes := resp.Notification[0].Update[0].Val.GetJsonIetfVal()
			if err := unmarshal(bytes, fields, tt.args.goStruct, tt.args.opt...); (err != nil) != tt.wantErr {
				t.Errorf("unmarshal() error = %v, wantErr %v", err, tt.wantErr)
			}
			if tt.args.goStruct.(*openconfig.Device).Interfaces == nil && tt.args.opt != nil{
				t.Errorf("unmarshal() error: field Interfaces must not be nil")
			}
		})
	}
}

func Test_iter(t *testing.T) {
	type args struct {
		a      ygot.GoStruct
		fields []string
	}
	tests := []struct {
		name      string
		args      args
		wantB     ygot.GoStruct
		wantField string
		wantErr   bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotB, gotField, err := iter(tt.args.a, tt.args.fields)
			if (err != nil) != tt.wantErr {
				t.Errorf("iter() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(gotB, tt.wantB) {
				t.Errorf("iter() gotB = %v, want %v", gotB, tt.wantB)
			}
			if gotField != tt.wantField {
				t.Errorf("iter() gotField = %v, want %v", gotField, tt.wantField)
			}
		})
	}
}