vgc unit tests part 2
Change-Id: Iec7e27c73f90b5d40d36b52a4b71e97cf166798c
diff --git a/internal/pkg/application/pppoeia_test.go b/internal/pkg/application/pppoeia_test.go
new file mode 100644
index 0000000..45b76fa
--- /dev/null
+++ b/internal/pkg/application/pppoeia_test.go
@@ -0,0 +1,266 @@
+/*
+* 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"
+ "net"
+ "sync"
+ "testing"
+ cntlr "voltha-go-controller/internal/pkg/controller"
+ "voltha-go-controller/internal/pkg/of"
+ "voltha-go-controller/internal/test/mocks"
+
+ "github.com/golang/mock/gomock"
+ "github.com/google/gopacket"
+ "github.com/google/gopacket/layers"
+ "github.com/stretchr/testify/assert"
+)
+
+var eth = &layers.Ethernet{
+ SrcMAC: layers.EthernetBroadcast,
+ DstMAC: layers.EthernetBroadcast,
+ EthernetType: layers.EthernetTypeARP,
+ Length: uint16(1),
+}
+var dot1Q = &layers.Dot1Q{
+ Priority: uint8(1),
+ DropEligible: true,
+ Type: layers.EthernetTypeARP,
+}
+var LayerTypeDot2Q = []gopacket.Layer{
+ dot1Q,
+}
+
+func TestPppoeIaPacketTask_Start(t *testing.T) {
+ type args struct {
+ ctx context.Context
+ taskID uint8
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "PppoeIaPacketTask_Start",
+ args: args{
+ ctx: context.Background(),
+ taskID: EtherType8100,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ pppoe := &layers.PPPoE{
+ Version: uint8(1),
+ }
+ pkt := mocks.NewMockPacket(gomock.NewController(t))
+ var dpt = &PppoeIaPacketTask{
+ pkt: pkt,
+ }
+ pkt.EXPECT().Layer(layers.LayerTypePPPoE).Return(pppoe).Times(2)
+ pkt.EXPECT().Layer(layers.LayerTypeEthernet).Return(eth).Times(1)
+ pkt.EXPECT().Layer(layers.LayerTypeDot1Q).Return(dot1Q).Times(1)
+ pkt.EXPECT().Layers().Return(LayerTypeDot2Q).Times(1)
+ err := dpt.Start(tt.args.ctx, tt.args.taskID)
+ assert.Nil(t, err)
+ })
+ }
+}
+
+func TestVoltApplication_ProcessPPPoEIaPacket(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ device string
+ port string
+ pkt gopacket.Packet
+ }
+ pkt := mocks.NewMockPacket(gomock.NewController(t))
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "ProcessPPPoEIaPacket_ProcessUsPppoeIaPacket",
+ args: args{
+ cntx: context.Background(),
+ device: test_device,
+ port: "test_port",
+ pkt: pkt,
+ },
+ },
+ {
+ name: "pppoel_nil",
+ args: args{
+ cntx: context.Background(),
+ device: test_device,
+ port: "test_port",
+ pkt: pkt,
+ },
+ },
+ {
+ name: "pppoel_invalidType",
+ args: args{
+ cntx: context.Background(),
+ device: test_device,
+ port: "test_port",
+ pkt: pkt,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ va := &VoltApplication{}
+ // dot1Q := &layers.Dot1Q{
+ // Priority: uint8(1),
+ // DropEligible: true,
+ // Type: layers.EthernetTypeARP,
+ // }
+ // LayerTypeDot2Q := []gopacket.Layer{
+ // dot1Q,
+ // }
+ ga := GetApplication()
+ switch tt.name {
+ case "ProcessPPPoEIaPacket_ProcessUsPppoeIaPacket":
+ ga.DevicesDisc.Store(test_device, voltDevice)
+ pkt.EXPECT().Layer(layers.LayerTypePPPoE).Return(&layers.PPPoE{
+ Version: uint8(1),
+ }).Times(1)
+ pkt.EXPECT().Layers().Return(LayerTypeDot2Q).Times(2)
+ va.ProcessPPPoEIaPacket(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt)
+ case "pppoel_nil":
+ pkt.EXPECT().Layer(layers.LayerTypePPPoE).Return(nil).Times(1)
+ va.ProcessPPPoEIaPacket(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt)
+ case "pppoel_invalidType":
+ pkt.EXPECT().Layer(layers.LayerTypePPPoE).Return(&layers.ARP{}).Times(1)
+ va.ProcessPPPoEIaPacket(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt)
+ }
+ })
+ }
+}
+
+func TestVoltApplication_ProcessUsPppoeIaPacket(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ device string
+ port string
+ pkt gopacket.Packet
+ }
+ pkt := mocks.NewMockPacket(gomock.NewController(t))
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "VoltApplication_ProcessUsPppoeIaPacket",
+ args: args{
+ cntx: context.Background(),
+ device: test_device,
+ port: "test_port",
+ pkt: pkt,
+ },
+ },
+ }
+ macAdd, _ := net.ParseMAC("ff:ff:ff:ff:ff:ff")
+ macPort := map[string]string{}
+ macPort[macAdd.String()] = test_data
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ va := &VoltApplication{
+ macPortMap: macPort,
+ VnetsByPort: sync.Map{},
+ DevicesDisc: sync.Map{},
+ }
+ voltServ := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ Device: "SDX6320031",
+ },
+ VoltServiceCfg: VoltServiceCfg{
+ IsActivated: true,
+ Pbits: []of.PbitType{PbitMatchAll},
+ },
+ }
+ switch tt.name {
+ case "VoltApplication_ProcessUsPppoeIaPacket":
+ va.DevicesDisc.Store(test_device, voltDevice)
+ pkt.EXPECT().Layers().Return(LayerTypeDot2Q).Times(3)
+ voltPortVnet1[0].SVlan = 0
+ voltDevice.NniPort = "1"
+ va.VnetsByPort.Store("test_port", voltPortVnet1)
+ voltPortVnet1[0].PppoeIa = true
+ voltPortVnet1[0].AllowTransparent = true
+ voltPortVnet1[0].Port = test_data
+ pendingDeleteFlow := map[string]bool{}
+ pendingDeleteFlow["test_cookie"] = true
+ voltPortVnet1[0].PendingDeleteFlow = pendingDeleteFlow
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ eth.SrcMAC = layers.EthernetBroadcast
+ dbintf.EXPECT().PutVpv(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).Times(1)
+ voltPortVnet1[0].services.Store("SDX6320031-1_SDX6320031-1-4096-2310-4096-65", voltServ)
+ pkt.EXPECT().Layer(layers.LayerTypeEthernet).Return(eth).Times(2)
+ pkt.EXPECT().Layer(layers.LayerTypePPPoE).Return(&layers.PPPoE{
+ Version: uint8(1),
+ Code: layers.PPPoECodePADI,
+ }).Times(1)
+ pkt.EXPECT().Layer(layers.LayerTypeDot1Q).Return(dot1Q).Times(1)
+ _ = cntlr.NewController(context.Background(), mocks.NewMockApp(gomock.NewController(t)))
+ va.ProcessUsPppoeIaPacket(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt)
+ }
+ })
+ }
+}
+
+func TestVoltApplication_ProcessDsPppoeIaPacket(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ device string
+ port string
+ pkt gopacket.Packet
+ }
+ pkt := mocks.NewMockPacket(gomock.NewController(t))
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "VoltApplication_ProcessDsPppoeIaPacket",
+ args: args{
+ cntx: context.Background(),
+ device: test_device,
+ port: "test_port",
+ pkt: pkt,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ va := &VoltApplication{}
+ pkt.EXPECT().Layer(layers.LayerTypeEthernet).Return(eth).Times(1)
+ pkt.EXPECT().Layer(layers.LayerTypePPPoE).Return(&layers.PPPoE{
+ Version: uint8(1),
+ Code: layers.PPPoECodePADI,
+ }).Times(1)
+ pkt.EXPECT().Layer(layers.LayerTypeDot1Q).Return(dot1Q).Times(1)
+ pkt.EXPECT().Layers().Return(LayerTypeDot2Q).Times(3)
+ 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).Times(1)
+ va.ProcessDsPppoeIaPacket(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt)
+ })
+ }
+}