networkElement_test.go

package nucleus

import (
	"reflect"
	"testing"

	"code.fbi.h-da.de/danet/gosdn/controller/conflict"
	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/plugin"
	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/transport"
	"code.fbi.h-da.de/danet/gosdn/controller/mocks"

	tpb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/transport"

	"github.com/google/uuid"
)

func TestNetworkElement_Id(t *testing.T) {
	type fields struct {
		Plugin    plugin.Plugin
		Transport transport.Transport
		UUID      uuid.UUID
		Name      string
	}
	tests := []struct {
		name   string
		fields fields
		want   uuid.UUID
	}{
		{
			name: "default",
			fields: fields{
				UUID: mneid,
			},
			want: mneid,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			d := &CommonNetworkElement{
				Plugin:    tt.fields.Plugin,
				transport: tt.fields.Transport,
				UUID:      tt.fields.UUID,
				name:      tt.fields.Name,
			}
			if got := d.ID(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("ID() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestNewNetworkElement(t *testing.T) {
	mockPlugin := mockPlugin(t)
	type args struct {
		plugin plugin.Plugin
		opts   *tpb.TransportOption
		name   string
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "default",
			args: args{
				plugin: mockPlugin,
				opts: &tpb.TransportOption{
					Address:  "test:///",
					Username: "test",
					Password: "test",
					TransportOption: &tpb.TransportOption_GnmiTransportOption{
						GnmiTransportOption: &tpb.GnmiTransportOption{
							Compression:     "",
							GrpcDialOptions: nil,
							Token:           "",
							Encoding:        0,
						},
					},
				},
				name: "MyNetworkElement",
			},
		},
		{
			name: "invalid options",
			args: args{
				plugin: mockPlugin,
				opts: &tpb.TransportOption{
					Address:  "test:///",
					Username: "test",
					Password: "test",
				},
				name: "MyNetworkElement",
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			resp, err := NewNetworkElement(tt.args.name, uuid.Nil, tt.args.opts, tt.args.plugin, conflict.Metadata{})
			if (err != nil) != tt.wantErr {
				t.Errorf("NewNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if resp != nil {
				if reflect.TypeOf(resp.GetPlugin()) != reflect.TypeOf(&mocks.Plugin{}) {
					t.Error("NewNetworkElement() returned invalid plugin")
				}
				if reflect.TypeOf(resp.Transport()) != reflect.TypeOf(&Gnmi{}) {
					t.Error("NewNetworkElement() returned invalid transport")
				}
				if resp.Name() != "MyNetworkElement" {
					t.Error("NewNetworkElement() returned wrong name")
				}
			}
		})
	}
}