Skip to content
Snippets Groups Projects
pnd_test.go 6.27 KiB
Newer Older
  • Learn to ignore specific revisions
  • Manuel Kieweg's avatar
    Manuel Kieweg committed
    package server
    
    import (
    	"context"
    	"os"
    	"reflect"
    	"testing"
    
    	ppb "code.fbi.h-da.de/cocsn/api/go/gosdn/pnd"
    	spb "code.fbi.h-da.de/cocsn/api/go/gosdn/southbound"
    	"code.fbi.h-da.de/cocsn/api/go/gosdn/transport"
    
    	"code.fbi.h-da.de/cocsn/gosdn/interfaces/device"
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	"code.fbi.h-da.de/cocsn/gosdn/mocks"
    	"code.fbi.h-da.de/cocsn/gosdn/nucleus"
    	"code.fbi.h-da.de/cocsn/yang-models/generated/openconfig"
    	"github.com/google/uuid"
    	log "github.com/sirupsen/logrus"
    	"github.com/stretchr/testify/mock"
    )
    
    const pndID = "2043519e-46d1-4963-9a8e-d99007e104b8"
    const pendingChangeID = "0992d600-f7d4-4906-9559-409b04d59a5f"
    const committedChangeID = "804787d6-e5a8-4dba-a1e6-e73f96b0119e"
    const sbiID = "f6fd4b35-f039-4111-9156-5e4501bb8a5a"
    const ondID = "7e0ed8cc-ebf5-46fa-9794-741494914883"
    
    var hostname = "manfred"
    var pndUUID uuid.UUID
    var pendingChangeUUID uuid.UUID
    var committedChangeUUID uuid.UUID
    var deviceUUID uuid.UUID
    
    var mockPnd *mocks.NetworkDomain
    var mockDevice device.Device
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    var sbiStore *nucleus.SbiStore
    
    func TestMain(m *testing.M) {
    	log.SetReportCaller(true)
    	var err error
    	pndUUID, err = uuid.Parse(pndID)
    	if err != nil {
    		log.Fatal(err)
    	}
    
    	pendingChangeUUID, err = uuid.Parse(pendingChangeID)
    	if err != nil {
    		log.Fatal(err)
    	}
    
    	committedChangeUUID, err = uuid.Parse(committedChangeID)
    	if err != nil {
    		log.Fatal(err)
    	}
    
    	deviceUUID, err = uuid.Parse(ondID)
    	if err != nil {
    		log.Fatal(err)
    	}
    
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	mockDevice = &nucleus.CommonDevice{
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		GoStruct: &openconfig.Device{
    			System: &openconfig.OpenconfigSystem_System{
    				Config: &openconfig.OpenconfigSystem_System_Config{
    					Hostname: &hostname,
    				},
    			},
    		},
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		UUID: deviceUUID,
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	mockDevice.(*nucleus.CommonDevice).SetSBI(nucleus.NewSBI(spb.Type_OPENCONFIG))
    	mockDevice.(*nucleus.CommonDevice).SetTransport(&mocks.Transport{})
    	mockDevice.(*nucleus.CommonDevice).SetName(hostname)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	sbiStore = nucleus.NewSbiStore()
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	if err := sbiStore.Add(mockDevice.SBI()); err != nil {
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    		log.Fatal(err)
    	}
    
    
    	mockPnd = &mocks.NetworkDomain{}
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    	mockPnd.On("ID").Return(pndUUID)
    	mockPnd.On("GetName").Return("test")
    	mockPnd.On("GetDescription").Return("test")
    	mockPnd.On("GetSBIs").Return(sbiStore)
    	mockPnd.On("Devices").Return([]uuid.UUID{deviceUUID})
    	mockPnd.On("PendingChanges").Return([]uuid.UUID{pendingChangeUUID})
    	mockPnd.On("CommittedChanges").Return([]uuid.UUID{committedChangeUUID})
    	mockPnd.On("GetChange", mock.Anything).Return(&nucleus.Change{}, nil)
    	mockPnd.On("AddDevice", mock.Anything, mock.Anything, mock.Anything).Return(nil)
    	mockPnd.On("GetDevice", mock.Anything).Return(mockDevice, nil)
    	mockPnd.On("Commit", mock.Anything).Return(nil)
    	mockPnd.On("Confirm", mock.Anything).Return(nil)
    
    	mockPnd.On("ChangeOND", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(uuid.Nil, nil)
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    
    	pndc = nucleus.NewPndStore()
    	if err := pndc.Add(mockPnd); err != nil {
    		log.Fatal(err)
    	}
    
    	os.Exit(m.Run())
    }
    
    func Test_pnd_Get(t *testing.T) {
    	type args struct {
    		ctx     context.Context
    		request *ppb.GetRequest
    	}
    	tests := []struct {
    		name    string
    		args    args
    		want    []string
    		wantErr bool
    	}{
    		{
    			name: "get pnd",
    			args: args{
    				ctx: context.Background(),
    				request: &ppb.GetRequest{
    					Request: &ppb.GetRequest_Pnd{
    						Pnd: &ppb.GetPnd{},
    					},
    					Pid: pndID,
    				},
    			},
    			want: []string{
    				pndID,
    				ondID,
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    				mockDevice.SBI().ID().String(),
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    				pendingChangeID,
    				committedChangeID,
    			},
    		},
    	}
    	for _, tt := range tests {
    		t.Run(tt.name, func(t *testing.T) {
    
    			p := pndServer{
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    				UnimplementedPndServer: ppb.UnimplementedPndServer{},
    			}
    			resp, err := p.Get(tt.args.ctx, tt.args.request)
    			if (err != nil) != tt.wantErr {
    				t.Errorf("Get() error = %v, wantErr %v", err, tt.wantErr)
    				return
    			}
    
    			got := []string{
    				resp.Pnd.Id,
    				resp.Pnd.Ond[0].Id,
    				resp.Pnd.Sbi[0].Id,
    				resp.Pnd.Change[0].Id,
    				resp.Pnd.Change[1].Id,
    			}
    			if !reflect.DeepEqual(got, tt.want) {
    				t.Errorf("Get() got = %v, want %v", got, tt.want)
    			}
    		})
    	}
    }
    
    func Test_pnd_Set(t *testing.T) {
    	type args struct {
    		ctx     context.Context
    		request *ppb.SetRequest
    	}
    	tests := []struct {
    		name    string
    		args    args
    		want    ppb.SetResponseStatus
    		wantErr bool
    	}{
    		{
    			name: "set ond",
    			args: args{
    				ctx: context.Background(),
    				request: &ppb.SetRequest{
    					Ond: []*ppb.SetOnd{
    						{
    							Sbi: &spb.SouthboundInterface{
    								Id:   sbiID,
    								Type: spb.Type_OPENCONFIG,
    							},
    							DeviceName: hostname,
    							TransportOption: &transport.TransportOption{
    								Address:         "test",
    								Username:        "test",
    								Password:        "test",
    								TransportOption: &transport.TransportOption_GnmiTransportOption{},
    							},
    						},
    					},
    					Pid: pndID,
    				},
    			},
    			want: ppb.SetResponse_OK,
    		},
    		{
    			name: "set change",
    			args: args{
    				ctx: context.Background(),
    				request: &ppb.SetRequest{
    					Pid: pndID,
    					Change: []*ppb.SetChange{
    						{
    							Cuid: pendingChangeID,
    							Op:   ppb.SetChange_COMMIT,
    						},
    						{
    							Cuid: committedChangeID,
    							Op:   ppb.SetChange_CONFIRM,
    						},
    					},
    				},
    			},
    			want: ppb.SetResponse_OK,
    		},
    		{
    			name: "change request",
    			args: args{
    				ctx: context.Background(),
    				request: &ppb.SetRequest{
    					Pid: pndID,
    					ChangeRequest: []*ppb.ChangeRequest{
    						{
    							Id:    ondID,
    							Path:  "/system/config/hostname",
    							Value: "herbert",
    							ApiOp: ppb.ApiOperation_UPDATE,
    						},
    						{
    							Id:    ondID,
    							Path:  "/system/config/hostname",
    							Value: "fridolin",
    							ApiOp: ppb.ApiOperation_REPLACE,
    						},
    						{
    							Id:    ondID,
    							Path:  "/system/config/hostname",
    							ApiOp: ppb.ApiOperation_DELETE,
    						},
    					},
    				},
    			},
    			want: ppb.SetResponse_OK,
    		},
    	}
    	for _, tt := range tests {
    		t.Run(tt.name, func(t *testing.T) {
    
    			p := pndServer{
    
    Manuel Kieweg's avatar
    Manuel Kieweg committed
    				UnimplementedPndServer: ppb.UnimplementedPndServer{},
    			}
    			resp, err := p.Set(tt.args.ctx, tt.args.request)
    			if (err != nil) != tt.wantErr {
    				t.Errorf("Set() error = %v, wantErr %v", err, tt.wantErr)
    				return
    			}
    			got := resp.Status
    			if !reflect.DeepEqual(got, tt.want) {
    				t.Errorf("Set() got = %v, want %v", got, tt.want)
    			}
    			for _, r := range resp.Responses {
    				got = r.Status
    				if !reflect.DeepEqual(got, tt.want) {
    					t.Errorf("Set() got = %v, want %v", got, tt.want)
    				}
    			}
    		})
    	}
    }