integration_test.go

package nucleus

import (
	"code.fbi.h-da.de/cocsn/gosdn/forks/goarista/gnmi"
	"context"
	gpb "github.com/openconfig/gnmi/proto/gnmi"
	"os"
	"reflect"
	"sort"
	"testing"
	"time"
)

var address = "141.100.70.171:6030"
var opt *GnmiTransportOptions

func testSetupIntegration() {
	a := os.Getenv("GOSDN_TEST_ENDPOINT")
	if a != "" {
		address = a
	}

	opt = &GnmiTransportOptions{
		Config: gnmi.Config{
			Addr:     address,
			Username: "admin",
			Password: "arista",
			Encoding: gpb.Encoding_JSON_IETF,
		},
	}
}

func TestGnmi_SetIntegration(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test")
	}
	type fields struct {
		opt *GnmiTransportOptions
	}
	type args struct {
		ctx    context.Context
		params []interface{}
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		want    interface{}
		wantErr bool
	}{
		{
			name: "destination unreachable",
			fields: fields{opt: &GnmiTransportOptions{
				Config: gnmi.Config{
					Addr: "203.0.113.10:6030",
				},
			},
			},
			args: args{
				ctx:    context.Background(),
				params: []interface{}{&gnmi.Operation{}},
			},
			want:    nil,
			wantErr: true,
		},
		{
			name:   "valid update",
			fields: fields{opt: opt},
			args: args{
				ctx: context.Background(),
				params: []interface{}{
					&gnmi.Operation{
						Type:   "update",
						Origin: "",
						Target: "",
						Path: []string{
							"system",
							"config",
							"hostname",
						},
						Val: "ceos3000",
					},
				},
			},
			want:    gnmiMessages["../test/resp-set-system-config-hostname"],
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			g, err := NewGnmiTransport(tt.fields.opt)
			if err != nil {
				t.Errorf("NewGnmiTransport() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			got, err := g.Set(tt.args.ctx, tt.args.params...)
			if tt.want != nil {
				tt.want.(*gpb.SetResponse).Timestamp = got.(*gpb.SetResponse).Timestamp
			}
			if (err != nil) != tt.wantErr {
				t.Errorf("Set() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if err != nil && tt.wantErr {
				return
			} else if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("Set() got = %v, want %v", got, tt.want)
			}
		})
	}
}
func TestGnmi_GetIntegration(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test")
	}
	t.Run("Test GNMI Get", func(t *testing.T) {
		transport, err := NewGnmiTransport(opt)
		if err != nil {
			t.Error(err)
		}
		p := []string{"/interfaces/interface"}
		resp, err := transport.Get(context.Background(), p...)
		if err != nil {
			t.Error(err)
		}
		if resp == nil {
			t.Error("resp is nil")
		}
	})
}

func TestGnmi_SubscribeIntegration(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test")
	}
	if os.Getenv("GOSDN_TEST_ENDPOINT") != "" {
		t.Skip("skipping locally running integration test")
	}

	t.Run("Test GNMI Subscribe", func(t *testing.T) {
		transport, err := NewGnmiTransport(opt)
		if err != nil {
			t.Error(err)
		}
		transport.RespChan = make(chan *gpb.SubscribeResponse)

		paths := []string{"/interfaces/interface/name"}

		opts := &gnmi.SubscribeOptions{
			UpdatesOnly:       false,
			Prefix:            "",
			Mode:              "stream",
			StreamMode:        "sample",
			SampleInterval:    uint64(10 * time.Second.Nanoseconds()),
			SuppressRedundant: false,
			HeartbeatInterval: uint64(time.Second.Nanoseconds()),
			Paths:             gnmi.SplitPaths(paths),
			Origin:            "",
			Target:            address,
		}
		ctx := context.WithValue(context.Background(), "opts", opts)
		go func() {
			if err := transport.Subscribe(ctx); err != nil {
				t.Error(err)
			}
		}()
		time.Sleep(time.Second * 30)
		ctx.Done()
		time.Sleep(time.Second * 5)
	})
}

func TestGnmi_CapabilitiesIntegration(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test")
	}
	type fields struct {
		opt *GnmiTransportOptions
	}
	type args struct {
		ctx context.Context
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		want    interface{}
		wantErr bool
	}{
		{
			name:    "supported models",
			fields:  fields{opt: opt},
			args:    args{ctx: context.Background()},
			want:    gnmiMessages["../test/cap-resp-arista-ceos"].(*gpb.CapabilityResponse).SupportedModels,
			wantErr: false,
		},
		{
			name:    "supported encodings",
			fields:  fields{opt: opt},
			args:    args{ctx: context.Background()},
			want:    gnmiMessages["../test/cap-resp-arista-ceos"].(*gpb.CapabilityResponse).SupportedEncodings,
			wantErr: false,
		},
		{
			name:    "gnmi version",
			fields:  fields{opt: opt},
			args:    args{ctx: context.Background()},
			want:    gnmiMessages["../test/cap-resp-arista-ceos"].(*gpb.CapabilityResponse).GNMIVersion,
			wantErr: false,
		},
		{
			name: "destination unreachable",
			fields: fields{opt: &GnmiTransportOptions{
				Config: gnmi.Config{
					Addr: "203.0.113.10:6030",
				},
			},
			},
			args:    args{ctx: context.Background()},
			want:    nil,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			g, err := NewGnmiTransport(tt.fields.opt)
			if err != nil {
				t.Error(err)
				return
			}
			resp, err := g.Capabilities(tt.args.ctx)
			if (err != nil) != tt.wantErr {
				t.Errorf("Capabilities() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			var got interface{}
			switch tt.name {
			case "supported encodings":
				got = resp.(*gpb.CapabilityResponse).SupportedEncodings
			case "supported models":
				got = resp.(*gpb.CapabilityResponse).SupportedModels
				sort.Slice(got.([]*gpb.ModelData), func(i, j int) bool {
					return got.([]*gpb.ModelData)[i].Name < got.([]*gpb.ModelData)[j].Name
				})
				sort.Slice(tt.want.([]*gpb.ModelData), func(i, j int) bool {
					return tt.want.([]*gpb.ModelData)[i].Name < tt.want.([]*gpb.ModelData)[j].Name
				})
			case "gnmi version":
				got = resp.(*gpb.CapabilityResponse).GNMIVersion
			default:
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("Type() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestPndImplementation_RequestAllIntegration(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test")
	}
	t.Fail()
}

func TestPndImplementation_RequestIntegration(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping integration test")
	}
	t.Fail()
}