store_test.go

package nucleus

import (
	"code.fbi.h-da.de/cocsn/gosdn/mocks"
	"github.com/google/uuid"
	log "github.com/sirupsen/logrus"
	"reflect"
	"sort"
	"testing"
)

func testSetupStore() {
	var err error
	iid, err = uuid.Parse("8495a8ac-a1e8-418e-b787-10f5878b2690")
	altIid, err = uuid.Parse("edc5de93-2d15-4586-b2a7-fb1bc770986b")
	if err != nil {
		log.Fatal(err)
	}
}

var iid uuid.UUID
var altIid uuid.UUID

func Test_store_add(t *testing.T) {
	type args struct {
		item Storable
	}
	tests := []struct {
		name    string
		s       store
		args    args
		wantErr bool
	}{
		{
			name: "default",
			s:    store{},
			args: args{
				item: &mocks.Storable{},
			},
		},
		{
			name: "already exists",
			s: store{
				iid: &mocks.Storable{},
			},
			args: args{
				item: &mocks.Storable{},
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.args.item.(*mocks.Storable).On("Id").Return(iid)
			switch tt.name {
			case "already exixts":
				_ = tt.s.add(tt.args.item)
			default:
			}
			if err := tt.s.add(tt.args.item); (err != nil) != tt.wantErr {
				t.Errorf("add() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func Test_store_delete(t *testing.T) {
	type args struct {
		id uuid.UUID
	}
	tests := []struct {
		name    string
		s       store
		args    args
		wantErr bool
	}{
		{
			name: "default",
			s: store{
				iid: &mocks.Storable{},
			},
			args:    args{id: iid},
			wantErr: false,
		},
		{
			name:    "not found empty",
			s:       store{},
			args:    args{id: iid},
			wantErr: true,
		},
		{
			name: "not found",
			s: store{
				iid: &mocks.Storable{},
			},
			args:    args{id: altIid},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := tt.s.delete(tt.args.id); (err != nil) != tt.wantErr {
				t.Errorf("delete() error = %v, wantErr %v", err, tt.wantErr)
			}
			if tt.name == "default" {
				item, ok := tt.s[iid]
				if ok {
					t.Errorf("delete() item %v still in store %v", item, tt.s)
				}
			}
		})
	}
}

func Test_store_exists(t *testing.T) {
	type args struct {
		id uuid.UUID
	}
	tests := []struct {
		name string
		s    store
		args args
		want bool
	}{
		{
			name: "default",
			s: store{
				iid: &mocks.Storable{},
			},
			args: args{id: iid},
			want: true,
		},
		{
			name: "not found empty",
			s:    store{},
			args: args{id: iid},
			want: false,
		},
		{
			name: "not found",
			s: store{
				iid: &mocks.Storable{},
			},
			args: args{id: altIid},
			want: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := tt.s.exists(tt.args.id); got != tt.want {
				t.Errorf("exists() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_store_get(t *testing.T) {
	type args struct {
		id uuid.UUID
	}
	tests := []struct {
		name    string
		s       store
		args    args
		want    Storable
		wantErr bool
	}{
		{
			name: "exists",
			s: store{
				iid: &mocks.Storable{},
			},
			args:    args{id: iid},
			want:    &mocks.Storable{},
			wantErr: false,
		},
		{
			name: "not found",
			s: store{
				iid: &mocks.Storable{},
			},
			args:    args{id: altIid},
			want:    nil,
			wantErr: true,
		},
		{
			name:    "not found empty",
			s:       store{},
			args:    args{id: iid},
			want:    nil,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := tt.s.get(tt.args.id)
			if (err != nil) != tt.wantErr {
				t.Errorf("get() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("get() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_store_UUIDs(t *testing.T) {
	tests := []struct {
		name string
		s    store
		want []uuid.UUID
	}{
		{
			name: "default",
			s: store{
				iid:    &mocks.Storable{},
				altIid: &mocks.Storable{},
			},
			want: []uuid.UUID{iid, altIid},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			sort.Slice(tt.want, func(i, j int) bool {
				return tt.want[i].String() < tt.want[j].String()
			})
			got := tt.s.UUIDs()
			sort.Slice(got, func(i, j int) bool {
				return got[i].String() < got[j].String()
			})
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("UUIDs() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_sbiStore_get(t *testing.T) {
	type fields struct {
		store store
	}
	type args struct {
		id uuid.UUID
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		want    SouthboundInterface
		wantErr bool
	}{
		{
			name: "exists",
			fields: fields{
				store: store{
					defaultSbiId: &OpenConfig{id: defaultSbiId},
				},
			},
			args:    args{id: defaultSbiId},
			want:    &OpenConfig{id: defaultSbiId},
			wantErr: false,
		},
		{
			name: "fails",
			fields: fields{
				store: store{
					defaultSbiId: &OpenConfig{id: defaultSbiId},
				},
			},
			args:    args{id: iid},
			wantErr: true,
		},
		{
			name: "fails empty",
			fields: fields{
				store: store{},
			},
			args:    args{id: defaultSbiId},
			wantErr: true,
		},
		{
			name: "fails wrong type",
			fields: fields{
				store: store{
					did: &Device{
						Config: DeviceConfig{
							Uuid: did,
						},
					},
				},
			},
			args:    args{id: did},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			s := sbiStore{
				store: tt.fields.store,
			}
			got, err := s.get(tt.args.id)
			if (err != nil) != tt.wantErr {
				t.Errorf("get() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("get() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_pndStore_get(t *testing.T) {
	type fields struct {
		store store
	}
	type args struct {
		id uuid.UUID
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		want    PrincipalNetworkDomain
		wantErr bool
	}{
		{
			name: "exists",
			fields: fields{
				store: store{
					defaultPndId: &pndImplementation{id: defaultPndId},
				},
			},
			args:    args{id: defaultPndId},
			want:    &pndImplementation{id: defaultPndId},
			wantErr: false,
		},
		{
			name: "fails",
			fields: fields{
				store: store{
					defaultPndId: &pndImplementation{id: defaultPndId},
				},
			},
			args:    args{id: iid},
			wantErr: true,
		},
		{
			name: "fails empty",
			fields: fields{
				store: store{},
			},
			args:    args{id: defaultPndId},
			wantErr: true,
		},
		{
			name: "fails wrong type",
			fields: fields{
				store: store{
					did: &Device{
						Config: DeviceConfig{
							Uuid: did,
						},
					},
				},
			},
			args:    args{id: defaultPndId},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			s := pndStore{
				store: tt.fields.store,
			}
			got, err := s.get(tt.args.id)
			if (err != nil) != tt.wantErr {
				t.Errorf("get() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("get() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_deviceStore_get(t *testing.T) {
	type fields struct {
		store store
	}
	type args struct {
		id uuid.UUID
	}
	tests := []struct {
		name    string
		fields  fields
		args    args
		want    *Device
		wantErr bool
	}{
		{
			name: "exists",
			fields: fields{
				store: store{
					defaultPndId: &Device{Config: DeviceConfig{Uuid: did}}}},
			args: args{id: defaultPndId},
			want: &Device{
				Config: DeviceConfig{
					Uuid: did,
				},
			},
			wantErr: false,
		},
		{
			name: "fails",
			fields: fields{
				store: store{
					defaultPndId: &Device{Config: DeviceConfig{Uuid: did}}}},
			args:    args{id: iid},
			wantErr: true,
		},
		{
			name: "fails empty",
			fields: fields{
				store: store{},
			},
			args:    args{id: defaultPndId},
			wantErr: true,
		},
		{
			name: "fails wrong type",
			fields: fields{
				store: store{
					defaultPndId: &pndImplementation{id: defaultPndId}}},
			args:    args{id: defaultPndId},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			s := deviceStore{
				store: tt.fields.store,
			}
			got, err := s.get(tt.args.id)
			if (err != nil) != tt.wantErr {
				t.Errorf("get() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("get() got = %v, want %v", got, tt.want)
			}
		})
	}
}