[FTTH-59259] Ut coverage for vgc upto 50%
Change-Id: I0ae047de26ec913a34fd2f8001ec3cbe170155a9
diff --git a/internal/pkg/application/igmptasks_test.go b/internal/pkg/application/igmptasks_test.go
new file mode 100644
index 0000000..8a71b29
--- /dev/null
+++ b/internal/pkg/application/igmptasks_test.go
@@ -0,0 +1,167 @@
+/*
+* 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 application
+
+import (
+ "context"
+ "testing"
+ "voltha-go-controller/internal/pkg/of"
+
+ "github.com/google/gopacket"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestTickTask_Name(t *testing.T) {
+ tt := &TickTask{}
+ got := tt.Name()
+ assert.NotNil(t, got)
+ got1 := tt.TaskID()
+ assert.NotNil(t, got1)
+ got2 := tt.Timestamp()
+ assert.NotNil(t, got2)
+ ipk := IgmpPacketTask{}
+ got3 := ipk.Name()
+ assert.NotNil(t, got3)
+ got4 := ipk.TaskID()
+ assert.NotNil(t, got4)
+ got5 := ipk.Timestamp()
+ assert.NotNil(t, got5)
+ mt := &UpdateMvlanTask{}
+ got6 := mt.Name()
+ assert.NotNil(t, got6)
+ got7 := mt.TaskID()
+ assert.NotNil(t, got7)
+ got8 := mt.Timestamp()
+ assert.NotNil(t, got8)
+ got9 := NewTickTask()
+ assert.NotNil(t, got9)
+}
+
+func TestTickTask_Start(t *testing.T) {
+ type args struct {
+ ctx context.Context
+ taskID uint8
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "TickTask_Start",
+ args: args{
+ ctx: context.Background(),
+ },
+ wantErr: false,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ tt1 := &TickTask{}
+ if err := tt1.Start(tt.args.ctx, tt.args.taskID); (err != nil) != tt.wantErr {
+ t.Errorf("TickTask.Start() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestNewIgmpPacketTask(t *testing.T) {
+ type args struct {
+ device string
+ port string
+ pkt gopacket.Packet
+ }
+ tests := []struct {
+ name string
+ args args
+ want *IgmpPacketTask
+ }{
+ {
+ name: "NewIgmpPacketTask",
+ args: args{
+ device: "SDX6320031",
+ port: "16777472",
+ },
+ want: &IgmpPacketTask{},
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := NewIgmpPacketTask(tt.args.device, tt.args.port, tt.args.pkt)
+ assert.NotNil(t, got)
+ })
+ }
+}
+
+func TestNewUpdateMvlanTask(t *testing.T) {
+ type args struct {
+ mvp *MvlanProfile
+ deviceID string
+ }
+ tests := []struct {
+ name string
+ args args
+ want *UpdateMvlanTask
+ }{
+ {
+ name: "NewUpdateMvlanTask",
+ args: args{
+ mvp: &MvlanProfile{},
+ deviceID: "SDX6320031",
+ },
+ want: &UpdateMvlanTask{},
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := NewUpdateMvlanTask(tt.args.mvp, tt.args.deviceID)
+ assert.NotNil(t, got)
+ })
+ }
+}
+
+func TestUpdateMvlanTask_Start(t *testing.T) {
+ type args struct {
+ ctx context.Context
+ taskID uint8
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "UpdateMvlanTask_Start",
+ args: args{
+ ctx: context.Background(),
+ taskID: uint8(123),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ mt := &UpdateMvlanTask{
+ DeviceID: "SDX6320031",
+ mvp: &MvlanProfile{
+ Mvlan: of.VlanAny,
+ },
+ }
+ if err := mt.Start(tt.args.ctx, tt.args.taskID); (err != nil) != tt.wantErr {
+ t.Errorf("UpdateMvlanTask.Start() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
diff --git a/internal/pkg/application/major_upgrade_test.go b/internal/pkg/application/major_upgrade_test.go
index 47e1f45..c0bb684 100644
--- a/internal/pkg/application/major_upgrade_test.go
+++ b/internal/pkg/application/major_upgrade_test.go
@@ -140,6 +140,9 @@
data []byte
}
vpvmap := make(map[string]interface{})
+ vpvmap["MacLearning"] = true
+ vpvmap["UsFlowsApplied"] = true
+ vpvmap["DsFlowsApplied"] = true
byteData, _ := json.Marshal(&vpvmap)
tests := []struct {
name string
diff --git a/internal/pkg/application/pppoeia_test.go b/internal/pkg/application/pppoeia_test.go
index fc07d1f..0b8ed04 100644
--- a/internal/pkg/application/pppoeia_test.go
+++ b/internal/pkg/application/pppoeia_test.go
@@ -296,3 +296,42 @@
})
}
}
+
+func TestNewPppoeIaPacketTask(t *testing.T) {
+ type args struct {
+ pkt gopacket.Packet
+ dev string
+ port string
+ }
+ pkt := mocks.NewMockPacket(gomock.NewController(t))
+ tests := []struct {
+ name string
+ args args
+ want *PppoeIaPacketTask
+ }{
+ {
+ name: "NewPppoeIaPacketTask",
+ args: args{
+ pkt: pkt,
+ dev: test_device,
+ port: "test_port",
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := NewPppoeIaPacketTask(tt.args.pkt, tt.args.dev, tt.args.port)
+ assert.NotNil(t, got)
+ })
+ }
+}
+
+func TestPppoeIaPacketTask_Name(t *testing.T) {
+ dpt := &PppoeIaPacketTask{}
+ got := dpt.Name()
+ assert.NotNil(t, got)
+ got1 := dpt.TaskID()
+ assert.NotNil(t, got1)
+ got2 := dpt.Timestamp()
+ assert.NotNil(t, got2)
+}
diff --git a/internal/pkg/application/service.go b/internal/pkg/application/service.go
index 6c44450..d93c8f4 100644
--- a/internal/pkg/application/service.go
+++ b/internal/pkg/application/service.go
@@ -2085,7 +2085,7 @@
} else if !vs.DsHSIAFlowsApplied && !vs.UsHSIAFlowsApplied {
flowProvisionStatus.FlowProvisionStatus = NO_FLOWS_PROVISIONED
return false
- } else if vs.LenOfPendingFlows() > 0 {
+ } else if vs.DsHSIAFlowsApplied && vs.UsHSIAFlowsApplied && vs.LenOfPendingFlows() > 0 {
flowProvisionStatus.FlowProvisionStatus = FLOWS_PROVISIONED_PARTIALLY
return false
}
diff --git a/internal/pkg/application/service_test.go b/internal/pkg/application/service_test.go
index 0f07347..83e39d7 100644
--- a/internal/pkg/application/service_test.go
+++ b/internal/pkg/application/service_test.go
@@ -3073,3 +3073,100 @@
})
}
}
+
+func TestVoltApplication_GetFlowProvisionStatus(t *testing.T) {
+ type args struct {
+ portNo string
+ }
+ voltServ := &VoltService{
+ VoltServiceCfg: VoltServiceCfg{
+ Port: "SDX6320031-1",
+ IsActivated: true,
+ },
+ VoltServiceOper: VoltServiceOper{
+ Device: "SDX6320031",
+ DsHSIAFlowsApplied: true,
+ UsHSIAFlowsApplied: true,
+ },
+ }
+ tests := []struct {
+ name string
+ args args
+ want FlowProvisionStatus
+ }{
+ {
+ name: "ALL_FLOWS_PROVISIONED",
+ args: args{
+ portNo: "SDX6320031-1",
+ },
+ want: FlowProvisionStatus{
+ FlowProvisionStatus: "ALL_FLOWS_PROVISIONED",
+ },
+ },
+ {
+ name: "SUBSCRIBER_DISABLED_IN_CONTROLLER",
+ args: args{
+ portNo: "SDX6320031-1",
+ },
+ want: FlowProvisionStatus{
+ FlowProvisionStatus: "DISABLED_IN_CONTROLLER",
+ },
+ },
+ {
+ name: "FLOWS_PROVISIONED_PARTIALLY",
+ args: args{
+ portNo: "SDX6320031-1",
+ },
+ want: FlowProvisionStatus{
+ FlowProvisionStatus: "FLOWS_PROVISIONED_PARTIALLY",
+ },
+ },
+ {
+ name: "NO_FLOWS_PROVISIONED",
+ args: args{
+ portNo: "SDX6320031-1",
+ },
+ want: FlowProvisionStatus{
+ FlowProvisionStatus: "NO_FLOWS_PROVISIONED",
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ va := &VoltApplication{}
+ switch tt.name {
+ case "ALL_FLOWS_PROVISIONED":
+ va.ServiceByName.Store("SCOM00001c75-1_SCOM00001c75-1-4096-2310-4096-65", voltServ)
+ if got := va.GetFlowProvisionStatus(tt.args.portNo); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltApplication.GetFlowProvisionStatus() = %v, want %v", got, tt.want)
+ }
+ case "SUBSCRIBER_DISABLED_IN_CONTROLLER":
+ voltServ1 := &VoltService{
+ VoltServiceCfg: VoltServiceCfg{
+ Port: "SDX6320031-1",
+ IsActivated: false,
+ },
+ }
+ va.ServiceByName.Store("SCOM00001c75-1_SCOM00001c75-1-4096-2310-4096-65", voltServ1)
+ if got := va.GetFlowProvisionStatus(tt.args.portNo); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltApplication.GetFlowProvisionStatus() = %v, want %v", got, tt.want)
+ }
+ case "FLOWS_PROVISIONED_PARTIALLY":
+ pendingFlows := map[string]bool{}
+ pendingFlows["test"] = true
+ voltServ.PendingFlows = pendingFlows
+ va.ServiceByName.Store("SCOM00001c75-1_SCOM00001c75-1-4096-2310-4096-65", voltServ)
+ if got := va.GetFlowProvisionStatus(tt.args.portNo); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltApplication.GetFlowProvisionStatus() = %v, want %v", got, tt.want)
+ }
+ case "NO_FLOWS_PROVISIONED":
+ voltServ.UsHSIAFlowsApplied = false
+ voltServ.DsHSIAFlowsApplied = false
+ va.ServiceByName.Store("SCOM00001c75-1_SCOM00001c75-1-4096-2310-4096-65", voltServ)
+ if got := va.GetFlowProvisionStatus(tt.args.portNo); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltApplication.GetFlowProvisionStatus() = %v, want %v", got, tt.want)
+ }
+ }
+ })
+ }
+}
diff --git a/internal/pkg/application/vnets_test.go b/internal/pkg/application/vnets_test.go
index 5a26bea..a8353d6 100644
--- a/internal/pkg/application/vnets_test.go
+++ b/internal/pkg/application/vnets_test.go
@@ -28,8 +28,10 @@
"voltha-go-controller/internal/test/mocks"
"github.com/golang/mock/gomock"
+ "github.com/google/gopacket/layers"
"github.com/opencord/voltha-lib-go/v7/pkg/db/kvstore"
"github.com/stretchr/testify/assert"
+ "go.uber.org/atomic"
)
func TestVoltPortVnet_JSONMarshal(t *testing.T) {
@@ -894,3 +896,470 @@
})
}
}
+
+func TestNewVoltPortVnet(t *testing.T) {
+ type args struct {
+ vnet *VoltVnet
+ }
+ usDhcpPbit := []of.PbitType{}
+ usDhcpPbit = append(usDhcpPbit, PbitMatchNone)
+ tests := []struct {
+ name string
+ args args
+ want *VoltPortVnet
+ }{
+ {
+ name: "NewVoltPortVnet",
+ args: args{
+ vnet: &VoltVnet{
+ VnetConfig: VnetConfig{
+ UsDhcpPbit: usDhcpPbit,
+ },
+ },
+ },
+ want: &VoltPortVnet{},
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ got := NewVoltPortVnet(tt.args.vnet)
+ assert.NotNil(t, got)
+ })
+ }
+}
+
+func TestVoltPortVnet_GetCircuitID(t *testing.T) {
+ vpv := &VoltPortVnet{}
+ got := vpv.GetCircuitID()
+ assert.Nil(t, got)
+ got1 := vpv.GetRemoteID()
+ assert.Nil(t, got1)
+ got3 := vpv.GetDhcpState()
+ assert.NotNil(t, got3)
+ got4 := vpv.GetPppoeIaState()
+ assert.NotNil(t, got4)
+ got5 := vpv.GetDhcpv6State()
+ assert.NotNil(t, got5)
+}
+
+func TestVoltPortVnet_GetNniVlans(t *testing.T) {
+ tests := []struct {
+ name string
+ want uint16
+ want1 uint16
+ }{
+ {
+ name: "GetNniVlans",
+ want: uint16(of.VlanAny),
+ want1: uint16(of.VlanAny),
+ },
+ {
+ name: "GetNniVlans_OLTSVlan",
+ want: uint16(of.VlanAny),
+ want1: uint16(of.VlanNone),
+ },
+ {
+ name: "GetNniVlans_Default",
+ want: uint16(of.VlanNone),
+ want1: uint16(of.VlanNone),
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ VlanControl: ONUCVlanOLTSVlan,
+ SVlan: of.VlanAny,
+ CVlan: of.VlanAny,
+ }
+ switch tt.name {
+ case "GetNniVlans":
+ got, got1 := vpv.GetNniVlans()
+ if got != tt.want {
+ t.Errorf("VoltPortVnet.GetNniVlans() got = %v, want %v", got, tt.want)
+ }
+ if got1 != tt.want1 {
+ t.Errorf("VoltPortVnet.GetNniVlans() got1 = %v, want %v", got1, tt.want1)
+ }
+ case "GetNniVlans_OLTSVlan":
+ vpv.VlanControl = OLTSVlan
+ got, got1 := vpv.GetNniVlans()
+ if got != tt.want {
+ t.Errorf("VoltPortVnet.GetNniVlans() got = %v, want %v", got, tt.want)
+ }
+ if got1 != tt.want1 {
+ t.Errorf("VoltPortVnet.GetNniVlans() got1 = %v, want %v", got1, tt.want1)
+ }
+ case "GetNniVlans_Default":
+ vpv.VlanControl = opt82
+ got, got1 := vpv.GetNniVlans()
+ if got != tt.want {
+ t.Errorf("VoltPortVnet.GetNniVlans() got = %v, want %v", got, tt.want)
+ }
+ if got1 != tt.want1 {
+ t.Errorf("VoltPortVnet.GetNniVlans() got1 = %v, want %v", got1, tt.want1)
+ }
+ }
+ })
+ }
+}
+
+func TestVoltPortVnet_GetService(t *testing.T) {
+ type args struct {
+ name string
+ }
+ voltServ := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ Device: "SDX6320031",
+ },
+ VoltServiceCfg: VoltServiceCfg{
+ IsActivated: true,
+ },
+ }
+ tests := []struct {
+ name string
+ args args
+ want *VoltService
+ want1 bool
+ }{
+ {
+ name: "GetService",
+ args: args{
+ name: "SDX6320031-1_SDX6320031-1-4096-2310-4096-65",
+ },
+ want: voltServ,
+ want1: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{}
+ vpv.services.Store("SDX6320031-1_SDX6320031-1-4096-2310-4096-65", voltServ)
+ got, got1 := vpv.GetService(tt.args.name)
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("VoltPortVnet.GetService() got = %v, want %v", got, tt.want)
+ }
+ if got1 != tt.want1 {
+ t.Errorf("VoltPortVnet.GetService() got1 = %v, want %v", got1, tt.want1)
+ }
+ })
+ }
+}
+
+func TestVoltPortVnet_ProcessDhcpSuccess(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ res *layers.DHCPv4
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "ProcessDhcpSuccess",
+ args: args{
+ cntx: context.Background(),
+ res: &layers.DHCPv4{},
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ servicesCount: atomic.NewUint64(0),
+ }
+ vpv.ProcessDhcpSuccess(tt.args.cntx, tt.args.res)
+ })
+ }
+}
+
+func TestVoltPortVnet_ProcessDhcpResult(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ res *layers.DHCPv4
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "ProcessDhcpResult",
+ args: args{
+ cntx: context.Background(),
+ res: &layers.DHCPv4{},
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{}
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().PutVpv(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+ vpv.ProcessDhcpResult(tt.args.cntx, tt.args.res)
+ })
+ }
+}
+
+func TestVoltVnet_associatePortToVnet(t *testing.T) {
+ type args struct {
+ port string
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "ProcessDhcpResult",
+ args: args{
+ port: "SDX6320031-1",
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vv := &VoltVnet{}
+ vv.associatePortToVnet(tt.args.port)
+ })
+ }
+}
+
+func TestVoltPortVnet_ProcessDhcpv6Result(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ ipv6Addr net.IP
+ leaseTime uint32
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "ProcessDhcpResult",
+ args: args{
+ cntx: context.Background(),
+ ipv6Addr: AllSystemsMulticastGroupIP,
+ leaseTime: uint32(128),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{}
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().PutVpv(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+ vpv.ProcessDhcpv6Result(tt.args.cntx, tt.args.ipv6Addr, tt.args.leaseTime)
+ })
+ }
+}
+
+func TestAddSvcUsMeterToDevice(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ key interface{}
+ value interface{}
+ flag bool
+ }
+ vpv := &VoltApplication{}
+ voltServ := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ Device: test_device,
+ ForceDelete: true,
+ },
+ }
+ vpv.ServiceByName.Store(test_device, voltServ)
+ tests := []struct {
+ name string
+ args args
+ want bool
+ }{
+ {
+ name: "ProcessDhcpResult",
+ args: args{
+ cntx: context.Background(),
+ key: test_device,
+ value: voltServ,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := AddSvcUsMeterToDevice(tt.args.cntx, tt.args.key, tt.args.value, tt.args.flag); got != tt.want {
+ t.Errorf("AddSvcUsMeterToDevice() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestClearFlagsInService(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ key interface{}
+ value interface{}
+ flag bool
+ }
+ vpv := &VoltPortVnet{}
+ voltServ := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ Device: "SDX6320031",
+ },
+ VoltServiceCfg: VoltServiceCfg{
+ IsActivated: true,
+ },
+ }
+ vpv.services.Store("SDX6320031-1_SDX6320031-1-4096-2310-4096-65", voltServ)
+ tests := []struct {
+ name string
+ args args
+ want bool
+ }{
+ {
+ name: "ClearFlagsInService",
+ args: args{
+ cntx: context.Background(),
+ key: test_device,
+ value: voltServ,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+ got := ClearFlagsInService(tt.args.cntx, tt.args.key, tt.args.value, tt.args.flag)
+ assert.NotNil(t, got)
+ })
+ }
+}
+
+func TestVoltPortVnet_DelDhcpFlows(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "DelDhcpFlows",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{}
+ vpv.DelDhcpFlows(tt.args.cntx)
+ })
+ }
+}
+
+func TestVoltPortVnet_AddDsDhcpFlows(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ va := GetApplication()
+ voltDev := &VoltDevice{
+ Name: "49686e2d-618f-4e8e-bca0-442ab850a63a",
+ SerialNum: "SDX6320031",
+ NniDhcpTrapVid: 123,
+ State: cntlr.DeviceStateUP,
+ FlowAddEventMap: util.NewConcurrentMap(),
+ }
+ va.DevicesDisc.Store("SDX6320031", voltDev)
+ voltPort := &VoltPort{
+ Name: "49686e2d-618f-4e8e-bca0-442ab850a63a",
+ Device: "SDX6320031",
+ ID: 16777472,
+ State: PortStateDown,
+ ChannelPerSubAlarmRaised: false,
+ Type: VoltPortTypeNni,
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "AddDsDhcpFlows",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: "AddDsDhcpFlows_DeviceNotFound",
+ args: args{
+ cntx: context.Background(),
+ },
+ wantErr: true,
+ },
+ {
+ name: "AddDsDhcpFlows_StateDown",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: "AddDsDhcpFlows_GlobalDhcpFlowAdded",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: "AddDsDhcpFlows_PositiveSenario",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ Device: "SDX6320031",
+ }
+ switch tt.name {
+ case "AddDsDhcpFlows":
+ if err := vpv.AddDsDhcpFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddDsDhcpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "AddDsDhcpFlows_DeviceNotFound":
+ vpv.Device = ""
+ if err := vpv.AddDsDhcpFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddDsDhcpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "AddDsDhcpFlows_StateDown":
+ voltDev.State = cntlr.DeviceStateDOWN
+ if err := vpv.AddDsDhcpFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddDsDhcpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "AddDsDhcpFlows_GlobalDhcpFlowAdded":
+ vpv.Device = "SDX6320031"
+ voltDev.State = cntlr.DeviceStateUP
+ voltDev.GlobalDhcpFlowAdded = true
+ if err := vpv.AddDsDhcpFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddDsDhcpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "AddDsDhcpFlows_PositiveSenario":
+ vpv.Device = "SDX6320031"
+ voltDev.State = cntlr.DeviceStateUP
+ voltDev.GlobalDhcpFlowAdded = false
+ voltDev.NniPort = "16777472"
+ va.PortsDisc.Store("16777472", voltPort)
+ appMock := mocks.NewMockApp(gomock.NewController(t))
+ cntlr.NewController(ctx, appMock)
+ vc := cntlr.GetController()
+ device := &cntlr.Device{
+ ID: "SDX6320031",
+ }
+ dev := map[string]*cntlr.Device{}
+ dev["SDX6320031"] = device
+ vc.Devices = dev
+ if err := vpv.AddDsDhcpFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddDsDhcpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ }
+ })
+ }
+}