principalNetworkDomain_test.go

		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)
			}
		})
	}

	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)
			}

			err := pnd.loadStoredDevices()
			if err != nil {
				t.Error(err)
			}

			dev, err := pnd.GetDevice(tt.args.name)
			if err != nil {
				t.Errorf("GetDevice() error = %v, want no err", err)
			}

			if dev.Name() != tt.args.name {
				t.Errorf("Device name is = %s, want %s", dev.Name(), tt.args.name)
			}
		})
	}
}

// TODO(mbauch): This test case looks unfinished. For example there are no
// cases for 'already exists' and 'fails wrong type'.
func Test_pndImplementation_AddDeviceWithUUID(t *testing.T) {
	type args struct {
		uuid   uuid.UUID
		device interface{}
		name   string
		opts   *tpb.TransportOption
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		{
			name: "default",
			args: args{
				uuid: did,
				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.AddDeviceFromStore(tt.args.name, tt.args.uuid, 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 d.ID() != tt.args.uuid {
						t.Errorf("AddDevice() got = %v, want %v", d.ID(), tt.args.uuid)
					}
					if err := pnd.devices.Delete(d.ID()); err != nil {
						t.Error(err)
					}
				}
			}
		})
	}
}

func Test_pndImplementation_saveGoStructsToFile(t *testing.T) {
	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 GenericGrpcClient
	}
	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,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			_, err := saveGenericClientStreamToFile(tt.args.client, "gostructs.go", tt.args.id)
			if (err != nil) != tt.wantErr {
				t.Errorf("saveGoStructsToFile() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}