principalNetworkDomain_test.go

package nucleus

import (
	"errors"
	"reflect"
	"testing"

	ppb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/pnd"
	tpb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/transport"
	"code.fbi.h-da.de/danet/gosdn/controller/conflict"
	"code.fbi.h-da.de/danet/gosdn/controller/customerrs"
	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/networkdomain"
	"code.fbi.h-da.de/danet/gosdn/controller/interfaces/plugin"
	"code.fbi.h-da.de/danet/gosdn/controller/mocks"
	"code.fbi.h-da.de/danet/gosdn/controller/store"
	"github.com/google/uuid"
	gpb "github.com/openconfig/gnmi/proto/gnmi"
	"github.com/stretchr/testify/mock"
)

func TestNewPND(t *testing.T) {
	p, err := newPnd()
	if err != nil {
		t.Fatal(err)
		return
	}

	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) {
			pluginService := NewPluginServiceMock()
			got, err := NewPND(tt.args.name, tt.args.description, tt.args.pid, nil, nil, pluginService, 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_pndImplementation_AddNetworkElement(t *testing.T) {
	type args struct {
		name            string
		opts            *tpb.TransportOption
		requestPluginFn func(uuid.UUID) (plugin.Plugin, error)
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "default",
			args: args{
				name: "fridolin",
				opts: &tpb.TransportOption{
					TransportOption: &tpb.TransportOption_GnmiTransportOption{
						GnmiTransportOption: &tpb.GnmiTransportOption{},
					},
				},
				requestPluginFn: func(u uuid.UUID) (plugin.Plugin, error) {
					mockPlugin := &mocks.Plugin{}
					mockPlugin.On("ID").Return(u)
					mockPlugin.On("Model", mock.Anything).Return([]byte("mockModel"), nil)
					return mockPlugin, nil
				},
			},
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			mockPlugin := &mocks.Plugin{}
			mockPlugin.On("ID").Return(defaultPluginID)
			mockPlugin.On("Model", mock.Anything).Return([]byte("mockModel"), nil)
			mockPlugin.On("Unmarshal", mock.Anything, mock.Anything).Return(nil)

			pnd, err := newPnd()
			if err != nil {
				t.Fatal(err)
			}
			err = pnd.pluginService.Add(mockPlugin)
			if err != nil {
				t.Fatal(err)
			}

			_, err = pnd.AddNetworkElement(tt.args.name, tt.args.opts, tt.args.requestPluginFn, defaultPluginID, defaultPndID)
			if (err != nil) != tt.wantErr {
				t.Errorf("AddNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
			}

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

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, err := newPnd()
			if err != nil {
				t.Errorf("GetDescription() = %v", err)
			}
			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, err := newPnd()
			if err != nil {
				t.Errorf("GetName() = %v", err)
			}
			if got := pnd.GetName(); got != tt.want {
				t.Errorf("GetName() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_pndImplementation_MarshalNetworkElement(t *testing.T) {
	type args struct {
		uuid uuid.UUID
	}
	tests := []struct {
		name    string
		args    args
		want    string
		wantErr bool
	}{
		{
			name:    "default",
			want:    "{\n\t\"Acl\": null,\n\t\"Bfd\": null,\n\t\"Components\": null,\n\t\"Interfaces\": null,\n\t\"Keychains\": null,\n\t\"Lldp\": null,\n\t\"Messages\": null,\n\t\"NetworkInstances\": null,\n\t\"RoutingPolicy\": null,\n\t\"System\": null\n}",
			args:    args{mdid},
			wantErr: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pnd, err := newPnd()
			if err != nil {
				t.Error(err)
			}

			mne := mockNetworkElement()

			_, err = pnd.addNetworkElement(mne)
			if err != nil {
				t.Error(err)
			}
			got, err := pnd.MarshalNetworkElement(tt.args.uuid.String())
			if (err != nil) != tt.wantErr {
				t.Errorf("MarshalNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got != tt.want {
				t.Errorf("MarshalNetworkElement() got = %v, want %v", got, tt.want)
			}
			if err := pnd.networkElementService.Delete(mne); err != nil {
				t.Error(err)
			}
		})
	}
}

func Test_pndImplementation_RemoveNetworkElement(t *testing.T) {
	type args struct {
		uuid                 uuid.UUID
		networkElementLength int
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{name: "default", args: args{uuid: mdid, networkElementLength: 0}, wantErr: false},
		{name: "fails", args: args{uuid: uuid.New(), networkElementLength: 1}, wantErr: true},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			pnd, err := newPnd()
			if err != nil {
				t.Error(err)
			}

			mne := mockNetworkElement()

			_, err = pnd.addNetworkElement(mne)
			if err != nil {
				t.Error(err)
			}
			if err := pnd.RemoveNetworkElement(tt.args.uuid); (err != nil) != tt.wantErr {
				t.Errorf("RemoveNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
			}
			ne, err := pnd.networkElementService.GetAll()
			if err != nil {
				t.Errorf("RemoveNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
			}
			if len(ne) != tt.args.networkElementLength {
				t.Errorf("RemoveNetworkElement() error = length of network is: %v, want: %v", len(ne), tt.args.networkElementLength)
			}
		})
	}
}

func Test_pndImplementation_Request(t *testing.T) {
	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: mneid,
				path: "",
				rErr: errors.New("deliberate test fail"),
			},
			wantErr: true,
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			pluginService := NewPluginServiceMock()
			networkElementService := NewNetworkElementServiceMock()

			pnd := pndImplementation{
				Name:                  "default",
				Description:           "default test pnd",
				pluginService:         pluginService,
				networkElementService: networkElementService,
				changes:               store.NewChangeStore(),
				Id:                    defaultPndID,
			}

			transport := mocks.Transport{}
			transport.On("Get", mockContext, mock.Anything).Return(&gpb.GetResponse{}, tt.args.rErr)
			transport.On("ProcessResponse", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.rErr)

			networkElementWithMockTransport := &CommonNetworkElement{
				UUID:      mdid,
				Plugin:    mockPlugin(t),
				transport: &transport,
			}

			_, _ = pnd.addNetworkElement(networkElementWithMockTransport)

			_, err := pnd.Request(tt.args.uuid, tt.args.path)
			if (err != nil) != tt.wantErr {
				t.Errorf("Request() error = %v, wantErr %v", err, tt.wantErr)
			}

			mne, _ := pnd.networkElementService.Get(store.Query{ID: mdid})
			if mne == nil {
				return
			}
			if err := pnd.networkElementService.Delete(mne); err != nil {
				t.Error(err)
			}
		})
	}
}

func Test_pndImplementation_RequestAll(t *testing.T) {
	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: mneid,
				path: "",
				rErr: errors.New("deliberate test fail"),
			},
			wantErr: true,
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			pluginService := NewPluginServiceMock()
			networkElementService := NewNetworkElementServiceMock()

			pnd := pndImplementation{
				Name:                  "default",
				Description:           "default test pnd",
				pluginService:         pluginService,
				networkElementService: networkElementService,
				changes:               store.NewChangeStore(),
				Id:                    defaultPndID,
			}

			transport := mocks.Transport{}
			transport.On("Get", mockContext, mock.Anything).Return(&gpb.GetResponse{}, tt.args.rErr)
			transport.On("ProcessResponse", mock.Anything, mock.Anything, mock.Anything).Return(tt.args.rErr)

			networkElementWithMockTransport := &CommonNetworkElement{
				UUID:      mdid,
				Plugin:    mockPlugin(t),
				transport: &transport,
			}

			_, _ = pnd.addNetworkElement(networkElementWithMockTransport)

			mne, _ := pnd.networkElementService.Get(store.Query{ID: mdid})
			if mne == nil {
				return
			}
			if err := pnd.networkElementService.Delete(mne); err != nil {
				t.Error(err)
			}
		})
	}
}

//func Test_pndImplementation_ChangeMNE(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_API_OPERATION_UPDATE,
//				path:      "/system/config/hostname",
//				value:     []string{"ceos3000"},
//			},
//			wantErr: false,
//		},
//		{
//			name: "replace",
//			args: args{
//				operation: ppb.ApiOperation_API_OPERATION_REPLACE,
//				path:      "/system/config/hostname",
//				value:     []string{"ceos3000"},
//			},
//			wantErr: false,
//		},
//		{
//			name: "delete",
//			args: args{
//				operation: ppb.ApiOperation_API_OPERATION_DELETE,
//				path:      "/system/config/hostname",
//			},
//			wantErr: false,
//		},
//		{
//			name: "delete w/args",
//			args: args{
//				operation: ppb.ApiOperation_API_OPERATION_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_API_OPERATION_UPDATE,
//				path:      "/system/config/hostname",
//				value:     []string{"ceos3000", "ceos3001"},
//			},
//			wantErr: true,
//		},
//		{
//			name: "invalid arg count - update, no args",
//			args: args{
//				operation: ppb.ApiOperation_API_OPERATION_UPDATE,
//				path:      "/system/config/hostname",
//			},
//			wantErr: true,
//		},
//		{
//			name: "invalid arg count - replace, no args",
//			args: args{
//				operation: ppb.ApiOperation_API_OPERATION_UPDATE,
//				path:      "/system/config/hostname",
//			},
//			wantErr: true,
//		},
//		{
//			name: "network element not found",
//			args: args{
//				operation: ppb.ApiOperation_API_OPERATION_UPDATE,
//			},
//			wantErr: true,
//		},
//	}
//	for _, tt := range tests {
//		tt := tt
//		t.Run(tt.name, func(t *testing.T) {
//			t.Parallel()
//			pnd := newPnd()
//			_, err := pnd.AddNetworkElement("testnetworkElement", opts, defaultSbiID)
//			if err != nil {
//				t.Error(err)
//				return
//			}
//
//			networkElements, err := pnd.networkElementService.GetAllAsLoaded()
//			if err != nil {
//				err := errors.New("error fetching network element")
//				t.Error(err)
//				return
//			}
//
//			neUUID, err := uuid.Parse(networkElements[0].ID)
//			if err != nil {
//				err := errors.New("error parsing network element uuid")
//				t.Error(err)
//				return
//			}
//
//			_, err = pnd.ChangeMNE(neUUID, tt.args.operation, tt.args.path, tt.args.value...)
//			if (err != nil) != tt.wantErr {
//				t.Errorf("ChangeMNE() error = %v, wantErr %v", err, tt.wantErr)
//				return
//			}
//			if !tt.wantErr {
//				if len(pnd.changes.Store) != 1 {
//					t.Errorf("ChangeMNE() unexpected change count. got %v, want 1", len(pnd.changes.Store))
//				}
//			}
//		})
//	}
//}

func Test_pndImplementation_GetNetworkElement(t *testing.T) {
	pnd, err := newPnd()
	if err != nil {
		t.Error(err)
		return
	}

	mne := mockNetworkElement()
	_, err = pnd.addNetworkElement(mne)
	if err != nil {
		t.Error(err)
		return
	}

	mPlugin, ok := mockPlugin(t).(plugin.Plugin)
	if !ok {
		t.Errorf("GetNetworkElement(), failed type conversion -> %v", &customerrs.InvalidTypeAssertionError{
			Value: mockPlugin(t),
			Type:  (*plugin.Plugin)(nil),
		})
		return
	}
	pluginModel, err := mPlugin.Model(false)
	if err != nil {
		t.Error(err)
		return
	}

	type args struct {
		uuid uuid.UUID
	}
	tests := []struct {
		name    string
		args    args
		want    []byte
		wantErr bool
	}{
		{
			name:    "default",
			args:    args{uuid: mdid},
			want:    pluginModel,
			wantErr: false,
		},
		{
			name:    "network element not found",
			args:    args{uuid: mneid},
			want:    nil,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			foundNetworkElement, err := pnd.GetNetworkElement(tt.args.uuid.String())
			if (err != nil) != tt.wantErr {
				t.Errorf("GetNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if foundNetworkElement != nil {
				model, err := foundNetworkElement.GetModel()
				if err != nil {
					t.Errorf("GetNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
				}
				if !reflect.DeepEqual(model, tt.want) {
					t.Errorf("GetNetworkElement() got = %v, want %v", model, tt.want)
				}
			}
		})
	}
}

func Test_pndImplementation_GetNetworkElementByName(t *testing.T) {
	opts := &tpb.TransportOption{
		Address:  "",
		Username: "test",
		Password: "test",
		TransportOption: &tpb.TransportOption_GnmiTransportOption{
			GnmiTransportOption: &tpb.GnmiTransportOption{},
		},
	}

	pnd, err := newPnd()
	if err != nil {
		t.Error(err)
		return
	}
	mockPlugin := mockPlugin(t)
	pluginModel, err := mockPlugin.Model(false)
	if err != nil {
		t.Error(err)
		return
	}
	mne, err := NewNetworkElement("my-mne", mneid, opts, mockPlugin, conflict.Metadata{ResourceVersion: 0})
	if err != nil {
		t.Error(err)
		return
	}
	_, err = pnd.addNetworkElement(mne)
	if err != nil {
		t.Error(err)
		return
	}
	type args struct {
		name string
	}
	tests := []struct {
		name    string
		args    args
		want    []byte
		wantErr bool
	}{
		{
			name:    "default",
			args:    args{name: mne.Name()},
			want:    pluginModel,
			wantErr: false,
		},
		{
			name:    "network element not found",
			args:    args{name: "test-mne"},
			want:    nil,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			foundNetworkElement, err := pnd.GetNetworkElement(tt.args.name)
			if (err != nil) != tt.wantErr {
				t.Errorf("GetNetworkElementByName() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if foundNetworkElement != nil {
				model, err := foundNetworkElement.GetModel()
				if err != nil {
					t.Errorf("GetNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
				}
				if !reflect.DeepEqual(model, tt.want) {
					t.Errorf("GetNetworkElementByName() got = %v, want %v", model, tt.want)
				}
			}
		})
	}
}

func Test_pndImplementation_Confirm(t *testing.T) {
	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) {
			pluginService := NewPluginServiceMock()
			networkElementService := NewNetworkElementServiceMock()

			pnd := pndImplementation{
				Name:                  "default",
				Description:           "default test pnd",
				pluginService:         pluginService,
				networkElementService: networkElementService,
				changes:               store.NewChangeStore(),
				Id:                    defaultPndID,
			}

			mne := mockNetworkElement()
			mockPlugin, ok := mne.GetPlugin().(*mocks.Plugin)
			if !ok {
				t.Errorf("Confirm(), failed type conversion -> %v", &customerrs.InvalidTypeAssertionError{
					Value: mne.GetPlugin(),
					Type:  (*mocks.Plugin)(nil),
				})
				return
			}
			mockPlugin.On("ValidateChange", mock.Anything, mock.Anything, mock.Anything).Return([]byte{}, nil)
			mockPlugin.On("PruneConfigFalse", mock.Anything).Return([]byte{}, nil)
			mockPlugin.On("Diff", mock.Anything, mock.Anything, mock.Anything).Return(&gpb.Notification{}, nil)
			tr, ok := mne.Transport().(*mocks.Transport)
			if !ok {
				t.Errorf("Confirm(), failed type conversion -> %v", &customerrs.InvalidTypeAssertionError{
					Value: mne.Transport(),
					Type:  (*mocks.Transport)(nil),
				})
				return
			}

			tr.On("Set", mockContext, mock.Anything, mock.Anything, mock.Anything).Return(nil)
			_, err := pnd.addNetworkElement(mne)
			if err != nil {
				t.Error(err)
				return
			}
			u, err := pnd.ChangeMNE(mne.ID(), ppb.ApiOperation_API_OPERATION_UPDATE, "system/config/hostname", "ceos3000")
			if err != nil {
				t.Error(err)
				return
			}
			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(mneid, &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(mneid, &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(mneid, &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_saveStreamToFile(t *testing.T) {
//	defer removeTestGoStructs()
//
//	type genericGoStructClientArg struct {
//		fn    string
//		rtrn  []interface{}
//		times int
//	}
//	// Create a new mock for GenericGoStructClient. With
//	// genericGoStructClientArg it is possible to set the Return values of the
//	// mocks methods.
//	newGenericGoStructClient := func(args ...genericGoStructClientArg) *mocks.GenericGoStructClient {
//		ggsc := &mocks.GenericGoStructClient{}
//		for _, arg := range args {
//			ggsc.On(arg.fn).Return(arg.rtrn...).Times(arg.times)
//		}
//		ggsc.On("CloseSend").Return(nil)
//		return ggsc
//	}
//
//	type args struct {
//		id     uuid.UUID
//		client StreamClient
//	}
//	tests := []struct {
//		name    string
//		args    args
//		wantErr bool
//	}{
//		{
//			name: "default",
//			args: args{
//				id: uuid.New(),
//				client: newGenericGoStructClient(
//					[]genericGoStructClientArg{
//						{
//							fn: "Recv",
//							rtrn: []interface{}{
//								&csbi.Payload{Chunk: []byte("test")},
//								nil,
//							},
//							times: 3,
//						},
//						{
//							fn: "Recv",
//							rtrn: []interface{}{
//								&csbi.Payload{Chunk: nil},
//								io.EOF,
//							},
//							times: 1,
//						},
//					}...),
//			},
//			wantErr: false,
//		},
//		{
//			name: "unexpected EOF error",
//			args: args{
//				id: uuid.New(),
//				client: newGenericGoStructClient(
//					[]genericGoStructClientArg{
//						{
//							fn: "Recv",
//							rtrn: []interface{}{
//								&csbi.Payload{Chunk: nil},
//								io.ErrUnexpectedEOF,
//							},
//							times: 1,
//						},
//						{
//							fn: "CloseSend",
//							rtrn: []interface{}{
//								nil,
//							},
//							times: 1,
//						},
//					}...),
//			},
//			wantErr: true,
//		},
//	}
//	var wg sync.WaitGroup
//	for _, tt := range tests {
//		wg.Add(1)
//		tt := tt
//
//		// waitgroup and extra func needed to be able to clean up generated pnd directories while running test cases in parallel mode,
//		// var x is just a dummy to be able to call the func,
//		// outer t.Run() required for defered wg.Done().
//		// reference: https://stackoverflow.com/a/63609718
//		x := func() {
//			defer wg.Done()
//			t.Run("parallel waiting func", func(t *testing.T) {
//				t.Run(tt.name, func(t *testing.T) {
//					t.Parallel()
//					err := saveStreamToFile(tt.args.client, util.GoStructName, tt.args.id)
//					if (err != nil) != tt.wantErr {
//						t.Errorf("saveGoStructsToFile() error = %v, wantErr %v", err, tt.wantErr)
//					}
//				})
//			})
//		}
//		x()
//	}
//	wg.Wait()
//}