principalNetworkDomain_test.go

package nucleus

import (
	"errors"
	"fmt"
	"os"
	"reflect"
	"testing"

	ppb "code.fbi.h-da.de/danet/api/go/gosdn/pnd"
	spb "code.fbi.h-da.de/danet/api/go/gosdn/southbound"
	tpb "code.fbi.h-da.de/danet/api/go/gosdn/transport"
	"code.fbi.h-da.de/danet/gosdn/interfaces/device"
	"code.fbi.h-da.de/danet/gosdn/interfaces/networkdomain"
	"code.fbi.h-da.de/danet/gosdn/interfaces/southbound"
	"code.fbi.h-da.de/danet/gosdn/mocks"
	"code.fbi.h-da.de/danet/gosdn/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 removeExistingPNDStore() {
	os.Remove(fmt.Sprintf("stores/device-store-%s.json", defaultPndID))
}

func TestNewPND(t *testing.T) {
	removeExistingPNDStore()

	p := newPnd()
	if err := p.addSbi(&OpenConfig{id: defaultSbiID}); err != nil {
		t.Error(err)
	}
	type args struct {
		name        string
		description string
		sbi         southbound.SouthboundInterface
		pid         uuid.UUID
	}
	tests := []struct {
		name    string
		args    args
		want    networkdomain.NetworkDomain
		wantErr bool
	}{
		{
			name: "default",
			args: args{
				name:        "default",
				description: "default test pnd",
				sbi:         &OpenConfig{id: defaultSbiID},
				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, tt.args.sbi, nil, nil)
			if (err != nil) != tt.wantErr {
				t.Errorf("NewPND() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("NewPND() = %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)
			}
			if tt.name == "already exists" {
				pnd.devices.Store[did] = tt.args.device.(device.Device)
			}
			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.GetDevice(store.FromString(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.ID()); 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()
			if tt.name == "already exists" {
				pnd.sbic.Store[defaultSbiID] = tt.args.sbi
			}
			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 {
					_, ok := pnd.sbic.Store[defaultSbiID]
					if !ok {
						t.Errorf("AddSbi() SBI %v not in device store %v",
							tt.args.sbi, pnd.GetSBIs())
					}
					if err := pnd.sbic.Delete(defaultSbiID); err != nil {
						t.Error(err)
					}
				}
			}
		})
	}
}

func Test_pndImplementation_ContainsDevice(t *testing.T) {
	removeExistingPNDStore()

	type args struct {
		uuid   uuid.UUID
		device device.Device
	}
	tests := []struct {
		name string
		args args
		want bool
	}{
		{name: "default", args: args{
			uuid:   did,
			device: &CommonDevice{UUID: did},
		}, want: true},
		{name: "fails", args: args{
			uuid:   uuid.New(),
			device: &CommonDevice{UUID: did},
		}, want: false},
		{name: "fails empty", args: args{
			uuid:   uuid.New(),
			device: &CommonDevice{UUID: did},
		}, want: false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pnd := newPnd()
			if tt.name != "fails empty" {
				if err := pnd.devices.Add(tt.args.device, "test"); err != nil {
					t.Error(err)
				}
			}
			if got := pnd.ContainsDevice(tt.args.uuid); got != tt.want {
				t.Errorf("ContainsDevice() = %v, want %v", got, tt.want)
			}
			if err := pnd.devices.Delete(did); err != nil && tt.name != "fails empty" {
				t.Error(err)
			}
		})
	}
}

func Test_pndImplementation_Destroy(t *testing.T) {
	type fields struct {
		name        string
		description string
		sbi         *store.SbiStore
		devices     *store.DeviceStore
	}
	tests := []struct {
		name    string
		fields  fields
		wantErr bool
	}{
		{name: "dummy", fields: fields{}, wantErr: false},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pnd := &pndImplementation{
				Name:        tt.fields.name,
				Description: tt.fields.description,
				sbic:        tt.fields.sbi,
				devices:     tt.fields.devices,
			}
			if err := pnd.Destroy(); (err != nil) != tt.wantErr {
				t.Errorf("Destroy() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func Test_pndImplementation_GetDescription(t *testing.T) {
	tests := []struct {
		name string
		want string
	}{
		{name: "default", want: "default test pnd"},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pnd := newPnd()
			if got := pnd.GetDescription(); got != tt.want {
				t.Errorf("GetDescription() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_pndImplementation_GetName(t *testing.T) {
	tests := []struct {
		name string
		want string
	}{
		{name: "default", want: "default"},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pnd := newPnd()
			if got := pnd.GetName(); got != tt.want {
				t.Errorf("GetName() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_pndImplementation_GetSBIs(t *testing.T) {
	pnd := newPnd()
	tests := []struct {
		name string
		want *store.SbiStore
	}{
		{name: "default", want: pnd.sbic},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := pnd.GetSBIs(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("GetSBIs() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_pndImplementation_MarshalDevice(t *testing.T) {
	removeExistingPNDStore()

	type args struct {
		uuid uuid.UUID
	}
	tests := []struct {
		name    string
		args    args
		want    string
		wantErr bool
	}{
		{
			name:    "default",
			args:    args{did},
			want:    "{\n\t\"Acl\": null,\n\t\"Bgp\": null,\n\t\"Components\": null,\n\t\"Interfaces\": null,\n\t\"LocalRoutes\": null,\n\t\"Messages\": null,\n\t\"NetworkInstances\": null,\n\t\"RoutingPolicy\": null,\n\t\"System\": null\n}",
			wantErr: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pnd := newPnd()
			d := &CommonDevice{
				UUID:      tt.args.uuid,
				GoStruct:  &openconfig.Device{},
				sbi:       nil,
				transport: nil,
			}
			if err := pnd.addDevice(d); err != nil {
				t.Error(err)
			}
			got, err := pnd.MarshalDevice(tt.args.uuid.String())
			if (err != nil) != tt.wantErr {
				t.Errorf("MarshalDevice() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got != tt.want {
				t.Errorf("MarshalDevice() got = %v, want %v", got, tt.want)
			}
			if err := pnd.devices.Delete(did); err != nil {
				t.Error(err)
			}
		})
	}
}

func Test_pndImplementation_RemoveDevice(t *testing.T) {
	removeExistingPNDStore()

	type args struct {
		uuid uuid.UUID
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{name: "default", args: args{uuid: did}, wantErr: false},
		{name: "fails", args: args{uuid: uuid.New()}, wantErr: true},
		{name: "fails empty", args: args{uuid: did}, wantErr: true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pnd := newPnd()
			if tt.name != "fails empty" {
				d := &CommonDevice{
					UUID: did,
					sbi:  NewSBI(spb.Type_OPENCONFIG),
				}
				if err := pnd.addDevice(d); err != nil {
					t.Error(err)
				}
			}
			if err := pnd.RemoveDevice(tt.args.uuid); (err != nil) != tt.wantErr {
				t.Errorf("RemoveDevice() error = %v, wantErr %v", err, tt.wantErr)
			}
			if pnd.devices.Exists(did) && tt.name == "default" {
				t.Errorf("RemoveDevice() device still in device store %v", pnd.devices)
			}
		})
	}
}

func Test_pndImplementation_RemoveSbi(t *testing.T) {
	opts := &tpb.TransportOption{
		TransportOption: &tpb.TransportOption_GnmiTransportOption{
			GnmiTransportOption: &tpb.GnmiTransportOption{},
		},
	}
	type args struct {
		id uuid.UUID
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{name: "default", args: args{id: defaultSbiID}, wantErr: false},
		{name: "fails", args: args{id: uuid.New()}, wantErr: true},
		{name: "fails empty", args: args{id: defaultSbiID}, wantErr: true},
		{name: "exclusively remove associated devices", args: args{id: defaultSbiID}, wantErr: false},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pnd := &pndImplementation{
				Name:        "test-remove-sbi",
				Description: "test-remove-sbi",
				sbic:        store.NewSbiStore(),
				devices:     store.NewDeviceStore(defaultPndID),
				Id:          defaultPndID,
			}
			if tt.name != "fails empty" && tt.name != "fails" {
				if err := pnd.addSbi(&OpenConfig{id: defaultSbiID}); err != nil {
					t.Error(err)
				}
				if err := pnd.AddDevice("associatedDevice", opts, tt.args.id); err != nil {
					t.Error(err)
				}
				if err := pnd.AddDevice("associatedDevice2", opts, tt.args.id); err != nil {
					t.Error(err)
				}
				if tt.name == "exclusively remove associated devices" {
					newID := uuid.New()
					if err := pnd.addSbi(&OpenConfig{id: newID}); err != nil {
						t.Error(err)
					}
					if err := pnd.AddDevice("associatedDevice2", opts, newID); err != nil {
						t.Error(err)
					}
				}
			}

			if err := pnd.RemoveSbi(tt.args.id); (err != nil) != tt.wantErr {
				t.Errorf("RemoveSbi() error = %v, wantErr %v", err, tt.wantErr)
			}
			if pnd.sbic.Exists(tt.args.id) {
				t.Errorf("RemoveSbi() SBI still in SBI store %v", pnd.sbic)
			}

			if tt.name == "exclusively remove associated devices" {
				if len(pnd.devices.Store) != 1 {
					t.Errorf("RemoveSbi() non associated devices should remain in the storage %v", pnd.devices)
				}
			} else {
				if len(pnd.devices.Store) != 0 {
					t.Errorf("RemoveSbi() associated devices have not been removed correctly %v", len(pnd.devices.Store))
				}
			}
		})
	}
}

func Test_pndImplementation_Request(t *testing.T) {
	removeExistingPNDStore()

	type args struct {
		uuid uuid.UUID
		path string
		rErr error
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "default",
			args: args{
				uuid: mdid,
				path: "",
				rErr: nil,
			},
			wantErr: false,
		},
		{
			name: "error",
			args: args{
				uuid: did,
				path: "",
				rErr: errors.New("deliberate test fail"),
			},
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			deviceWithMockTransport := mockDevice()
			pnd := newPnd()
			tr := deviceWithMockTransport.Transport().(*mocks.Transport)
			tr.On("Get", mockContext, mock.Anything).Return(&gpb.GetResponse{}, tt.args.rErr)
			tr.On("ProcessResponse", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.rErr)
			_ = pnd.addDevice(deviceWithMockTransport)
			_, err := pnd.Request(tt.args.uuid, tt.args.path)
			if (err != nil) != tt.wantErr {
				t.Errorf("Request() error = %v, wantErr %v", err, tt.wantErr)
			}
			if err := pnd.devices.Delete(mdid); err != nil {
				t.Error(err)
			}
		})
	}
}

func Test_pndImplementation_RequestAll(t *testing.T) {
	removeExistingPNDStore()

	type args struct {
		uuid uuid.UUID
		path string
		rErr error
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "default",
			args: args{
				uuid: mdid,
				path: "",
				rErr: nil,
			},
			wantErr: false,
		},
		{
			name: "error",
			args: args{
				uuid: did,
				path: "",
				rErr: errors.New("deliberate test fail"),
			},
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			deviceWithMockTransport := mockDevice()
			pnd := newPnd()
			tr := deviceWithMockTransport.Transport().(*mocks.Transport)
			tr.On("Get", mockContext, mock.Anything).Return(&gpb.GetResponse{}, tt.args.rErr)
			tr.On("ProcessResponse", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.rErr)
			_ = pnd.addDevice(deviceWithMockTransport)
			if err := pnd.RequestAll(tt.args.path); (err != nil) != tt.wantErr {
				t.Errorf("RequestAll() error = %v, wantErr %v", err, tt.wantErr)
			}
			if err := pnd.devices.Delete(mdid); err != nil {
				t.Error(err)
			}
		})
	}
}

func Test_pndImplementation_ChangeOND(t *testing.T) {
	opts := &tpb.TransportOption{
		TransportOption: &tpb.TransportOption_GnmiTransportOption{
			GnmiTransportOption: &tpb.GnmiTransportOption{},
		},
	}
	type args struct {
		operation ppb.ApiOperation
		path      string
		value     []string
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "update",
			args: args{
				operation: ppb.ApiOperation_UPDATE,
				path:      "/system/config/hostname",
				value:     []string{"ceos3000"},
			},
			wantErr: false,
		},
		{
			name: "replace",
			args: args{
				operation: ppb.ApiOperation_REPLACE,
				path:      "/system/config/hostname",
				value:     []string{"ceos3000"},
			},
			wantErr: false,
		},
		{
			name: "delete",
			args: args{
				operation: ppb.ApiOperation_DELETE,
				path:      "/system/config/hostname",
			},
			wantErr: false,
		},
		{
			name: "delete w/args",
			args: args{
				operation: ppb.ApiOperation_DELETE,
				path:      "/system/config/hostname",
				value:     []string{"ceos3000"},
			},
			wantErr: false,
		},

		// Negative test cases
		{
			name: "invalid operation",
			args: args{
				operation: 54,
			},
			wantErr: true,
		},
		{
			name: "invalid arg count",
			args: args{
				operation: ppb.ApiOperation_UPDATE,
				path:      "/system/config/hostname",
				value:     []string{"ceos3000", "ceos3001"},
			},
			wantErr: true,
		},
		{
			name: "invalid arg count - update, no args",
			args: args{
				operation: ppb.ApiOperation_UPDATE,
				path:      "/system/config/hostname",
			},
			wantErr: true,
		},
		{
			name: "invalid arg count - replace, no args",
			args: args{
				operation: ppb.ApiOperation_UPDATE,
				path:      "/system/config/hostname",
			},
			wantErr: true,
		},
		{
			name: "device not found",
			args: args{
				operation: ppb.ApiOperation_UPDATE,
			},
			wantErr: true,
		},
	}
	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)
			}
			if err := pnd.AddDevice("testdevice", opts, defaultSbiID); err != nil {
				t.Error(err)
				return
			}

			did, ok := pnd.devices.DeviceNameToUUIDLookup["testdevice"]
			if !ok {
				err := errors.New("error fetching device")
				t.Error(err)
				return
			}

			_, err := pnd.ChangeOND(did, tt.args.operation, tt.args.path, tt.args.value...)
			if (err != nil) != tt.wantErr {
				t.Errorf("ChangeOND() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !tt.wantErr {
				if len(pnd.changes.Store) != 1 {
					t.Errorf("ChangeOND() unexpected change count. got %v, want 1", len(pnd.changes.Store))
				}
			}
		})
	}
}

func Test_pndImplementation_GetDevice(t *testing.T) {
	pnd := newPnd()
	sbi := NewSBI(spb.Type_OPENCONFIG)
	d, err := NewDevice("", uuid.Nil, newGnmiTransportOptions(), sbi)
	if err != nil {
		t.Error(err)
		return
	}
	if err = pnd.addDevice(d); err != nil {
		t.Error(err)
		return
	}
	type args struct {
		uuid uuid.UUID
	}
	tests := []struct {
		name    string
		args    args
		want    ygot.GoStruct
		wantErr bool
	}{
		{
			name:    "default",
			args:    args{uuid: d.ID()},
			want:    sbi.Schema().Root,
			wantErr: false,
		},
		{
			name:    "device not found",
			args:    args{uuid: mdid},
			want:    nil,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			foundDevice, err := pnd.GetDevice(tt.args.uuid.String())
			if (err != nil) != tt.wantErr {
				t.Errorf("GetDevice() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if foundDevice != nil {
				if !reflect.DeepEqual(foundDevice.(device.Device).Model(), tt.want) {
					t.Errorf("GetDevice() got = %v, want %v", foundDevice.(device.Device).Model(), tt.want)
				}
			}
		})
	}
}

func Test_pndImplementation_GetDeviceByName(t *testing.T) {
	p := newPnd()
	sbi := NewSBI(spb.Type_OPENCONFIG)
	d, err := NewDevice("my-device", uuid.Nil, newGnmiTransportOptions(), sbi)
	if err != nil {
		t.Error(err)
		return
	}
	if err = p.addDevice(d); err != nil {
		t.Error(err)
		return
	}
	type args struct {
		name string
	}
	tests := []struct {
		name    string
		args    args
		want    ygot.GoStruct
		wantErr bool
	}{
		{
			name:    "default",
			args:    args{name: d.Name()},
			want:    sbi.Schema().Root,
			wantErr: false,
		},
		{
			name:    "device not found",
			args:    args{name: "test-device"},
			want:    nil,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			foundDevice, err := p.GetDevice(tt.args.name)
			if (err != nil) != tt.wantErr {
				t.Errorf("GetDeviceByName() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if foundDevice != nil {
				if !reflect.DeepEqual(foundDevice.(device.Device).Model(), tt.want) {
					t.Errorf("GetDeviceByName() got = %v, want %v", foundDevice.(device.Device).Model(), tt.want)
				}
			}
		})
	}
}

func Test_pndImplementation_Confirm(t *testing.T) {
	removeExistingPNDStore()

	tests := []struct {
		name    string
		wantErr bool
	}{
		{
			name:    "default",
			wantErr: false,
		},
		{
			name:    "uncommitted",
			wantErr: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pnd := newPnd()
			d := mockDevice()
			tr := d.Transport().(*mocks.Transport)
			tr.On("Set", mockContext, mock.Anything, mock.Anything).Return(nil)
			if err := pnd.addDevice(d); err != nil {
				t.Error(err)
				return
			}
			_, err := pnd.ChangeOND(d.ID(), ppb.ApiOperation_UPDATE, "system/config/hostname", "ceos3000")
			if err != nil {
				t.Error(err)
				return
			}
			u := pnd.PendingChanges()[0]
			if tt.name != "uncommitted" {
				if err := pnd.Commit(u); (err != nil) != tt.wantErr {
					t.Errorf("Confirm() error = %v, wantErr %v", err, tt.wantErr)
					return
				}
			}
			if err := pnd.Confirm(u); (err != nil) != tt.wantErr {
				t.Errorf("Confirm() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func Test_pndImplementation_PendingChanges(t *testing.T) {
	testName := t.Name()
	callback := func(first ygot.GoStruct, second ygot.GoStruct) error {
		log.Infof("callback in test %v", testName)
		return nil
	}

	store := store.NewChangeStore()
	pending := NewChange(did, &openconfig.Device{}, &openconfig.Device{}, callback)
	if err := store.Add(pending); err != nil {
		t.Error(err)
		return
	}
	tests := []struct {
		name string
		want []uuid.UUID
	}{
		{
			name: "default",
			want: []uuid.UUID{pending.cuid},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pnd := newPnd()
			pnd.changes = store
			if got := pnd.PendingChanges(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("pndImplementation.PendingChanges() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_pndImplementation_CommittedChanges(t *testing.T) {
	testName := t.Name()
	callback := func(first ygot.GoStruct, second ygot.GoStruct) error {
		log.Infof("callback in test %v", testName)
		return nil
	}

	store := store.NewChangeStore()
	committed := NewChange(did, &openconfig.Device{}, &openconfig.Device{}, callback)
	if err := committed.Commit(); err != nil {
		t.Error(err)
		return
	}
	if err := store.Add(committed); err != nil {
		t.Error(err)
		return
	}
	tests := []struct {
		name string
		want []uuid.UUID
	}{
		{
			name: "default",
			want: []uuid.UUID{committed.cuid},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pnd := newPnd()
			pnd.changes = store
			if got := pnd.CommittedChanges(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("pndImplementation.CommittedChanges() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_pndImplementation_ConfirmedChanges(t *testing.T) {
	testName := t.Name()
	callback := func(first ygot.GoStruct, second ygot.GoStruct) error {
		log.Infof("callback in test %v", testName)
		return nil
	}
	store := store.NewChangeStore()
	confirmed := NewChange(did, &openconfig.Device{}, &openconfig.Device{}, callback)
	if err := confirmed.Commit(); err != nil {
		t.Error(err)
		return
	}
	if err := confirmed.Confirm(); err != nil {
		t.Error(err)
		return
	}
	if err := store.Add(confirmed); err != nil {
		t.Error(err)
		return
	}
	tests := []struct {
		name string
		want []uuid.UUID
	}{
		{
			name: "default",
			want: []uuid.UUID{confirmed.cuid},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pnd := newPnd()
			pnd.changes = store
			if got := pnd.ConfirmedChanges(); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("pndImplementation.ConfirmedChanges() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_pndImplementation_LoadStoredDevices(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)
			}
			if tt.name == "already exists" {
				pnd.devices.Store[did] = tt.args.device.(device.Device)
			}
			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)
			}