package server

// import (
// 	"context"
// 	"errors"
// 	"reflect"
// 	"testing"

// 	cpb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/conflict"
// 	mnepb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/networkelement"
// 	spb "code.fbi.h-da.de/danet/gosdn/api/go/gosdn/southbound"
// 	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/nucleus"
// 	"code.fbi.h-da.de/danet/gosdn/controller/store"
// 	"code.fbi.h-da.de/danet/gosdn/models/generated/openconfig"
// 	"github.com/google/uuid"
// )

// func TestNetworkElementServer_AddNetworkElement(t *testing.T) {
// 	mneServer := &NetworkElementServer{}
// 	createTestNetworkElementServer(t, mneServer)
// 	t.Cleanup(removeTestStores)

// 	type args struct {
// 		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 {
// 		tt := tt

// 		t.Run(tt.name, func(t *testing.T) {
// 			t.Parallel()

// 			sbi := &nucleus.OpenConfig{}
// 			sbi.SetID(sbiUUID)
// 			if err := mneServer.sbiService.Add(sbi); err != nil {
// 				t.Error(err)
// 			}

// 			_, err := mneServer.addNetworkElement(context.TODO(), tt.args.name, tt.args.opts, sbiUUID, pndUUID)
// 			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 := mneServer.mneService.Get(store.Query{Name: tt.args.name})
// 					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 := mneServer.mneService.Delete(mne); err != nil {
// 						t.Error(err)
// 					}
// 				}
// 			}
// 		})

// 		cleanMneAndSbiTestStore(mneServer)
// 	}
// }

// func TestNetworkElementServer_RemoveNetworkElement(t *testing.T) {
// 	mneServer := &NetworkElementServer{}
// 	createTestNetworkElementServer(t, mneServer)
// 	t.Cleanup(removeTestStores)

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

// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			sbi, err := nucleus.NewSBI(spb.Type_TYPE_OPENCONFIG, uuid.MustParse(sbiID))
// 			if err != nil {
// 				t.Error("could not create sbi")
// 			}

// 			err = mneServer.sbiService.Add(sbi)
// 			if err != nil {
// 				t.Error("could not add sbi")
// 			}
// 			mne := &nucleus.CommonNetworkElement{
// 				UUID:  mneUUID,
// 				Model: &openconfig.Device{},
// 			}
// 			mne.SetSBI(sbi)
// 			mne.SetTransport(nil)

// 			err = mneServer.mneService.Add(mne)
// 			if err != nil {
// 				t.Error(err)
// 			}

// 			if err := mneServer.deleteMne(tt.args.uuid); (err != nil) != tt.wantErr {
// 				t.Errorf("RemoveNetworkElement() error = %v, wantErr %v", err, tt.wantErr)
// 			}
// 		})

// 		cleanMneAndSbiTestStore(mneServer)
// 	}
// }

// // Somehow, provided mock transport does not get used?
// func TestNetworkElementServer_getPath(t *testing.T) {
// 	mneServer := &NetworkElementServer{}
// 	createTestNetworkElementServer(t, mneServer)
// 	t.Cleanup(removeTestStores)

// 	type args struct {
// 		uuid uuid.UUID
// 		path string
// 		rErr error
// 	}
// 	tests := []struct {
// 		name    string
// 		args    args
// 		wantErr bool
// 	}{
// 		{
// 			name: "default",
// 			args: args{
// 				uuid: mneUUID,
// 				path: "",
// 				rErr: nil,
// 			},
// 			wantErr: false,
// 		},
// 		{
// 			name: "error",
// 			args: args{
// 				uuid: uuid.New(),
// 				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()

// 			// sbi, err := nucleus.NewSBI(spb.Type_TYPE_OPENCONFIG)
// 			// if err != nil {
// 			// 	t.Error("could not create sbi")
// 			// }

// 			// err = mneServer.sbiService.Add(sbi)
// 			// if err != nil {
// 			// 	t.Error("could not add sbi")
// 			// }

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

// 			// networkElementWithMockTransport := &nucleus.CommonNetworkElement{
// 			// 	UUID:  mneUUID,
// 			// 	Model: &openconfig.Device{},
// 			// }

// 			// networkElementWithMockTransport.SetSBI(sbi)
// 			// networkElementWithMockTransport.SetTransport(&transport)

// 			// _ = mneServer.mneService.Add(networkElementWithMockTransport)

// 			// _, err = mneServer.getPath(context.TODO(), tt.args.uuid, tt.args.path)
// 			// if (err != nil) != tt.wantErr {
// 			// 	t.Errorf("getPath() error = %v, wantErr %v", err, tt.wantErr)
// 			// }
// 		})

// 		cleanMneAndSbiTestStore(mneServer)
// 	}
// }

// func TestNetworkElementServer_GetAll(t *testing.T) {
// 	mneServer := &NetworkElementServer{}
// 	createTestNetworkElementServer(t, mneServer)
// 	t.Cleanup(removeTestStores)

// 	type args struct {
// 		ctx     context.Context
// 		request *mnepb.GetAllNetworkElementRequest
// 	}
// 	tests := []struct {
// 		name    string
// 		args    args
// 		want    *mnepb.GetAllNetworkElementResponse
// 		wantErr bool
// 	}{
// 		{
// 			name: "default",
// 			args: args{
// 				ctx:     context.TODO(),
// 				request: &mnepb.GetAllNetworkElementRequest{},
// 			},
// 			want: &mnepb.GetAllNetworkElementResponse{
// 				Status: mnepb.Status_STATUS_OK,
// 				NetworkElement: []*mnepb.ManagedNetworkElement{
// 					{
// 						Id:   mneID,
// 						Name: "test",
// 					},
// 				},
// 			},
// 			wantErr: false,
// 		},
// 	}
// 	for _, tt := range tests {
// 		tt := tt

// 		t.Run(tt.name, func(t *testing.T) {
// 			t.Parallel()

// 			sbi, _ := nucleus.NewSBI(spb.Type_TYPE_OPENCONFIG)
// 			_ = mneServer.sbiService.Add(sbi)

// 			testMne := &nucleus.CommonNetworkElement{
// 				UUID:  mneUUID,
// 				Model: &openconfig.Device{},
// 			}

// 			testMne.SetName("test")
// 			testMne.SetSBI(sbi)
// 			testMne.SetPnd(uuid.New())

// 			_ = mneServer.mneService.Add(testMne)

// 			got, err := mneServer.GetAll(tt.args.ctx, tt.args.request)
// 			if (err != nil) != tt.wantErr {
// 				t.Errorf("NetworkElementServer.GetAll() error = %v, wantErr %v", err, tt.wantErr)
// 				return
// 			}
// 			if !(got.NetworkElement[0].Id == testMne.UUID.String() && got.NetworkElement[0].Name == testMne.Name()) {
// 				t.Errorf("NetworkElementServer.GetAll() = %v, want %v", got, tt.want)
// 			}
// 		})

// 		cleanMneAndSbiTestStore(mneServer)
// 	}
// }

// func TestNetworkElementServer_Get(t *testing.T) {
// 	mneServer := &NetworkElementServer{}
// 	createTestNetworkElementServer(t, mneServer)
// 	t.Cleanup(removeTestStores)

// 	type args struct {
// 		ctx     context.Context
// 		request *mnepb.GetNetworkElementRequest
// 	}
// 	tests := []struct {
// 		name    string
// 		args    args
// 		want    *mnepb.GetNetworkElementResponse
// 		wantErr bool
// 	}{
// 		{
// 			name: "default get by id",
// 			args: args{
// 				ctx: context.TODO(),
// 				request: &mnepb.GetNetworkElementRequest{
// 					NetworkElementId: mneID,
// 				},
// 			},
// 			want: &mnepb.GetNetworkElementResponse{
// 				Status: mnepb.Status_STATUS_OK,
// 				NetworkElement: &mnepb.ManagedNetworkElement{
// 					Id:   mneID,
// 					Name: "test",
// 				},
// 			},
// 			wantErr: false,
// 		},
// 		// {
// 		// 	name: "error wrong id",
// 		// 	args: args{
// 		// 		ctx: context.TODO(),
// 		// 		request: &mnepb.GetNetworkElementRequest{
// 		// 			NetworkElementId: uuid.NewString(),
// 		// 		},
// 		// 	},
// 		// 	want: &mnepb.GetNetworkElementResponse{
// 		// 		Status:         mnepb.Status_STATUS_ERROR,
// 		// 		NetworkElement: &mnepb.ManagedNetworkElement{},
// 		// 	},
// 		// 	wantErr: true,
// 		// },
// 	}
// 	for _, tt := range tests {
// 		tt := tt

// 		t.Run(tt.name, func(t *testing.T) {
// 			t.Parallel()

// 			sbi, _ := nucleus.NewSBI(spb.Type_TYPE_OPENCONFIG, uuid.MustParse(sbiID))
// 			_ = mneServer.sbiService.Add(sbi)

// 			testMne := &nucleus.CommonNetworkElement{
// 				UUID:  mneUUID,
// 				Model: &openconfig.Device{},
// 			}

// 			testMne.SetName("test")
// 			testMne.SetSBI(sbi)
// 			testMne.SetPnd(uuid.New())

// 			_ = mneServer.mneService.Add(testMne)

// 			got, err := mneServer.Get(tt.args.ctx, tt.args.request)
// 			if !tt.wantErr {
// 				if !(got.NetworkElement.Id == testMne.ID().String() && got.NetworkElement.Name == testMne.Name()) {
// 					t.Errorf("NetworkElementServer.Get() = %v, want %v", got, tt.want)
// 				}
// 			} else if (err != nil) != tt.wantErr {
// 				t.Errorf("NetworkElementServer.Get() error = %v, wantErr %v", err, tt.wantErr)
// 				return
// 			}
// 		})

// 		cleanMneAndSbiTestStore(mneServer)
// 	}
// }

// func TestNetworkElementServer_Update(t *testing.T) {
// 	mneServer := &NetworkElementServer{}
// 	createTestNetworkElementServer(t, mneServer)
// 	t.Cleanup(removeTestStores)

// 	type args struct {
// 		ctx     context.Context
// 		request *mnepb.UpdateNetworkElementRequest
// 	}
// 	tests := []struct {
// 		name    string
// 		args    args
// 		want    *mnepb.UpdateNetworkElementResponse
// 		wantErr bool
// 	}{
// 		{
// 			name: "stored mne name change",
// 			args: args{
// 				ctx: context.TODO(),
// 				request: &mnepb.UpdateNetworkElementRequest{
// 					NetworkElement: &mnepb.ManagedNetworkElement{
// 						Id:            mneID,
// 						Name:          "not test anymore",
// 						Model:         "model",
// 						Sbi:           &spb.SouthboundInterface{Id: sbiID},
// 						Metadata:      &cpb.Metadata{ResourceVersion: 1},
// 						AssociatedPnd: pndUUID.String(),
// 						TransportOption: &tpb.TransportOption{
// 							TransportOption: &tpb.TransportOption_GnmiTransportOption{
// 								GnmiTransportOption: &tpb.GnmiTransportOption{},
// 							},
// 						},
// 						TransportAddress: "127.0.0.1",
// 					},
// 				},
// 			},
// 			want: &mnepb.UpdateNetworkElementResponse{
// 				Status: mnepb.Status_STATUS_OK,
// 			},
// 			wantErr: false,
// 		},
// 	}
// 	for _, tt := range tests {
// 		tt := tt

// 		t.Run(tt.name, func(t *testing.T) {
// 			t.Parallel()

// 			sbi, _ := nucleus.NewSBI(spb.Type_TYPE_OPENCONFIG, uuid.MustParse(sbiID))
// 			_ = mneServer.sbiService.Add(sbi)

// 			testMne := &nucleus.CommonNetworkElement{
// 				UUID:     mneUUID,
// 				Model:    &openconfig.Device{},
// 				Metadata: conflict.Metadata{ResourceVersion: 0},
// 			}

// 			testMne.SetName("test")
// 			testMne.SetSBI(sbi)
// 			testMne.SetPnd(pndUUID)

// 			_ = mneServer.mneService.Add(testMne)

// 			got, err := mneServer.Update(tt.args.ctx, tt.args.request)
// 			if (err != nil) != tt.wantErr {
// 				t.Errorf("NetworkElementServer.Update() error = %v, wantErr %v", err, tt.wantErr)
// 				return
// 			}

// 			changedMne, err := mneServer.mneService.Get(store.Query{ID: mneUUID})
// 			if err != nil {
// 				t.Errorf("NetworkElementServer.Update() error = %v", err)
// 			}

// 			if got.Status == tt.want.Status {
// 				if !(changedMne.Name() == tt.args.request.NetworkElement.Name) {
// 					t.Errorf("NetworkElementServer.Update() = %v, want %v", changedMne.Name(), tt.args.request.NetworkElement.Name)
// 				}
// 			}
// 		})

// 		cleanMneAndSbiTestStore(mneServer)
// 	}
// }

// func TestNetworkElementServer_GetChangeList(t *testing.T) {
// 	mneServer := &NetworkElementServer{}
// 	createTestNetworkElementServer(t, mneServer)
// 	t.Cleanup(removeTestStores)

// 	type args struct {
// 		ctx     context.Context
// 		request *mnepb.GetChangeListRequest
// 	}
// 	tests := []struct {
// 		name    string
// 		args    args
// 		want    *mnepb.GetChangeListResponse
// 		wantErr bool
// 	}{
// 		// TODO: Add test cases.
// 	}
// 	for _, tt := range tests {
// 		t.Run(tt.name, func(t *testing.T) {
// 			got, err := mneServer.GetChangeList(tt.args.ctx, tt.args.request)
// 			if (err != nil) != tt.wantErr {
// 				t.Errorf("NetworkElementServer.GetChangeList() error = %v, wantErr %v", err, tt.wantErr)
// 				return
// 			}
// 			if !reflect.DeepEqual(got, tt.want) {
// 				t.Errorf("NetworkElementServer.GetChangeList() = %v, want %v", got, tt.want)
// 			}
// 		})
// 	}
// }
