VGC UT coverage upto 40%
Change-Id: Ifb2886a44ff49128ecddb2100f524b5274d0a063
diff --git a/internal/pkg/controller/changeevent.go b/internal/pkg/controller/changeevent.go
index ae744d6..f221d88 100644
--- a/internal/pkg/controller/changeevent.go
+++ b/internal/pkg/controller/changeevent.go
@@ -89,5 +89,5 @@
logger.Debugw(ctx, "Processed Port Change Event", log.Fields{"Port No": portNo, "Port Name": portName, "State": state, "Reason": status.PortStatus.Reason})
return nil
}
- return errors.New("Invalid message received")
+ return errors.New("invalid message received")
}
diff --git a/internal/pkg/controller/controller.go b/internal/pkg/controller/controller.go
index 4e2c4eb..b1939b9 100644
--- a/internal/pkg/controller/controller.go
+++ b/internal/pkg/controller/controller.go
@@ -621,7 +621,7 @@
logger.Debugw(ctx, "Inside GetGroupList method", log.Fields{"groupID": id})
grps, ok := device.groups.Load(id)
if !ok {
- return nil, errors.New("Group not found")
+ return nil, errors.New("group not found")
}
groups = grps.(*of.Group)
logger.Debugw(ctx, "Groups", log.Fields{"groups": groups})
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)
+ }
+ })
+ }
+}
diff --git a/internal/pkg/controller/device.go b/internal/pkg/controller/device.go
index 0bafca7..57474a0 100644
--- a/internal/pkg/controller/device.go
+++ b/internal/pkg/controller/device.go
@@ -51,7 +51,11 @@
// DefaultMaxFlowQueues constant
DefaultMaxFlowQueues = 67
//ErrDuplicateFlow - indicates flow already exists in DB
- ErrDuplicateFlow string = "Duplicate Flow"
+ ErrDuplicateFlow string = "duplicate flow"
+ //Unknown_Port_ID - indicates that the port id is unknown
+ Unknown_Port_ID = "unknown port id"
+ //Duplicate_Port - indicates the port is already exist in controller
+ Duplicate_Port = "duplicate port"
)
// DevicePort structure
@@ -253,7 +257,7 @@
d.DelFlowFromDb(cntx, flow.Cookie)
return nil
}
- return errors.New("Flow does not Exist")
+ return errors.New("flow does not exist")
}
// DelFlowFromDb is utility to delete the flow from the device
@@ -287,7 +291,7 @@
d.DelFlowFromDb(cntx, flow.OldCookie)
return nil
}
- return errors.New("Flow does not Exist")
+ return errors.New("flow does not exist")
}
// RestoreFlowsFromDb to restore flows from database
@@ -386,7 +390,7 @@
d.meterLock.Lock()
defer d.meterLock.Unlock()
if _, ok := d.meters[meter.ID]; ok {
- return errors.New("Duplicate Meter")
+ return errors.New("duplicate meter")
}
d.meters[meter.ID] = meter
go d.AddMeterToDb(cntx, meter)
@@ -401,7 +405,7 @@
d.meters[meter.ID] = meter
d.AddMeterToDb(cntx, meter)
} else {
- return errors.New("Meter not found for updation")
+ return errors.New("meter not found for updation")
}
return nil
}
@@ -413,7 +417,7 @@
if m, ok := d.meters[id]; ok {
return m, nil
}
- return nil, errors.New("Meter Not Found")
+ return nil, errors.New("meter not found")
}
// DelMeter to delete meter
@@ -483,10 +487,10 @@
id := mp.PortNo
name := mp.Name
if _, ok := d.PortsByID[id]; ok {
- return errors.New("Duplicate port")
+ return errors.New(Duplicate_Port)
}
if _, ok := d.PortsByName[name]; ok {
- return errors.New("Duplicate port")
+ return errors.New(Duplicate_Port)
}
p := NewDevicePort(mp)
@@ -503,7 +507,7 @@
func (d *Device) DelPort(cntx context.Context, id uint32) error {
p := d.GetPortByID(id)
if p == nil {
- return errors.New("Unknown Port")
+ return errors.New("unknown port")
}
if p.State == PortStateUp {
GetController().PortDownInd(cntx, d.ID, p.Name)
@@ -546,7 +550,7 @@
return p.Name, nil
}
logger.Errorw(ctx, "Port not found", log.Fields{"port": id})
- return "", errors.New("Unknown Port ID")
+ return "", errors.New(Unknown_Port_ID)
}
// GetPortByID is utility to retrieve the port by ID
@@ -581,7 +585,7 @@
if p, ok := d.PortsByName[name]; ok {
return p.State, nil
}
- return PortStateDown, errors.New("Unknown Port ID")
+ return PortStateDown, errors.New(Unknown_Port_ID)
}
// GetPortID to get the port-id by the port name
@@ -592,7 +596,7 @@
if p, ok := d.PortsByName[name]; ok {
return p.ID, nil
}
- return 0, errors.New("Unknown Port ID")
+ return 0, errors.New(Unknown_Port_ID)
}
// WritePortToDb to add the port to the database
@@ -633,7 +637,7 @@
d.PortsByName[port.Name] = &port
GetController().PortAddInd(cntx, d.ID, port.ID, port.Name)
} else {
- logger.Warnw(ctx, "Duplicate Port", log.Fields{"ID": port.ID})
+ logger.Warnw(ctx, Duplicate_Port, log.Fields{"ID": port.ID})
}
} else {
logger.Warnw(ctx, "Unmarshal failed", log.Fields{"port": string(b)})
@@ -907,11 +911,11 @@
func (d *Device) PacketOutReq(outport string, inport string, data []byte, isCustomPkt bool) error {
inp, err := d.GetPortID(inport)
if err != nil {
- return errors.New("Unknown inport")
+ return errors.New("unknown inport")
}
outp, err1 := d.GetPortID(outport)
if err1 != nil {
- return errors.New("Unknown outport")
+ return errors.New("unknown outport")
}
logger.Debugw(ctx, "Sending packet out", log.Fields{"Device": d.ID, "Inport": inport, "Outport": outport})
return d.SendPacketOut(outp, inp, data, isCustomPkt)
diff --git a/internal/pkg/controller/device_test.go b/internal/pkg/controller/device_test.go
new file mode 100644
index 0000000..11084fd
--- /dev/null
+++ b/internal/pkg/controller/device_test.go
@@ -0,0 +1,211 @@
+/*
+* 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"
+ "testing"
+ "voltha-go-controller/internal/pkg/holder"
+ "voltha-go-controller/internal/pkg/of"
+ "voltha-go-controller/internal/test/mocks"
+
+ "github.com/golang/mock/gomock"
+ ofp "github.com/opencord/voltha-protos/v5/go/openflow_13"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestNewDevicePort(t *testing.T) {
+ type args struct {
+ mp *ofp.OfpPort
+ }
+ tests := []struct {
+ name string
+ args args
+ want *DevicePort
+ }{
+ {
+ name: "NewDevicePort",
+ args: args{
+ mp: &ofp.OfpPort{
+ PortNo: uint32(1),
+ },
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := NewDevicePort(tt.args.mp)
+ assert.NotNil(t, got)
+ })
+ }
+}
+
+func TestDevice_UpdateFlows(t *testing.T) {
+ type args struct {
+ flow *of.VoltFlow
+ devPort *DevicePort
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "Device_UpdateFlows",
+ args: args{
+ flow: &of.VoltFlow{
+ PortName: "test_port_name",
+ },
+ devPort: &DevicePort{
+ Name: "test_name",
+ },
+ },
+ },
+ }
+ for _, tt := range tests {
+ flushQueue := make(map[uint32]*UniIDFlowQueue)
+ flushQueue[uint32(1)] = &UniIDFlowQueue{
+ ID: uint32(1),
+ }
+ t.Run(tt.name, func(t *testing.T) {
+ d := &Device{
+ flowQueue: flushQueue,
+ flowHash: uint32(1),
+ }
+ d.UpdateFlows(tt.args.flow, tt.args.devPort)
+ })
+ }
+}
+
+func TestNewDevice(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ id string
+ slno string
+ vclientHldr *holder.VolthaServiceClientHolder
+ southBoundID string
+ mfr string
+ hwDesc string
+ swDesc string
+ }
+ tests := []struct {
+ name string
+ args args
+ want *Device
+ }{
+ {
+ name: "TestNewDevice",
+ args: args{
+ cntx: context.Background(),
+ id: "test_id",
+ slno: "test_sl_no",
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().GetFlowHash(gomock.Any(), gomock.Any()).Return("1", nil).Times(1)
+ got := NewDevice(tt.args.cntx, tt.args.id, tt.args.slno, tt.args.vclientHldr, tt.args.southBoundID, tt.args.mfr, tt.args.hwDesc, tt.args.swDesc)
+ assert.NotNil(t, got)
+ })
+ }
+}
+
+func TestDevice_triggerFlowResultNotification(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ cookie uint64
+ flow *of.VoltSubFlow
+ oper of.Command
+ bwDetails of.BwAvailDetails
+ err error
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "Device_triggerFlowResultNotification",
+ args: args{
+ cntx: context.Background(),
+ cookie: uint64(1),
+ flow: &of.VoltSubFlow{
+ Cookie: uint64(1),
+ },
+ oper: of.CommandAdd,
+ bwDetails: of.BwAvailDetails{
+ PrevBw: "test_prev_bw",
+ },
+ err: nil,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ flows := make(map[uint64]*of.VoltSubFlow)
+ flows[uint64(1)] = &of.VoltSubFlow{
+ Cookie: uint64(1),
+ }
+ d := &Device{
+ flows: flows,
+ }
+ appMock := mocks.NewMockApp(gomock.NewController(t))
+ _ = NewController(context.Background(), appMock)
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().PutFlow(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).Times(1)
+ appMock.EXPECT().ProcessFlowModResultIndication(gomock.Any(), gomock.Any()).Times(1)
+ d.triggerFlowResultNotification(tt.args.cntx, tt.args.cookie, tt.args.flow, tt.args.oper, tt.args.bwDetails, tt.args.err)
+ })
+ }
+}
+
+func TestDevice_ResetCache(t *testing.T) {
+ tests := []struct {
+ name string
+ }{
+ {
+ name: "Device_ResetCache",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ d := &Device{}
+ d.ResetCache()
+ })
+ }
+}
+
+func TestDevice_GetAllFlows(t *testing.T) {
+ tests := []struct {
+ name string
+ want []*of.VoltSubFlow
+ }{
+ {
+ name: "Device_GetAllFlows",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ d := &Device{}
+ if got := d.GetAllFlows(); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("Device.GetAllFlows() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
diff --git a/internal/pkg/controller/modmeter_test.go b/internal/pkg/controller/modmeter_test.go
new file mode 100644
index 0000000..fb7df0f
--- /dev/null
+++ b/internal/pkg/controller/modmeter_test.go
@@ -0,0 +1,182 @@
+/*
+* 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"
+ "sync"
+ "testing"
+ "voltha-go-controller/internal/pkg/holder"
+ "voltha-go-controller/internal/pkg/of"
+ "voltha-go-controller/internal/test/mocks"
+
+ "github.com/golang/mock/gomock"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestModMeterTask_Start(t *testing.T) {
+ type args struct {
+ ctx context.Context
+ taskID uint8
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "mmt.command == of.MeterCommandAdd",
+ args: args{
+ ctx: context.Background(),
+ taskID: uint8(1),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ meters := make(map[uint32]*of.Meter)
+ meters[uint32(1)] = &of.Meter{
+ ID: uint32(1),
+ }
+ volthaClientMock := mocks.NewMockVolthaServiceClient(gomock.NewController(t))
+ mmt := &ModMeterTask{
+ meter: &of.Meter{
+ ID: uint32(1),
+ },
+ device: &Device{
+ meterLock: sync.RWMutex{},
+ meters: meters,
+ State: DeviceStateUP,
+ vclientHolder: &holder.VolthaServiceClientHolder{
+ VolthaSvcClient: volthaClientMock,
+ },
+ },
+ }
+ mmt.meter.ID = uint32(2)
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().DelDeviceMeter(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+ volthaClientMock.EXPECT().UpdateLogicalDeviceMeterTable(gomock.Any(), gomock.Any()).Return(nil, nil).AnyTimes()
+ err := mmt.Start(tt.args.ctx, tt.args.taskID)
+ assert.Nil(t, err)
+ })
+ }
+}
+
+func TestNewModMeterTask(t *testing.T) {
+ type args struct {
+ ctx context.Context
+ command of.MeterCommand
+ meter *of.Meter
+ device *Device
+ }
+ tests := []struct {
+ name string
+ args args
+ want *ModMeterTask
+ }{
+ {
+ name: "NewModMeterTask",
+ args: args{
+ ctx: context.Background(),
+ command: of.MeterCommandAdd,
+ meter: &of.Meter{
+ ID: uint32(1),
+ },
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := NewModMeterTask(tt.args.ctx, tt.args.command, tt.args.meter, tt.args.device)
+ assert.NotNil(t, got)
+ })
+ }
+}
+
+func TestModMeterTask_Name(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ {
+ name: "ModMeterTask_Name",
+ want: "Add Flows Task",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ mmt := &ModMeterTask{}
+ if got := mmt.Name(); got != tt.want {
+ t.Errorf("ModMeterTask.Name() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestModMeterTask_TaskID(t *testing.T) {
+ tests := []struct {
+ name string
+ want uint8
+ }{
+ {
+ name: "ModMeterTask_TaskID",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ mmt := &ModMeterTask{}
+ if got := mmt.TaskID(); got != tt.want {
+ t.Errorf("ModMeterTask.TaskID() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestModMeterTask_Timestamp(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ {
+ name: "ModMeterTask_Timestamp",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ mmt := &ModMeterTask{}
+ if got := mmt.Timestamp(); got != tt.want {
+ t.Errorf("ModMeterTask.Timestamp() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestModMeterTask_Stop(t *testing.T) {
+ tests := []struct {
+ name string
+ }{
+ {
+ name: "ModMeterTask_Stop",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ mmt := &ModMeterTask{}
+ mmt.Stop()
+ })
+ }
+}
diff --git a/internal/pkg/controller/pendingprofiles_test.go b/internal/pkg/controller/pendingprofiles_test.go
index fe0639c..dfb17f6 100644
--- a/internal/pkg/controller/pendingprofiles_test.go
+++ b/internal/pkg/controller/pendingprofiles_test.go
@@ -21,6 +21,7 @@
"voltha-go-controller/internal/test/mocks"
"github.com/golang/mock/gomock"
+ "github.com/stretchr/testify/assert"
)
func TestPendingProfilesTask_Start(t *testing.T) {
@@ -60,3 +61,103 @@
})
}
}
+
+func TestNewPendingProfilesTask(t *testing.T) {
+ type args struct {
+ device *Device
+ }
+ tests := []struct {
+ name string
+ args args
+ want *PendingProfilesTask
+ }{
+ {
+ name: "NewPendingProfilesTask",
+ args: args{
+ device: &Device{
+ ctx: context.Background(),
+ },
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := NewPendingProfilesTask(tt.args.device)
+ assert.NotNil(t, got)
+ })
+ }
+}
+
+func TestPendingProfilesTask_Name(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ {
+ name: "PendingProfilesTask_Name",
+ want: "Pending Profiles Task",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ ppt := &PendingProfilesTask{}
+ if got := ppt.Name(); got != tt.want {
+ t.Errorf("PendingProfilesTask.Name() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestPendingProfilesTask_TaskID(t *testing.T) {
+ tests := []struct {
+ name string
+ want uint8
+ }{
+ {
+ name: "PendingProfilesTask_TaskID",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ ppt := &PendingProfilesTask{}
+ if got := ppt.TaskID(); got != tt.want {
+ t.Errorf("PendingProfilesTask.TaskID() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestPendingProfilesTask_Timestamp(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ {
+ name: "PendingProfilesTask_Timestamp",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ ppt := &PendingProfilesTask{}
+ if got := ppt.Timestamp(); got != tt.want {
+ t.Errorf("PendingProfilesTask.Timestamp() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestPendingProfilesTask_Stop(t *testing.T) {
+ tests := []struct {
+ name string
+ }{
+ {
+ name: "PendingProfilesTask_Stop",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ ppt := &PendingProfilesTask{}
+ ppt.Stop()
+ })
+ }
+}
diff --git a/internal/pkg/controller/utils_test.go b/internal/pkg/controller/utils_test.go
new file mode 100644
index 0000000..323b388
--- /dev/null
+++ b/internal/pkg/controller/utils_test.go
@@ -0,0 +1,66 @@
+/*
+* 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 (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func TestPadString(t *testing.T) {
+ type args struct {
+ value string
+ padSize int
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "PadString",
+ args: args{
+ value: "test_value",
+ padSize: 20,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := PadString(tt.args.value, tt.args.padSize)
+ assert.NotNil(t, got)
+ })
+ }
+}
+
+func TestGetXid(t *testing.T) {
+ tests := []struct {
+ name string
+ want uint32
+ }{
+ {
+ name: "GetXid",
+ want: uint32(2),
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := GetXid(); got != tt.want {
+ t.Errorf("GetXid() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}