VGC UT coverage upto 40%
Change-Id: Ifb2886a44ff49128ecddb2100f524b5274d0a063
diff --git a/internal/pkg/controller/controller_test.go b/internal/pkg/controller/controller_test.go
new file mode 100644
index 0000000..ff45c50
--- /dev/null
+++ b/internal/pkg/controller/controller_test.go
@@ -0,0 +1,1032 @@
+/*
+* Copyright 2022-present Open Networking Foundation
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+ */
+
+package controller
+
+import (
+ "context"
+ "reflect"
+ "sync"
+ "testing"
+ "voltha-go-controller/internal/pkg/intf"
+ "voltha-go-controller/internal/pkg/of"
+ "voltha-go-controller/internal/pkg/tasks"
+ "voltha-go-controller/internal/pkg/vpagent"
+ "voltha-go-controller/internal/test/mocks"
+
+ "github.com/golang/mock/gomock"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestNewController(t *testing.T) {
+ type args struct {
+ ctx context.Context
+ app intf.App
+ }
+ appMock := mocks.NewMockApp(gomock.NewController(t))
+ app := NewController(ctx, appMock)
+ tests := []struct {
+ name string
+ args args
+ want intf.IVPClientAgent
+ }{
+ {
+ name: "TestNewController",
+ args: args{
+ ctx: context.Background(),
+ app: GetController().app,
+ },
+ want: app,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := NewController(tt.args.ctx, tt.args.app); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("NewController() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func Cancel() {}
+func TestVoltController_DelDevice(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ id string
+ }
+
+ device := &Device{
+ ID: "SDX6320031",
+ cancel: Cancel,
+ }
+ dev := map[string]*Device{}
+ dev["SDX6320031"] = device
+ appMock := mocks.NewMockApp(gomock.NewController(t))
+ NewController(ctx, appMock)
+ appMock.EXPECT().DelDevice(gomock.Any(), gomock.Any()).AnyTimes()
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "DelDevice",
+ args: args{
+ cntx: context.Background(),
+ id: "SDX6320031",
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ devices: dev,
+ app: GetController().app,
+ }
+ v.DelDevice(tt.args.cntx, tt.args.id)
+ })
+ }
+}
+
+func TestVoltController_AddFlows(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ port string
+ device string
+ flow *of.VoltFlow
+ }
+ subFlows := map[uint64]*of.VoltSubFlow{}
+ vltSubFlow := &of.VoltSubFlow{
+ Priority: 100,
+ Cookie: 103112802816,
+ State: of.FlowAddSuccess,
+ Match: of.Match{
+ InPort: 1573376,
+ MatchVlan: 4096,
+ L4Protocol: 255,
+ },
+ Action: of.Action{
+ Metadata: 279189651712,
+ GoToTableID: 1,
+ MeterID: 1,
+ SetVlan: 4097,
+ Pcp: 8,
+ Output: 4,
+ },
+ }
+ subFlows[0] = vltSubFlow
+ portsByName := map[string]*DevicePort{}
+ portsByName["SDX6320031-1"] = &DevicePort{
+ Name: "SDX6320031-1",
+ ID: 256,
+ }
+ device := &Device{
+ ctx: context.Background(),
+ ID: "SDX6320031",
+ flows: subFlows,
+ PortsByName: portsByName,
+ }
+ dev := map[string]*Device{}
+ dev["SDX6320031"] = device
+ flow := &of.VoltFlow{
+ PortName: "SDX6320031-1",
+ PortID: 256,
+ Command: 0,
+ MigrateCookie: true,
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "AddFlows",
+ args: args{
+ cntx: context.Background(),
+ port: "SDX6320031-1",
+ device: "SDX6320031",
+ flow: flow,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ devices: dev,
+ }
+ if err := v.AddFlows(tt.args.cntx, tt.args.port, tt.args.device, tt.args.flow); (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.AddFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestVoltController_DelFlows(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ port string
+ device string
+ flow *of.VoltFlow
+ }
+ subFlows := map[uint64]*of.VoltSubFlow{}
+ vltSubFlow := &of.VoltSubFlow{
+ Priority: 100,
+ Cookie: 103112802816,
+ State: of.FlowAddSuccess,
+ Match: of.Match{
+ InPort: 1573376,
+ MatchVlan: 4096,
+ L4Protocol: 255,
+ },
+ Action: of.Action{
+ Metadata: 279189651712,
+ GoToTableID: 1,
+ MeterID: 1,
+ SetVlan: 4097,
+ Pcp: 8,
+ Output: 4,
+ },
+ }
+ subFlows[0] = vltSubFlow
+ portsByName := map[string]*DevicePort{}
+ portsByName["SDX6320031-1"] = &DevicePort{
+ Name: "SDX6320031-1",
+ ID: 256,
+ }
+ device := &Device{
+ ctx: context.Background(),
+ ID: "SDX6320031",
+ flows: subFlows,
+ PortsByName: portsByName,
+ }
+ dev := map[string]*Device{}
+ dev["SDX6320031"] = device
+ flow := &of.VoltFlow{
+ PortName: "SDX6320031-1",
+ PortID: 256,
+ Command: 0,
+ MigrateCookie: true,
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "DelFlows",
+ args: args{
+ cntx: context.Background(),
+ port: "SDX6320031-1",
+ device: "SDX6320031",
+ flow: flow,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ devices: dev,
+ }
+ if err := v.DelFlows(tt.args.cntx, tt.args.port, tt.args.device, tt.args.flow); (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.DelFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestVoltController_GetGroups(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ id uint32
+ }
+ device := &Device{
+ ctx: context.Background(),
+ ID: "SDX6320031",
+ groups: sync.Map{},
+ }
+ grp := &of.Group{
+ Device: "SDX6320031",
+ GroupID: uint32(256),
+ State: 1,
+ SetVlan: of.VlanAny,
+ }
+ dev := map[string]*Device{}
+ dev["SDX6320031"] = device
+ tests := []struct {
+ name string
+ args args
+ want *of.Group
+ wantErr bool
+ }{
+ {
+ name: "VoltController_GetGroups",
+ args: args{
+ cntx: context.Background(),
+ id: uint32(256),
+ },
+ want: grp,
+ wantErr: false,
+ },
+ {
+ name: "GetGroups_Not-Found",
+ args: args{
+ cntx: context.Background(),
+ id: 1,
+ },
+ want: nil,
+ wantErr: true,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ devices: dev,
+ }
+ switch tt.name {
+ case "VoltController_GetGroups":
+ device.groups.Store(uint32(256), grp)
+ got, err := v.GetGroups(tt.args.cntx, tt.args.id)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.GetGroups() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltController.GetGroups() = %v, want %v", got, tt.want)
+ }
+ case "GetGroups_Not-Found":
+ got, err := v.GetGroups(tt.args.cntx, tt.args.id)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.GetGroups() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltController.GetGroups() = %v, want %v", got, tt.want)
+ }
+ }
+ })
+ }
+}
+
+func TestVoltController_GetGroupList(t *testing.T) {
+ device := &Device{
+ ctx: context.Background(),
+ ID: "SDX6320031",
+ groups: sync.Map{},
+ }
+ grpList := []*of.Group{}
+ grp := &of.Group{
+ Device: "SDX6320031",
+ GroupID: uint32(256),
+ State: 1,
+ SetVlan: of.VlanAny,
+ }
+ grpList = append(grpList, grp)
+ dev := map[string]*Device{}
+ dev["SDX6320031"] = device
+ tests := []struct {
+ name string
+ want []*of.Group
+ wantErr bool
+ }{
+ {
+ name: "VoltController_GetGroups",
+ want: grpList,
+ wantErr: false,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ devices: dev,
+ }
+ device.groups.Store(uint32(256), grp)
+ got, err := v.GetGroupList()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.GetGroupList() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltController.GetGroupList() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestVoltController_GetMeterInfo(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ id uint32
+ }
+ mtrs := &of.Meter{
+ ID: uint32(256),
+ State: 1,
+ }
+ mtr := map[string]*of.Meter{}
+ mtr["SDX6320031"] = mtrs
+ devMtr := map[uint32]*of.Meter{}
+ devMtr[uint32(256)] = mtrs
+ device := &Device{
+ ctx: context.Background(),
+ ID: "SDX6320031",
+ meters: devMtr,
+ }
+ dev := map[string]*Device{}
+ dev["SDX6320031"] = device
+ tests := []struct {
+ name string
+ args args
+ want map[string]*of.Meter
+ wantErr bool
+ }{
+ {
+ name: "VoltController_GetMeterInfo",
+ args: args{
+ cntx: context.Background(),
+ id: uint32(256),
+ },
+ want: mtr,
+ wantErr: false,
+ },
+ {
+ name: "Not_Found_Error",
+ args: args{
+ cntx: context.Background(),
+ id: 1,
+ },
+ want: nil,
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ devices: dev,
+ }
+ switch tt.name {
+ case "VoltController_GetMeterInfo":
+ got, err := v.GetMeterInfo(tt.args.cntx, tt.args.id)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.GetMeterInfo() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltController.GetMeterInfo() = %v, want %v", got, tt.want)
+ }
+ case "Not_Found_Error":
+ got, err := v.GetMeterInfo(tt.args.cntx, tt.args.id)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.GetMeterInfo() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltController.GetMeterInfo() = %v, want %v", got, tt.want)
+ }
+ }
+ })
+ }
+}
+
+func TestVoltController_GetAllMeterInfo(t *testing.T) {
+ vltMtr := map[string][]*of.Meter{}
+ mtr := &of.Meter{
+ ID: uint32(256),
+ State: 1,
+ }
+ mtrs := []*of.Meter{}
+ mtrs = append(mtrs, mtr)
+ vltMtr["SDX6320031"] = mtrs
+ devMtr := map[uint32]*of.Meter{}
+ devMtr[uint32(256)] = mtr
+ device := &Device{
+ ctx: context.Background(),
+ ID: "SDX6320031",
+ meters: devMtr,
+ }
+ dev := map[string]*Device{}
+ dev["SDX6320031"] = device
+ tests := []struct {
+ name string
+ want map[string][]*of.Meter
+ wantErr bool
+ }{
+ {
+ name: "VoltController_GetMeterInfo",
+ want: vltMtr,
+ wantErr: false,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ devices: dev,
+ }
+ got, err := v.GetAllMeterInfo()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.GetAllMeterInfo() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltController.GetAllMeterInfo() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestVoltController_GetAllPendingFlows(t *testing.T) {
+ subFlowList := []*of.VoltSubFlow{}
+ vltSubFlow := &of.VoltSubFlow{
+ Priority: 100,
+ Cookie: 103112802816,
+ State: of.FlowAddSuccess,
+ Match: of.Match{
+ InPort: 1573376,
+ MatchVlan: 4096,
+ L4Protocol: 255,
+ },
+ Action: of.Action{
+ Metadata: 279189651712,
+ GoToTableID: 1,
+ MeterID: 1,
+ SetVlan: 4097,
+ Pcp: 8,
+ Output: 4,
+ },
+ }
+ subFlowList = append(subFlowList, vltSubFlow)
+ subFlows := map[uint64]*of.VoltSubFlow{}
+ subFlows[0] = vltSubFlow
+ device := &Device{
+ ctx: context.Background(),
+ ID: "SDX6320031",
+ flows: subFlows,
+ }
+ dev := map[string]*Device{}
+ dev["SDX6320031"] = device
+ tests := []struct {
+ name string
+ want []*of.VoltSubFlow
+ wantErr bool
+ }{
+ {
+ name: "GetAllPendingFlows",
+ want: subFlowList,
+ wantErr: false,
+ },
+ }
+ type args1 struct {
+ deviceId string
+ }
+ tests1 := []struct {
+ name string
+ args args1
+ want []*of.VoltSubFlow
+ wantErr bool
+ }{
+ {
+ name: "GetFlows_with_DeviceID",
+ args: args1{
+ deviceId: "SDX6320031",
+ },
+ want: subFlowList,
+ wantErr: false,
+ },
+ {
+ name: "GetFlows_with_DeviceID_NOT_FOUND",
+ args: args1{
+ deviceId: "",
+ },
+ want: subFlowList,
+ wantErr: false,
+ },
+ }
+ type args2 struct {
+ deviceId string
+ cookie uint64
+ }
+ tests2 := []struct {
+ name string
+ args args2
+ want []*of.VoltSubFlow
+ wantErr bool
+ }{
+ {
+ name: "GetFlow_with_DeviceID_and_cookie",
+ args: args2{
+ deviceId: "SDX6320031",
+ cookie: 103112802816,
+ },
+ want: subFlowList,
+ wantErr: false,
+ },
+ {
+ name: "GetFlow_with_DeviceID_and_cookie_NOT_FOUND",
+ args: args2{
+ deviceId: "",
+ },
+ want: subFlowList,
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ devices: dev,
+ }
+ got, err := v.GetAllPendingFlows()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.GetAllPendingFlows() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.Nil(t, got)
+ got1, err1 := v.GetAllFlows()
+ if (err1 != nil) != tt.wantErr {
+ t.Errorf("VoltController.GetAllPendingFlows() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.NotNil(t, got1)
+ })
+ }
+ for _, tt := range tests1 {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ devices: dev,
+ }
+ switch tt.name {
+ case "GetFlows_with_DeviceID":
+ got, err := v.GetFlows(tt.args.deviceId)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.GetAllPendingFlows() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.NotNil(t, got)
+ case "GetFlows_with_DeviceID_NOT_FOUND":
+ got, err := v.GetFlows(tt.args.deviceId)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.GetAllPendingFlows() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.Nil(t, got)
+ }
+ })
+ }
+ for _, tt := range tests2 {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ devices: dev,
+ }
+ switch tt.name {
+ case "GetFlow_with_DeviceID_and_cookie":
+ got, err := v.GetFlow(tt.args.deviceId, tt.args.cookie)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.GetAllPendingFlows() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.Nil(t, got)
+ case "GetFlow_with_DeviceID_and_cookie_NOT_FOUND":
+ got, err := v.GetFlow(tt.args.deviceId, tt.args.cookie)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.GetAllPendingFlows() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.Nil(t, got)
+ }
+ })
+ }
+}
+
+func TestVoltController_GetTaskList(t *testing.T) {
+ type args struct {
+ device string
+ }
+ device := &Device{
+ ctx: context.Background(),
+ ID: "SDX6320031",
+ }
+ dev := map[string]*Device{}
+ dev["SDX6320031"] = device
+ tests := []struct {
+ name string
+ args args
+ want []tasks.Task
+ }{
+ {
+ name: "GetTaskList",
+ args: args{
+ device: "SDX6320031",
+ },
+ want: []tasks.Task{},
+ },
+ {
+ name: "GetTaskList_Device_Not_found",
+ args: args{
+ device: "SDX632003",
+ },
+ want: []tasks.Task{},
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ devices: dev,
+ }
+ switch tt.name {
+ case "GetTaskList":
+ if got := v.GetTaskList(tt.args.device); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltController.GetTaskList() = %v, want %v", got, tt.want)
+ }
+ case "GetTaskList_Device_Not_found":
+ if got := v.GetTaskList(tt.args.device); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltController.GetTaskList() = %v, want %v", got, tt.want)
+ }
+ }
+ })
+ }
+}
+
+func TestVoltController_GetPortState(t *testing.T) {
+ type args struct {
+ device string
+ name string
+ }
+ portsByName := map[string]*DevicePort{}
+ portsByName["SDX6320031-1"] = &DevicePort{
+ Name: "SDX6320031-1",
+ ID: 256,
+ }
+ device := &Device{
+ ctx: context.Background(),
+ ID: "SDX6320031",
+ PortsByName: portsByName,
+ }
+ dev := map[string]*Device{}
+ dev["SDX6320031"] = device
+ tests := []struct {
+ name string
+ args args
+ want PortState
+ wantErr bool
+ }{
+ {
+ name: "GetPortState",
+ args: args{
+ device: "SDX6320031",
+ name: "SDX6320031-1",
+ },
+ want: PortStateUp,
+ },
+ {
+ name: "GetPortState_Device_Not_found",
+ args: args{
+ device: "SDX6320031-1",
+ name: "SDX6320031",
+ },
+ want: PortStateDown,
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ devices: dev,
+ }
+ switch tt.name {
+ case "GetPortState":
+ got, err := v.GetPortState(tt.args.device, tt.args.name)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.GetPortState() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.NotNil(t, got)
+ case "GetPortState_Device_Not_found":
+ got, err := v.GetPortState(tt.args.device, tt.args.name)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.GetPortState() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if got != tt.want {
+ t.Errorf("VoltController.GetPortState() = %v, want %v", got, tt.want)
+ }
+ }
+ })
+ }
+}
+
+func TestVoltController_ModMeter(t *testing.T) {
+ type args struct {
+ port string
+ device string
+ command of.MeterCommand
+ meter *of.Meter
+ }
+ portsByName := map[string]*DevicePort{}
+ portsByName["SDX6320031-1"] = &DevicePort{
+ Name: "SDX6320031-1",
+ ID: 256,
+ }
+ mtrs := &of.Meter{
+ ID: uint32(256),
+ State: 1,
+ }
+ devMtr := map[uint32]*of.Meter{}
+ devMtr[uint32(256)] = mtrs
+ device := &Device{
+ ctx: context.Background(),
+ ID: "SDX6320031",
+ PortsByName: portsByName,
+ meters: devMtr,
+ }
+ dev := map[string]*Device{}
+ dev["SDX6320031"] = device
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "ModMeter",
+ args: args{
+ device: "SDX6320031",
+ port: "SDX6320031-1",
+ command: of.MeterCommandAdd,
+ meter: mtrs,
+ },
+ wantErr: false,
+ },
+ {
+ name: "ModMeter_device_not_found",
+ args: args{
+ command: of.MeterCommandAdd,
+ meter: mtrs,
+ },
+ wantErr: true,
+ },
+ {
+ name: "ModMeter_port_not_found",
+ args: args{
+ device: "SDX6320031",
+ command: of.MeterCommandAdd,
+ meter: mtrs,
+ },
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ devices: dev,
+ }
+ switch tt.name {
+ case "ModMeter":
+ if err := v.ModMeter(tt.args.port, tt.args.device, tt.args.command, tt.args.meter); (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.ModMeter() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "ModMeter_device_not_found":
+ if err := v.ModMeter(tt.args.port, tt.args.device, tt.args.command, tt.args.meter); (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.ModMeter() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "ModMeter_port_not_found":
+ if err := v.ModMeter(tt.args.port, tt.args.device, tt.args.command, tt.args.meter); (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.ModMeter() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ }
+ })
+ }
+}
+
+func TestVoltController_VPAgent(t *testing.T) {
+ type args struct {
+ vep string
+ }
+ vagent := map[string]*vpagent.VPAgent{}
+ vpa := &vpagent.VPAgent{}
+ vagent[""] = vpa
+ tests := []struct {
+ name string
+ args args
+ want *vpagent.VPAgent
+ wantErr bool
+ }{
+ {
+ name: "VPAgent",
+ args: args{},
+ want: vpa,
+ wantErr: false,
+ },
+ {
+ name: "VPAgent_Error",
+ args: args{
+ vep: "ab",
+ },
+ want: nil,
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ vagent: vagent,
+ }
+ switch tt.name {
+ case "VPAgent":
+ got, err := v.VPAgent(tt.args.vep)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.VPAgent() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltController.VPAgent() = %v, want %v", got, tt.want)
+ }
+ case "VPAgent_Error":
+ got, err := v.VPAgent(tt.args.vep)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltController.VPAgent() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltController.VPAgent() = %v, want %v", got, tt.want)
+ }
+ }
+ })
+ }
+}
+
+func TestVoltController_DeviceRebootInd(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ dID string
+ srNo string
+ sbID string
+ }
+ appMock := mocks.NewMockApp(gomock.NewController(t))
+ NewController(ctx, appMock)
+ appMock.EXPECT().DeviceRebootInd(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes()
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().DelAllRoutesForDevice(gomock.Any(), gomock.Any()).AnyTimes()
+ dbintf.EXPECT().DelAllGroup(gomock.Any(), gomock.Any()).AnyTimes()
+ dbintf.EXPECT().DelAllMeter(gomock.Any(), gomock.Any()).AnyTimes()
+ dbintf.EXPECT().DelAllPONCounters(gomock.Any(), gomock.Any()).AnyTimes()
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "VPAgent",
+ args: args{
+ dID: "1234",
+ srNo: "SDX6320031",
+ cntx: context.Background(),
+ sbID: "4321",
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ app: GetController().app,
+ }
+ v.DeviceRebootInd(tt.args.cntx, tt.args.dID, tt.args.srNo, tt.args.sbID)
+ })
+ }
+}
+
+func TestVoltController_SetRebootInProgressForDevice(t *testing.T) {
+ type args struct {
+ device string
+ }
+ rebootInProgressDevices := map[string]string{}
+ device := &Device{
+ ctx: context.Background(),
+ ID: "SDX6320031",
+ }
+ dev := map[string]*Device{}
+ dev["SDX6320031"] = device
+ tests := []struct {
+ name string
+ args args
+ want bool
+ }{
+ {
+ name: "SetRebootInProgressForDevice",
+ args: args{
+ device: "SDX6320031",
+ },
+ want: true,
+ },
+ {
+ name: "SetRebootInProgressForDevice_Error",
+ args: args{
+ device: "SDX6320031-1",
+ },
+ want: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ rebootInProgressDevices: rebootInProgressDevices,
+ devices: dev,
+ }
+ switch tt.name {
+ case "SetRebootInProgressForDevice":
+ if got := v.SetRebootInProgressForDevice(tt.args.device); got != tt.want {
+ t.Errorf("VoltController.SetRebootInProgressForDevice() = %v, want %v", got, tt.want)
+ }
+ case "SetRebootInProgressForDevice_Error":
+ if got := v.SetRebootInProgressForDevice(tt.args.device); got != tt.want {
+ t.Errorf("VoltController.SetRebootInProgressForDevice() = %v, want %v", got, tt.want)
+ }
+ }
+ })
+ }
+}
+
+func TestVoltController_ReSetRebootInProgressForDevice(t *testing.T) {
+ type args struct {
+ device string
+ }
+ rebootInProgressDevices := map[string]string{}
+ device := &Device{
+ ctx: context.Background(),
+ ID: "SDX6320031",
+ }
+ rebootInProgressDevices["SDX6320031"] = "done"
+ dev := map[string]*Device{}
+ dev["SDX6320031"] = device
+ tests := []struct {
+ name string
+ args args
+ want bool
+ }{
+ {
+ name: "ReSetRebootInProgressForDevice",
+ args: args{
+ device: "SDX6320031",
+ },
+ want: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ v := &VoltController{
+ rebootInProgressDevices: rebootInProgressDevices,
+ devices: dev,
+ }
+ if got := v.ReSetRebootInProgressForDevice(tt.args.device); got != tt.want {
+ t.Errorf("VoltController.ReSetRebootInProgressForDevice() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}