UT-Coverage upto 53%
Change-Id: I34e860354d56a40fa97bc2b0143bcd37e00072d1
diff --git a/internal/pkg/application/vnets_test.go b/internal/pkg/application/vnets_test.go
index a8353d6..f224278 100644
--- a/internal/pkg/application/vnets_test.go
+++ b/internal/pkg/application/vnets_test.go
@@ -22,6 +22,7 @@
"reflect"
"sync"
"testing"
+ "voltha-go-controller/internal/pkg/controller"
cntlr "voltha-go-controller/internal/pkg/controller"
"voltha-go-controller/internal/pkg/of"
"voltha-go-controller/internal/pkg/util"
@@ -34,6 +35,8 @@
"go.uber.org/atomic"
)
+const deviceName = "SDX6320031"
+
func TestVoltPortVnet_JSONMarshal(t *testing.T) {
tests := []struct {
name string
@@ -613,6 +616,35 @@
vnet *VoltVnet
deviceSerialNum string
}
+ voltDev := &VoltDevice{
+ Name: "SDX6320031",
+ SerialNum: "SDX6320031",
+ NniDhcpTrapVid: 123,
+ State: cntlr.DeviceStateUP,
+ NniPort: "16777472",
+ Ports: sync.Map{},
+ FlowDelEventMap: util.NewConcurrentMap(),
+ ConfiguredVlanForDeviceFlows: util.NewConcurrentMap(),
+ }
+ voltVnet = &VoltVnet{
+ Version: "v3",
+ VnetConfig: VnetConfig{
+ Name: "2310-4096-4096",
+ VnetType: "Encapsulation",
+ },
+ VnetOper: VnetOper{
+ PendingDeviceToDelete: "SDX6320031",
+ DeleteInProgress: true,
+ PendingDeleteFlow: make(map[string]map[string]bool),
+ },
+ }
+ voltPort := &VoltPort{
+ Name: "16777472",
+ Device: "SDX6320031",
+ ID: 16777472,
+ State: PortStateUp,
+ ChannelPerSubAlarmRaised: false,
+ }
tests := []struct {
name string
args args
@@ -621,31 +653,79 @@
name: "device.SerialNum != deviceSerialNum",
args: args{
cntx: context.Background(),
- vnet: &VoltVnet{
- Version: "test_version",
- },
+ vnet: voltVnet,
},
},
{
- name: "VoltApplication_DeleteDevFlowForVlanFromDevice",
+ name: "DeleteDevFlowForVlanFromDevice",
args: args{
- cntx: context.Background(),
- vnet: &VoltVnet{
- Version: "test_version",
- },
- deviceSerialNum: "test_serial_number",
+ cntx: context.Background(),
+ deviceSerialNum: "SDX6320031",
+ vnet: voltVnet,
+ },
+ },
+ {
+ name: "DeleteDevFlowForVlanFromDevice_PortStateDown",
+ args: args{
+ cntx: context.Background(),
+ deviceSerialNum: "SDX6320031",
+ vnet: voltVnet,
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- va := &VoltApplication{}
+ va := &VoltApplication{
+ DevicesDisc: sync.Map{},
+ }
switch tt.name {
case "device.SerialNum != deviceSerialNum":
va.DevicesDisc.Store(test_device, voltDevice)
va.DeleteDevFlowForVlanFromDevice(tt.args.cntx, tt.args.vnet, tt.args.deviceSerialNum)
- case "VoltApplication_DeleteDevFlowForVlanFromDevice":
- va.DevicesDisc.Store(test_device, voltDevice)
+ case "DeleteDevFlowForVlanFromDevice":
+ va.DevicesDisc.Store("SDX6320031", voltDev)
+ va.VnetsByName.Store("2310-4096-4096", voltVnet)
+ voltDev.ConfiguredVlanForDeviceFlows.Set("0-0-0", util.NewConcurrentMap())
+ va.PortsDisc.Store("16777472", voltPort)
+ appMock := mocks.NewMockApp(gomock.NewController(t))
+ cntlr.NewController(ctx, appMock)
+ vc := cntlr.GetController()
+ dev := map[string]*cntlr.Device{}
+ portsByName := map[string]*cntlr.DevicePort{}
+ portsByName["16777472"] = &cntlr.DevicePort{
+ Name: "16777472",
+ ID: 256,
+ State: cntlr.PortStateUp,
+ }
+ device := &cntlr.Device{
+ ID: "SDX6320031",
+ PortsByName: portsByName,
+ }
+ dev["SDX6320031"] = device
+ vc.Devices = dev
+ va.DeleteDevFlowForVlanFromDevice(tt.args.cntx, tt.args.vnet, tt.args.deviceSerialNum)
+ case "DeleteDevFlowForVlanFromDevice_PortStateDown":
+ voltDev.Name = ""
+ va.DevicesDisc.Store("SDX6320031", voltDev)
+ va.VnetsByName.Store("2310-4096-4096", voltVnet)
+ voltDev.ConfiguredVlanForDeviceFlows.Set("0-0-0", util.NewConcurrentMap())
+ va.PortsDisc.Store("16777472", voltPort)
+ appMock := mocks.NewMockApp(gomock.NewController(t))
+ cntlr.NewController(ctx, appMock)
+ vc := cntlr.GetController()
+ dev := map[string]*cntlr.Device{}
+ portsByName := map[string]*cntlr.DevicePort{}
+ portsByName["16777472"] = &cntlr.DevicePort{
+ Name: "16777472",
+ ID: 256,
+ State: cntlr.PortStateUp,
+ }
+ device := &cntlr.Device{
+ ID: "SDX6320031",
+ PortsByName: portsByName,
+ }
+ dev["SDX6320031"] = device
+ vc.Devices = dev
va.DeleteDevFlowForVlanFromDevice(tt.args.cntx, tt.args.vnet, tt.args.deviceSerialNum)
}
})
@@ -699,35 +779,76 @@
cntx context.Context
device *VoltDevice
}
+ voltDev := &VoltDevice{
+ Name: "SDX6320031",
+ SerialNum: "SDX6320031",
+ NniDhcpTrapVid: 123,
+ State: cntlr.DeviceStateUP,
+ NniPort: "16777472",
+ FlowDelEventMap: util.NewConcurrentMap(),
+ ConfiguredVlanForDeviceFlows: util.NewConcurrentMap(),
+ icmpv6GroupAdded: true,
+ }
+ voltVnet = &VoltVnet{
+ Version: "v3",
+ VnetConfig: VnetConfig{
+ Name: "2310-4096-4096",
+ VnetType: "Encapsulation",
+ },
+ VnetOper: VnetOper{
+ PendingDeviceToDelete: "SDX6320031",
+ DeleteInProgress: true,
+ PendingDeleteFlow: make(map[string]map[string]bool),
+ },
+ }
+ voltPort := &VoltPort{
+ Name: "16777472",
+ Device: "SDX6320031",
+ ID: 16777472,
+ State: PortStateUp,
+ ChannelPerSubAlarmRaised: false,
+ }
tests := []struct {
name string
args args
}{
{
- name: "VoltApplication_DeleteDevFlowForDevice",
+ name: "DeleteDevFlowForDevice",
args: args{
- cntx: context.Background(),
- device: &VoltDevice{
- Name: test_device,
- ConfiguredVlanForDeviceFlows: util.NewConcurrentMap(),
- },
+ cntx: context.Background(),
+ device: voltDev,
},
},
}
- var voltVnet_DeleteDevFlowForDevice = &VoltVnet{
- Version: "test_version",
- VnetConfig: VnetConfig{
- Name: "test_name",
- SVlan: of.VlanAny,
- CVlan: of.VlanAny,
- },
- }
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
va := &VoltApplication{}
- va.VnetsByName.Store("4096-4096-0", voltVnet_DeleteDevFlowForDevice)
- //tt.args.device.ConfiguredVlanForDeviceFlows.SyncMap.Store("4096-4069-0", util.NewConcurrentMap())
- va.DeleteDevFlowForDevice(tt.args.cntx, tt.args.device)
+ switch tt.name {
+ case "DeleteDevFlowForDevice":
+ va.DevicesDisc.Store("SDX6320031", voltDev)
+ va.VnetsByName.Store("2310-4096-4096", voltVnet)
+ voltDev.ConfiguredVlanForDeviceFlows.Set("0-0-0", util.NewConcurrentMap())
+ va.PortsDisc.Store("16777472", voltPort)
+ voltApp := GetApplication()
+ voltApp.DevicesDisc.Store("SDX6320031", voltDev)
+ appMock := mocks.NewMockApp(gomock.NewController(t))
+ cntlr.NewController(ctx, appMock)
+ vc := cntlr.GetController()
+ dev := map[string]*cntlr.Device{}
+ portsByName := map[string]*cntlr.DevicePort{}
+ portsByName["16777472"] = &cntlr.DevicePort{
+ Name: "16777472",
+ ID: 256,
+ State: cntlr.PortStateUp,
+ }
+ device := &cntlr.Device{
+ ID: "SDX6320031",
+ PortsByName: portsByName,
+ }
+ dev["SDX6320031"] = device
+ vc.Devices = dev
+ va.DeleteDevFlowForDevice(tt.args.cntx, tt.args.device)
+ }
})
}
}
@@ -786,6 +907,38 @@
cntx context.Context
vnet *VoltVnet
}
+ voltDev := &VoltDevice{
+ Name: "SDX6320031",
+ SerialNum: "SDX6320031",
+ NniDhcpTrapVid: 123,
+ State: cntlr.DeviceStateUP,
+ NniPort: "16777472",
+ FlowDelEventMap: util.NewConcurrentMap(),
+ ConfiguredVlanForDeviceFlows: util.NewConcurrentMap(),
+ icmpv6GroupAdded: true,
+ VlanPortStatus: sync.Map{},
+ }
+ voltVnet := &VoltVnet{
+ Version: "v3",
+ VnetConfig: VnetConfig{
+ Name: "2310-4096-4096",
+ VnetType: "Encapsulation",
+ DevicesList: []string{"SDX6320031"},
+ SVlan: 0,
+ },
+ VnetOper: VnetOper{
+ PendingDeviceToDelete: "SDX6320031",
+ DeleteInProgress: true,
+ PendingDeleteFlow: make(map[string]map[string]bool),
+ },
+ }
+ voltPort := &VoltPort{
+ Name: "16777216",
+ Device: "SDX6320031",
+ ID: 16777216,
+ State: PortStateUp,
+ ChannelPerSubAlarmRaised: false,
+ }
tests := []struct {
name string
args args
@@ -803,18 +956,39 @@
},
},
},
+ // {
+ // name: "PushDevFlowForVlan",
+ // args: args{
+ // cntx: context.Background(),
+ // vnet: voltVnet,
+ // },
+ // },
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
va := &VoltApplication{}
- voltDevice.SerialNum = "test_serialNum"
- voltDevice.VlanPortStatus.Store(uint16(of.VlanAny), true)
- voltDevice.Name = test_device
- va.DevicesDisc.Store(test_device, voltDevice)
- ga := GetApplication()
- ga.DevicesDisc.Store(test_device, voltDevice)
- _ = cntlr.NewController(context.Background(), mocks.NewMockApp(gomock.NewController(t)))
- va.PushDevFlowForVlan(tt.args.cntx, tt.args.vnet)
+ switch tt.name {
+ case "VoltApplication_PushDevFlowForVlan":
+ voltDevice.SerialNum = "test_serialNum"
+ voltDevice.VlanPortStatus.Store(uint16(of.VlanAny), true)
+ voltDevice.Name = test_device
+ va.DevicesDisc.Store(test_device, voltDevice)
+ va.PortsDisc.Store("16777216", voltPort)
+ ga := GetApplication()
+ ga.DevicesDisc.Store(test_device, voltDevice)
+ _ = cntlr.NewController(context.Background(), mocks.NewMockApp(gomock.NewController(t)))
+ va.PushDevFlowForVlan(tt.args.cntx, tt.args.vnet)
+ case "PushDevFlowForVlan":
+ va.DevicesDisc.Store("SDX6320031", voltDev)
+ voltDevice.VlanPortStatus.Store(uint16(0), true)
+ va.VnetsByName.Store("2310-4096-4096", voltVnet)
+ voltDev.ConfiguredVlanForDeviceFlows.Set("0-0-0", util.NewConcurrentMap())
+ va.PortsDisc.Store("16777472", voltPort)
+ voltApp := GetApplication()
+ voltApp.DevicesDisc.Store("SDX6320031", voltDev)
+ _ = cntlr.NewController(context.Background(), mocks.NewMockApp(gomock.NewController(t)))
+ va.PushDevFlowForVlan(tt.args.cntx, tt.args.vnet)
+ }
})
}
}
@@ -1256,6 +1430,266 @@
}
}
+func TestVoltPortVnet_PushFlowsForPortVnet(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ d *VoltDevice
+ }
+ va := GetApplication()
+ voltDev := &VoltDevice{
+ Name: "49686e2d-618f-4e8e-bca0-442ab850a63a",
+ SerialNum: "SDX6320031",
+ NniDhcpTrapVid: 123,
+ State: cntlr.DeviceStateUP,
+ FlowAddEventMap: util.NewConcurrentMap(),
+ Ports: sync.Map{},
+ }
+ va.DevicesDisc.Store("SDX6320031", voltDev)
+ voltPort := &VoltPort{
+ Name: "49686e2d-618f-4e8e-bca0-442ab850a63a",
+ Device: "SDX6320031",
+ ID: 16777472,
+ State: PortStateUp,
+ Type: VoltPortTypeNni,
+ }
+ voltDev.Ports.Store("16777472", voltPort)
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "PushFlowsForPortVnet",
+ args: args{
+ cntx: context.Background(),
+ d: voltDev,
+ },
+ },
+ {
+ name: "PushFlowsForPortVnet_PortDown",
+ args: args{
+ cntx: context.Background(),
+ d: voltDev,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{}
+ switch tt.name {
+ case "PushFlowsForPortVnet_PortDown":
+ vpv.PushFlowsForPortVnet(tt.args.cntx, tt.args.d)
+ case "PushFlowsForPortVnet":
+ vpv.Port = "16777472"
+ vpv.PushFlowsForPortVnet(tt.args.cntx, tt.args.d)
+ }
+ })
+ }
+}
+
+func TestVoltPortVnet_setLearntMAC(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ key interface{}
+ value interface{}
+ flag bool
+ }
+ voltServ := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ Device: test_device,
+ ForceDelete: true,
+ },
+ }
+ tests := []struct {
+ name string
+ args args
+ want bool
+ }{
+ {
+ name: "setLearntMAC",
+ args: args{
+ cntx: context.Background(),
+ key: test_device,
+ value: voltServ,
+ },
+ want: true,
+ },
+ {
+ name: "updateIPv4AndProvisionFlows",
+ args: args{
+ cntx: context.Background(),
+ key: test_device,
+ value: voltServ,
+ },
+ want: true,
+ },
+ {
+ name: "updateIPv6AndProvisionFlows",
+ args: args{
+ cntx: context.Background(),
+ key: test_device,
+ value: voltServ,
+ },
+ want: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ MacAddr: net.HardwareAddr(pendingPoolTimer),
+ Ipv4Addr: AllSystemsMulticastGroupIP,
+ Ipv6Addr: AllSystemsMulticastGroupIP,
+ }
+ vpv.services.Store(test_device, voltServ)
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).Times(1)
+ switch tt.name {
+ case "setLearntMAC":
+ if got := vpv.setLearntMAC(tt.args.cntx, tt.args.key, tt.args.value, tt.args.flag); got != tt.want {
+ t.Errorf("VoltPortVnet.setLearntMAC() = %v, want %v", got, tt.want)
+ }
+ case "updateIPv4AndProvisionFlows":
+ if got := vpv.updateIPv4AndProvisionFlows(tt.args.cntx, tt.args.key, tt.args.value, tt.args.flag); got != tt.want {
+ t.Errorf("VoltPortVnet.updateIPv4AndProvisionFlows() = %v, want %v", got, tt.want)
+ }
+ case "updateIPv6AndProvisionFlows":
+ if got := vpv.updateIPv6AndProvisionFlows(tt.args.cntx, tt.args.key, tt.args.value, tt.args.flag); got != tt.want {
+ t.Errorf("VoltPortVnet.updateIPv6AndProvisionFlows() = %v, want %v", got, tt.want)
+ }
+ }
+ })
+ }
+}
+
+func TestAddMeterToDevice(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ key interface{}
+ value interface{}
+ flag bool
+ }
+ voltServ := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ Device: test_device,
+ ForceDelete: true,
+ },
+ }
+ tests := []struct {
+ name string
+ args args
+ want bool
+ }{
+ {
+ name: "TestAddMeterToDevice",
+ args: args{
+ cntx: context.Background(),
+ key: test_device,
+ value: voltServ,
+ },
+ want: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := AddMeterToDevice(tt.args.cntx, tt.args.key, tt.args.value, tt.args.flag); got != tt.want {
+ t.Errorf("AddMeterToDevice() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestVoltPortVnet_AddUsArpFlows(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ va := GetApplication()
+ voltDev := &VoltDevice{
+ Name: "SDX6320031",
+ SerialNum: "SDX6320031",
+ NniDhcpTrapVid: 123,
+ State: cntlr.DeviceStateUP,
+ FlowAddEventMap: util.NewConcurrentMap(),
+ Ports: sync.Map{},
+ }
+ voltPort := &VoltPort{
+ Name: "16777472",
+ Device: "SDX6320031",
+ ID: 16777472,
+ State: PortStateUp,
+ ChannelPerSubAlarmRaised: false,
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "AddUsArpFlows",
+ args: args{
+ cntx: context.Background(),
+ },
+ wantErr: true,
+ },
+ {
+ name: "AddUsArpFlows_DeviceNotFound",
+ args: args{
+ cntx: context.Background(),
+ },
+ wantErr: true,
+ },
+ {
+ name: "AddUsArpFlows_DeviceStateDOWN",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ Device: deviceName,
+ MacLearning: MacLearningNone,
+ MacAddr: BroadcastMAC,
+ Port: "16777472",
+ }
+ va.DevicesDisc.Store(deviceName, voltDev)
+ va.PortsDisc.Store("16777472", voltPort)
+ appMock := mocks.NewMockApp(gomock.NewController(t))
+ cntlr.NewController(ctx, appMock)
+ vc := cntlr.GetController()
+ dev := map[string]*cntlr.Device{}
+ portsByName := map[string]*cntlr.DevicePort{}
+ portsByName["16777472"] = &cntlr.DevicePort{
+ Name: "16777472",
+ ID: 256,
+ }
+ device := &cntlr.Device{
+ ID: deviceName,
+ PortsByName: portsByName,
+ }
+ dev["SDX6320031"] = device
+ vc.Devices = dev
+ switch tt.name {
+ case "AddUsArpFlows":
+ if err := vpv.AddUsArpFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddUsArpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "AddUsArpFlows_DeviceNotFound":
+ vpv.Device = ""
+ if err := vpv.AddUsArpFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddUsArpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "AddUsArpFlows_DeviceStateDOWN":
+ vpv.Device = deviceName
+ voltDev.State = cntlr.DeviceStateDOWN
+ if err := vpv.AddUsArpFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddUsArpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ }
+ })
+ }
+}
+
func TestVoltPortVnet_AddDsDhcpFlows(t *testing.T) {
type args struct {
cntx context.Context
@@ -1335,14 +1769,14 @@
t.Errorf("VoltPortVnet.AddDsDhcpFlows() error = %v, wantErr %v", err, tt.wantErr)
}
case "AddDsDhcpFlows_GlobalDhcpFlowAdded":
- vpv.Device = "SDX6320031"
+ vpv.Device = deviceName
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"
+ vpv.Device = deviceName
voltDev.State = cntlr.DeviceStateUP
voltDev.GlobalDhcpFlowAdded = false
voltDev.NniPort = "16777472"
@@ -1363,3 +1797,842 @@
})
}
}
+
+func TestVoltPortVnet_AddUsDhcpFlows(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ va := GetApplication()
+ voltDev := &VoltDevice{
+ Name: "SDX6320031",
+ SerialNum: "SDX6320031",
+ NniDhcpTrapVid: 123,
+ State: cntlr.DeviceStateUP,
+ NniPort: "16777472",
+ FlowAddEventMap: util.NewConcurrentMap(),
+ }
+ va.DevicesDisc.Store("SDX6320031", voltDev)
+ voltPort := &VoltPort{
+ Name: "16777472",
+ Device: "SDX6320031",
+ ID: 16777472,
+ State: PortStateDown,
+ ChannelPerSubAlarmRaised: false,
+ Type: VoltPortTypeNni,
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "AddUsDhcpFlows_PositiveSenario",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: "AddUsDhcpFlows_StateDown",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: "AddUsDhcpFlows_DeviceNotFound",
+ args: args{
+ cntx: context.Background(),
+ },
+ wantErr: true,
+ },
+ {
+ name: "AddUsDhcpFlows_GlobalDhcpFlowAdded",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ Device: "SDX6320031",
+ VnetType: DpuMgmtTraffic,
+ Port: "16777472",
+ }
+ switch tt.name {
+ case "AddUsDhcpFlows_PositiveSenario":
+ 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.AddUsDhcpFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddDsDhcpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "AddUsDhcpFlows_DeviceNotFound":
+ vpv.Device = ""
+ if err := vpv.AddUsDhcpFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddDsDhcpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "AddUsDhcpFlows_StateDown":
+ voltDev.State = cntlr.DeviceStateDOWN
+ if err := vpv.AddUsDhcpFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddDsDhcpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "AddUsDhcpFlows_GlobalDhcpFlowAdded":
+ vpv.Device = "SDX6320031"
+ voltDev.State = cntlr.DeviceStateUP
+ vpv.Port = ""
+ if err := vpv.AddUsDhcpFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddDsDhcpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ }
+ })
+ }
+}
+
+func TestVoltPortVnet_AddUsPppoeFlows(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ va := GetApplication()
+ voltDev := &VoltDevice{
+ Name: "SDX6320031",
+ SerialNum: "SDX6320031",
+ NniDhcpTrapVid: 123,
+ State: cntlr.DeviceStateUP,
+ NniPort: "16777472",
+ FlowAddEventMap: util.NewConcurrentMap(),
+ }
+ voltPort := &VoltPort{
+ Name: "16777472",
+ Device: "SDX6320031",
+ ID: 16777472,
+ State: PortStateUp,
+ ChannelPerSubAlarmRaised: false,
+ }
+ va.DevicesDisc.Store("SDX6320031", voltDev)
+ va.PortsDisc.Store("16777472", voltPort)
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "AddUsPppoeFlows",
+ args: args{
+ cntx: context.Background(),
+ },
+ wantErr: true,
+ },
+ {
+ name: "AddDsPppoeFlows",
+ args: args{
+ cntx: context.Background(),
+ },
+ wantErr: true,
+ },
+ {
+ name: "AddUsPppoeFlows_StateDown",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: "AddDsPppoeFlows_StateDown",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: "AddUsPppoeFlows_DeviceNotFound",
+ args: args{
+ cntx: context.Background(),
+ },
+ wantErr: true,
+ },
+ {
+ name: "AddDsPppoeFlows_DeviceNotFound",
+ args: args{
+ cntx: context.Background(),
+ },
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ Device: "SDX6320031",
+ MacLearning: MacLearningNone,
+ MacAddr: net.HardwareAddr(pendingPoolTimer),
+ }
+ switch tt.name {
+ case "AddUsPppoeFlows":
+ if err := vpv.AddUsPppoeFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddUsPppoeFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "AddDsPppoeFlows":
+ appMock := mocks.NewMockApp(gomock.NewController(t))
+ cntlr.NewController(ctx, appMock)
+ vc := cntlr.GetController()
+ dev := map[string]*cntlr.Device{}
+ portsByName := map[string]*cntlr.DevicePort{}
+ portsByName["16777472"] = &cntlr.DevicePort{
+ Name: "16777472",
+ ID: 256,
+ }
+ device := &cntlr.Device{
+ ID: "SDX6320031",
+ PortsByName: portsByName,
+ }
+ dev["SDX6320031"] = device
+ vc.Devices = dev
+ if err := vpv.AddDsPppoeFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddUsPppoeFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "AddUsPppoeFlows_StateDown":
+ voltDev.State = cntlr.DeviceStateDOWN
+ if err := vpv.AddUsPppoeFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddUsPppoeFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "AddDsPppoeFlows_StateDown":
+ voltDev.State = cntlr.DeviceStateDOWN
+ if err := vpv.AddDsPppoeFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddUsPppoeFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "AddUsPppoeFlows_DeviceNotFound":
+ vpv.Device = ""
+ if err := vpv.AddUsPppoeFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddUsPppoeFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "AddDsPppoeFlows_DeviceNotFound":
+ vpv.Device = ""
+ if err := vpv.AddDsPppoeFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddUsPppoeFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ }
+ })
+ }
+}
+
+func TestVoltPortVnet_AddIgmpFlows(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ var voltPortTest = &VoltPort{
+ Name: "test_name",
+ State: PortStateUp,
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "AddIgmpFlows",
+ args: args{
+ cntx: context.Background(),
+ },
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ MvlanProfileName: "mvlan_profile",
+ }
+ va := GetApplication()
+ va.PortsDisc.Store("test_port", voltPortTest)
+ if err := vpv.AddIgmpFlows(tt.args.cntx); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.AddIgmpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestVoltPortVnet_BuildUsDhcp6Flows(t *testing.T) {
+ voltPort := &VoltPort{
+ Name: "16777216",
+ Device: "SDX6320031",
+ ID: 16777216,
+ State: PortStateDown,
+ ChannelPerSubAlarmRaised: false,
+ Type: VoltPortTypeNni,
+ }
+ voltService := &VoltService{
+ Version: "test_version",
+ VoltServiceCfg: VoltServiceCfg{
+ VnetID: "test_vnet_id",
+ Port: "16777216",
+ SVlan: of.VlanAny,
+ CVlan: of.VlanAny,
+ UniVlan: of.VlanAny,
+ },
+ }
+ voltDev := &VoltDevice{
+ Name: "49686e2d-618f-4e8e-bca0-442ab850a63a",
+ SerialNum: "SDX6320031",
+ NniDhcpTrapVid: 123,
+ State: cntlr.DeviceStateUP,
+ NniPort: "16777216",
+ Ports: sync.Map{},
+ }
+ tests := []struct {
+ name string
+ want *of.VoltFlow
+ wantErr bool
+ }{
+ {
+ name: "BuildUsDhcp6Flows",
+ want: &of.VoltFlow{},
+ },
+ {
+ name: "BuildDsDhcp6Flows",
+ want: &of.VoltFlow{},
+ },
+ {
+ name: "BuildDsDhcp6Flows_DeviceNotFound",
+ want: &of.VoltFlow{},
+ wantErr: true,
+ },
+ {
+ name: "BuildUsDhcp6Flows_portnotfound",
+ want: &of.VoltFlow{},
+ wantErr: true,
+ },
+ {
+ name: "BuildDsDhcp6Flows_portnotfound",
+ want: &of.VoltFlow{},
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ Port: "16777216",
+ services: sync.Map{},
+ AllowTransparent: true,
+ Device: "SDX6320031",
+ }
+ va := GetApplication()
+ va.PortsDisc.Store("16777216", voltPort)
+ vpv.services.Store("SDX6320031-1_SDX6320031-1-4096-2310-4096-65", voltService)
+ switch tt.name {
+ case "BuildUsDhcp6Flows":
+ got, err := vpv.BuildUsDhcp6Flows()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.BuildUsDhcp6Flows() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.NotNil(t, got)
+ case "BuildDsDhcp6Flows":
+ va.DevicesDisc.Store("SDX6320031", voltDev)
+ got, err := vpv.BuildDsDhcp6Flows()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.BuildDsDhcp6Flows() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.NotNil(t, got)
+ case "BuildDsDhcp6Flows_DeviceNotFound":
+ vpv.Device = ""
+ got, err := vpv.BuildDsDhcp6Flows()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.BuildDsDhcp6Flows() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.Nil(t, got)
+ case "BuildUsDhcp6Flows_portnotfound":
+ vpv.Port = ""
+ got, err := vpv.BuildUsDhcp6Flows()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.BuildUsDhcp6Flows_portnotfound() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.Nil(t, got)
+ case "BuildDsDhcp6Flows_portnotfound":
+ voltDev.NniPort = "abc"
+ got, err := vpv.BuildDsDhcp6Flows()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.BuildDsDhcp6Flows_portnotfound() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.Nil(t, got)
+ }
+ })
+ }
+}
+
+func TestVoltPortVnet_setUsMatchVlan(t *testing.T) {
+ type args struct {
+ flow *of.VoltSubFlow
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "setUsMatchVlan",
+ args: args{
+ flow: &of.VoltSubFlow{},
+ },
+ },
+ {
+ name: "OLTCVlanOLTSVlan",
+ args: args{
+ flow: &of.VoltSubFlow{},
+ },
+ },
+ {
+ name: "ONUCVlan",
+ args: args{
+ flow: &of.VoltSubFlow{},
+ },
+ },
+ {
+ name: "OLTSVlan",
+ args: args{
+ flow: &of.VoltSubFlow{},
+ },
+ },
+ {
+ name: "Default",
+ args: args{
+ flow: &of.VoltSubFlow{},
+ },
+ wantErr: true,
+ },
+ {
+ name: "setDsMatchVlan_OLTCVlanOLTSVlan",
+ args: args{
+ flow: &of.VoltSubFlow{},
+ },
+ },
+ {
+ name: "setDsMatchVlan_Default",
+ args: args{
+ flow: &of.VoltSubFlow{},
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ VlanControl: ONUCVlanOLTSVlan,
+ }
+ switch tt.name {
+ case "setUsMatchVlan":
+ if err := vpv.setUsMatchVlan(tt.args.flow); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.setUsMatchVlan() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "OLTCVlanOLTSVlan":
+ vpv.VlanControl = OLTCVlanOLTSVlan
+ if err := vpv.setUsMatchVlan(tt.args.flow); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.setUsMatchVlan() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "ONUCVlan":
+ vpv.VlanControl = ONUCVlan
+ if err := vpv.setUsMatchVlan(tt.args.flow); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.setUsMatchVlan() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "OLTSVlan":
+ vpv.VlanControl = OLTSVlan
+ if err := vpv.setUsMatchVlan(tt.args.flow); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.setUsMatchVlan() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "Default":
+ vpv.VlanControl = opt82
+ if err := vpv.setUsMatchVlan(tt.args.flow); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.setUsMatchVlan() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "setDsMatchVlan_OLTCVlanOLTSVlan":
+ vpv.VlanControl = OLTCVlanOLTSVlan
+ vpv.setDsMatchVlan(tt.args.flow)
+ case "setDsMatchVlan_Default":
+ vpv.VlanControl = opt82
+ vpv.setDsMatchVlan(tt.args.flow)
+ }
+ })
+ }
+}
+
+func TestVoltPortVnet_BuildIgmpFlows(t *testing.T) {
+ va := GetApplication()
+ devicesList := make(map[string]OperInProgress)
+ devicesList["SDX6320030"] = opt82
+ mvp := &MvlanProfile{
+ Name: "mvlan_test",
+ DevicesList: devicesList,
+ }
+ va.MvlanProfilesByName.Store("mvlan_test", mvp)
+ voltPort := &VoltPort{
+ Name: "16777472",
+ Device: "SDX6320031",
+ ID: 16777472,
+ State: PortStateUp,
+ ChannelPerSubAlarmRaised: false,
+ }
+ va.PortsDisc.Store("16777472", voltPort)
+ tests := []struct {
+ name string
+ want *of.VoltFlow
+ wantErr bool
+ }{
+ {
+ name: "BuildIgmpFlows",
+ want: &of.VoltFlow{},
+ },
+ {
+ name: "BuildIgmpFlows_McastService_False",
+ want: &of.VoltFlow{},
+ },
+ {
+ name: "BuildIgmpFlows_PortNotFound",
+ want: nil,
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ Port: "16777472",
+ MvlanProfileName: "mvlan_test",
+ MacLearning: MacLearningNone,
+ MacAddr: util.Uint32ToByte(uint32(23)),
+ McastService: true,
+ AllowTransparent: true,
+ }
+
+ switch tt.name {
+ case "BuildIgmpFlows":
+ got, err := vpv.BuildIgmpFlows()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.BuildIgmpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.NotNil(t, got)
+ case "BuildIgmpFlows_McastService_False":
+ vpv.McastService = false
+ vpv.services.Store("16777472", &VoltService{})
+ got, err := vpv.BuildIgmpFlows()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.BuildIgmpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.NotNil(t, got)
+ case "BuildIgmpFlows_PortNotFound":
+ vpv.Port = ""
+ got, err := vpv.BuildIgmpFlows()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.BuildIgmpFlows() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ assert.Nil(t, got)
+ }
+ })
+ }
+}
+
+func TestVoltPortVnet_SetMacAddr(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ addr net.HardwareAddr
+ }
+ addr, _ := net.ParseMAC("00:00:11:00:00:00")
+ macAddr, _ := net.ParseMAC("00:00:00:00:00:11")
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "SetMacAddr",
+ args: args{
+ cntx: context.Background(),
+ addr: addr,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ MacAddr: macAddr,
+ MacLearning: MaxLenDhcpv6DUID,
+ FlowsApplied: true,
+ }
+ switch tt.name {
+ case "SetMacAddr":
+ vpv.SetMacAddr(tt.args.cntx, tt.args.addr)
+ }
+ })
+ }
+}
+
+func TestVoltPortVnet_AddTrapFlows(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "AddTrapFlows",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: "AddTrapFlows_ArpRelay",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: "AddTrapFlows_PppoeIa",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ DhcpRelay: true,
+ DeleteInProgress: true,
+ }
+ switch tt.name {
+ case "AddTrapFlows":
+ vpv.AddTrapFlows(tt.args.cntx)
+ case "AddTrapFlows_ArpRelay":
+ vpv.DhcpRelay = false
+ vpv.ArpRelay = true
+ vpv.AddTrapFlows(tt.args.cntx)
+ case "AddTrapFlows_PppoeIa":
+ vpv.DhcpRelay = false
+ vpv.ArpRelay = false
+ vpv.PppoeIa = true
+ vpv.AddTrapFlows(tt.args.cntx)
+ }
+ })
+ }
+}
+
+func TestVoltPortVnet_DelTrapFlows(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "DelTrapFlows",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ FlowsApplied: true,
+ DhcpRelay: true,
+ DeleteInProgress: true,
+ }
+ switch tt.name {
+ case "DelTrapFlows":
+ vpv.DelTrapFlows(tt.args.cntx)
+ }
+ })
+ }
+}
+
+func TestVoltPortVnet_delDsDhcp4Flows(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ device *VoltDevice
+ }
+ voltDev := &VoltDevice{
+ Name: "49686e2d-618f-4e8e-bca0-442ab850a63a",
+ SerialNum: "SDX6320031",
+ NniDhcpTrapVid: 123,
+ State: cntlr.DeviceStateUP,
+ NniPort: "16777472",
+ Ports: sync.Map{},
+ FlowDelEventMap: util.NewConcurrentMap(),
+ }
+ va := GetApplication()
+ devicesList := make(map[string]OperInProgress)
+ devicesList["SDX6320031"] = opt82
+ mvp := &MvlanProfile{
+ Name: "mvlan_test",
+ DevicesList: devicesList,
+ }
+ va.MvlanProfilesByName.Store("mvlan_test", mvp)
+ voltPort := &VoltPort{
+ Name: "16777472",
+ Device: "SDX6320031",
+ ID: 16777472,
+ State: PortStateUp,
+ ChannelPerSubAlarmRaised: false,
+ }
+ va.DevicesDisc.Store("SDX6320031", voltDev)
+ va.PortsDisc.Store("16777472", voltPort)
+ appMock := mocks.NewMockApp(gomock.NewController(t))
+ controller.NewController(ctx, appMock)
+ vc := cntlr.GetController()
+ dev := map[string]*cntlr.Device{}
+ portsByName := map[string]*cntlr.DevicePort{}
+ portsByName["16777472"] = &cntlr.DevicePort{
+ Name: "16777472",
+ ID: 256,
+ }
+ device := &cntlr.Device{
+ ID: deviceName,
+ PortsByName: portsByName,
+ }
+ dev["SDX6320031"] = device
+ vc.Devices = dev
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "delDsDhcp4Flows",
+ args: args{
+ cntx: context.Background(),
+ device: voltDev,
+ },
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vpv := &VoltPortVnet{
+ Device: "SDX6320031",
+ Port: "16777472",
+ MvlanProfileName: "mvlan_test",
+ MacLearning: MacLearningNone,
+ MacAddr: util.Uint32ToByte(uint32(23)),
+ McastService: true,
+ AllowTransparent: true,
+ PendingDeleteFlow: make(map[string]bool),
+ }
+ if err := vpv.delDsDhcp4Flows(tt.args.cntx, tt.args.device); (err != nil) != tt.wantErr {
+ t.Errorf("VoltPortVnet.delDsDhcp4Flows() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestVoltApplication_DeleteDevFlowForVlan(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ vnet *VoltVnet
+ }
+ voltDev := &VoltDevice{
+ Name: "SDX6320031",
+ SerialNum: "SDX6320031",
+ NniDhcpTrapVid: 123,
+ State: cntlr.DeviceStateUP,
+ NniPort: "16777472",
+ Ports: sync.Map{},
+ FlowDelEventMap: util.NewConcurrentMap(),
+ ConfiguredVlanForDeviceFlows: util.NewConcurrentMap(),
+ }
+ voltVnet := &VoltVnet{
+ Version: "v3",
+ VnetConfig: VnetConfig{
+ Name: "2310-4096-4096",
+ VnetType: "Encapsulation",
+ },
+ VnetOper: VnetOper{
+ PendingDeviceToDelete: "SDX6320031",
+ DeleteInProgress: true,
+ PendingDeleteFlow: make(map[string]map[string]bool),
+ },
+ }
+ voltPort := &VoltPort{
+ Name: "16777472",
+ Device: "SDX6320031",
+ ID: 16777472,
+ State: PortStateUp,
+ ChannelPerSubAlarmRaised: false,
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "DeleteDevFlowForVlan",
+ args: args{
+ cntx: context.Background(),
+ vnet: voltVnet,
+ },
+ },
+ {
+ name: "DeleteDevFlowForVlan_PortStateDown",
+ args: args{
+ cntx: context.Background(),
+ vnet: voltVnet,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ va := &VoltApplication{}
+ switch tt.name {
+ case "DeleteDevFlowForVlan":
+ va.DevicesDisc.Store("SDX6320031", voltDev)
+ va.VnetsByName.Store("2310-4096-4096", voltVnet)
+ voltDev.ConfiguredVlanForDeviceFlows.Set("0-0-0", util.NewConcurrentMap())
+ va.PortsDisc.Store("16777472", voltPort)
+ appMock := mocks.NewMockApp(gomock.NewController(t))
+ cntlr.NewController(ctx, appMock)
+ vc := cntlr.GetController()
+ dev := map[string]*cntlr.Device{}
+ portsByName := map[string]*cntlr.DevicePort{}
+ portsByName["16777472"] = &cntlr.DevicePort{
+ Name: "16777472",
+ ID: 256,
+ State: cntlr.PortStateUp,
+ }
+ device := &cntlr.Device{
+ ID: "SDX6320031",
+ PortsByName: portsByName,
+ }
+ dev["SDX6320031"] = device
+ vc.Devices = dev
+ va.DeleteDevFlowForVlan(tt.args.cntx, tt.args.vnet)
+ case "DeleteDevFlowForVlan_PortStateDown":
+ voltDev.Name = ""
+ va.DevicesDisc.Store("SDX6320031", voltDev)
+ va.VnetsByName.Store("2310-4096-4096", voltVnet)
+ voltDev.ConfiguredVlanForDeviceFlows.Set("0-0-0", util.NewConcurrentMap())
+ va.PortsDisc.Store("16777472", voltPort)
+ appMock := mocks.NewMockApp(gomock.NewController(t))
+ cntlr.NewController(ctx, appMock)
+ vc := cntlr.GetController()
+ dev := map[string]*cntlr.Device{}
+ portsByName := map[string]*cntlr.DevicePort{}
+ portsByName["16777472"] = &cntlr.DevicePort{
+ Name: "16777472",
+ ID: 256,
+ State: cntlr.PortStateUp,
+ }
+ device := &cntlr.Device{
+ ID: "SDX6320031",
+ PortsByName: portsByName,
+ }
+ dev["SDX6320031"] = device
+ vc.Devices = dev
+ va.DeleteDevFlowForVlan(tt.args.cntx, tt.args.vnet)
+ }
+ })
+ }
+}