blob: 66edc57478bb3a32a31807730b068cd7c47ee1e6 [file] [log] [blame]
/*
* 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"
"encoding/json"
"net"
"reflect"
"sync"
"testing"
"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"
"go.uber.org/atomic"
)
func TestVoltApplication_GetIgnoredPorts(t *testing.T) {
voltDevice := &VoltDevice{
Name: "11c3175b-50f3-4220-9555-93df733ded1d",
SerialNum: "SDX6320031",
SouthBoundID: "68580342-6b3e-57cb-9ea4-06125594e330",
NniPort: "16777472",
Ports: sync.Map{},
PonPortList: sync.Map{},
}
voltPort := &VoltPort{
Name: "16777472",
Device: "SDX6320031",
ID: 16777472,
State: PortStateDown,
ChannelPerSubAlarmRaised: false,
Type: VoltPortTypeNni,
}
voltPortVnets := make([]*VoltPortVnet, 0)
voltPortVnet := &VoltPortVnet{
Device: "SDX6320031",
Port: "16777472",
MacLearning: MacLearningNone,
}
voltPortVnets = append(voltPortVnets, voltPortVnet)
IgnoredPorts := make(map[string][]string)
IgnoredPorts["SDX6320031"] = append(IgnoredPorts["SDX6320031"], "16777472")
tests := []struct {
name string
want map[string][]string
wantErr bool
}{
{
name: "Positive_Case_GetIgnoredPorts",
want: IgnoredPorts,
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
va := &VoltApplication{
DevicesDisc: sync.Map{},
}
va.DevicesDisc.Store("SDX6320031", voltDevice)
voltDevice.Ports.Store("16777472", voltPort)
voltApp := GetApplication()
voltApp.VnetsByPort.Store("16777472", voltPortVnets)
got, err := va.GetIgnoredPorts()
if (err != nil) != tt.wantErr {
t.Errorf("VoltApplication.GetIgnoredPorts() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("VoltApplication.GetIgnoredPorts() = %v, want %v", got, tt.want)
}
})
}
}
func TestDhcpNetworks_AddDhcpSession(t *testing.T) {
pkt := mocks.NewMockPacket(gomock.NewController(t))
type args struct {
pkt gopacket.Packet
session IDhcpRelaySession
}
tests := []struct {
name string
args args
wantErr bool
}{
{
name: "DhcpNetworks_AddDhcpSession",
args: args{
pkt: pkt,
session: &VoltPortVnet{},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
network := make(map[uint32]*DhcpRelayVnet)
dn := &DhcpNetworks{
Networks: network,
}
pkt.EXPECT().Layer(layers.LayerTypeEthernet).Return(eth).Times(1)
if err := dn.AddDhcpSession(tt.args.pkt, tt.args.session); (err != nil) != tt.wantErr {
t.Errorf("DhcpNetworks.AddDhcpSession() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestDhcpNetworks_DelDhcpSession(t *testing.T) {
pkt := mocks.NewMockPacket(gomock.NewController(t))
type args struct {
pkt gopacket.Packet
session IDhcpRelaySession
}
tests := []struct {
name string
args args
}{
{
name: "DhcpNetworks_DelDhcpSession",
args: args{
pkt: pkt,
session: &VoltPortVnet{},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
network := make(map[uint32]*DhcpRelayVnet)
dn := &DhcpNetworks{
Networks: network,
}
pkt.EXPECT().Layer(layers.LayerTypeEthernet).Return(eth).Times(1)
dn.DelDhcpSession(tt.args.pkt, tt.args.session)
})
}
}
func TestDhcpNetworks_AddDhcp6Session(t *testing.T) {
type args struct {
key [MaxLenDhcpv6DUID]byte
session IDhcpRelaySession
}
tests := []struct {
name string
args args
wantErr bool
}{
{
name: "DhcpNetworks_AddDhcp6Session",
args: args{
session: &VoltPortVnet{},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
network := make(map[uint32]*DhcpRelayVnet)
dn := &DhcpNetworks{
Networks: network,
}
if err := dn.AddDhcp6Session(tt.args.key, tt.args.session); (err != nil) != tt.wantErr {
t.Errorf("DhcpNetworks.AddDhcp6Session() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestDhcpNetworks_DelDhcp6Session(t *testing.T) {
type args struct {
key [MaxLenDhcpv6DUID]byte
session IDhcpRelaySession
}
tests := []struct {
name string
args args
}{
{
name: "DhcpNetworks_DelDhcp6Session",
args: args{
session: &VoltPortVnet{},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
network := make(map[uint32]*DhcpRelayVnet)
network[uint32(4097)] = &DhcpRelayVnet{
InnerVlan: uint16(4097),
}
dn := &DhcpNetworks{
Networks: network,
}
dn.DelDhcp6Session(tt.args.key, tt.args.session)
})
}
}
func TestDhcpNetworks_GetDhcpSession(t *testing.T) {
type fields struct {
Networks map[uint32]*DhcpRelayVnet
}
type args struct {
outerVlan uint16
innerVlan uint16
addr net.HardwareAddr
}
macAdd, _ := net.ParseMAC("ff:ff:ff:ff:ff:ff")
tests := []struct {
name string
fields fields
args args
want IDhcpRelaySession
}{
{
name: "DhcpNetworks_GetDhcpSession",
args: args{
outerVlan: uint16(0),
innerVlan: uint16(4097),
addr: macAdd,
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
network := make(map[uint32]*DhcpRelayVnet)
network[uint32(4097)] = &DhcpRelayVnet{
InnerVlan: uint16(4097),
}
dn := &DhcpNetworks{
Networks: network,
}
got, err := dn.GetDhcpSession(tt.args.outerVlan, tt.args.innerVlan, tt.args.addr)
assert.NotNil(t, err)
assert.Nil(t, got)
})
}
}
func TestDhcpNetworks_GetDhcp6Session(t *testing.T) {
type fields struct {
Networks map[uint32]*DhcpRelayVnet
}
type args struct {
outerVlan uint16
innerVlan uint16
key [MaxLenDhcpv6DUID]byte
}
tests := []struct {
name string
fields fields
args args
want IDhcpRelaySession
wantErr bool
}{
{
name: "DhcpNetworks_GetDhcp6Session",
args: args{
outerVlan: uint16(0),
innerVlan: uint16(4097),
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
network := make(map[uint32]*DhcpRelayVnet)
network[uint32(4097)] = &DhcpRelayVnet{
InnerVlan: uint16(4097),
}
dn := &DhcpNetworks{
Networks: network,
}
got, err := dn.GetDhcp6Session(tt.args.outerVlan, tt.args.innerVlan, tt.args.key)
assert.NotNil(t, err)
assert.Nil(t, got)
})
}
}
func TestGetVnetForV4Nni(t *testing.T) {
type args struct {
dhcp *layers.DHCPv4
cvlan of.VlanType
svlan of.VlanType
pbit uint8
}
macAdd, _ := net.ParseMAC("ff:ff:ff:ff:ff:ff")
tests := []struct {
name string
args args
want []*VoltPortVnet
wantErr bool
}{
{
name: "GetVnetForV4Nni",
args: args{
cvlan: of.VlanAny,
svlan: of.VlanAny,
dhcp: &layers.DHCPv4{
BaseLayer: dot1Q.BaseLayer,
ClientHWAddr: macAdd,
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := GetVnetForV4Nni(tt.args.dhcp, tt.args.cvlan, tt.args.svlan, tt.args.pbit)
assert.NotNil(t, err)
assert.Nil(t, got)
})
}
}
func TestGetVnetForV6Nni(t *testing.T) {
type args struct {
dhcp *layers.DHCPv6
cvlan of.VlanType
svlan of.VlanType
pbit uint8
clientMAC net.HardwareAddr
}
macAdd, _ := net.ParseMAC("ff:ff:ff:ff:ff:ff")
tests := []struct {
name string
args args
want []*VoltPortVnet
want1 net.HardwareAddr
wantErr bool
}{
{
name: "GetVnetForV6Nni",
args: args{
dhcp: &layers.DHCPv6{
BaseLayer: dot1Q.BaseLayer,
Options: layers.DHCPv6Options{
{
Code: layers.DHCPv6OptClientID,
Data: []byte{2, 3, 4, 2, 3, 4, 2, 3, 4},
},
},
},
cvlan: of.VlanAny,
svlan: of.VlanAny,
clientMAC: macAdd,
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, got1, err := GetVnetForV6Nni(tt.args.dhcp, tt.args.cvlan, tt.args.svlan, tt.args.pbit, tt.args.clientMAC)
assert.NotNil(t, err)
assert.Nil(t, got)
assert.NotNil(t, got1)
})
}
}
func TestAddDhcpv4Option82(t *testing.T) {
type args struct {
svc *VoltService
rID []byte
dhcpv4 *layers.DHCPv4
}
tests := []struct {
name string
args args
}{
{
name: "AddDhcpv4Option82",
args: args{
svc: &VoltService{
VoltServiceCfg: VoltServiceCfg{
CircuitID: "test_circuit_id",
DataRateAttr: DSLAttrEnabled,
},
},
rID: []byte{1},
dhcpv4: &layers.DHCPv4{
Options: layers.DHCPOptions{
{
Type: layers.DHCPOptARPTimeout,
},
},
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
AddDhcpv4Option82(tt.args.svc, tt.args.rID, tt.args.dhcpv4)
})
}
}
func TestVoltApplication_ProcessDsDhcpv4Packet(t *testing.T) {
pkt := mocks.NewMockPacket(gomock.NewController(t))
type args struct {
cntx context.Context
device string
port string
pkt gopacket.Packet
}
tests := []struct {
name string
args args
}{
{
name: "VoltApplication_ProcessDsDhcpv4Packet",
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{}
iPv4 := &layers.IPv4{
Version: uint8(1),
}
uDP := &layers.UDP{
Length: uint16(1),
}
dHCPv4 := &layers.DHCPv4{
HardwareLen: uint8(1),
}
dot1Q_test := &layers.Dot1Q{
Priority: uint8(1),
}
pkt.EXPECT().Layer(layers.LayerTypeEthernet).Return(eth).Times(1)
pkt.EXPECT().Layer(layers.LayerTypeIPv4).Return(iPv4).Times(1)
pkt.EXPECT().Layer(layers.LayerTypeUDP).Return(uDP).Times(1)
pkt.EXPECT().Layer(layers.LayerTypeDHCPv4).Return(dHCPv4).Times(1)
pkt.EXPECT().Layer(layers.LayerTypeDot1Q).Return(dot1Q_test).Times(1)
pkt.EXPECT().Layers().Return(LayerTypeDot2Q).Times(1)
va.ProcessDsDhcpv4Packet(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt)
})
}
}
func TestDelOption82(t *testing.T) {
type args struct {
dhcpv4 *layers.DHCPv4
}
tests := []struct {
name string
args args
}{
{
name: "DelOption82",
args: args{
dhcpv4: &layers.DHCPv4{
Options: layers.DHCPOptions{
{
Type: opt82,
},
},
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
DelOption82(tt.args.dhcpv4)
})
}
}
func TestDhcpMsgType(t *testing.T) {
type args struct {
dhcp *layers.DHCPv4
}
tests := []struct {
name string
args args
want layers.DHCPMsgType
}{
{
name: "DhcpMsgType",
args: args{
dhcp: &layers.DHCPv4{
Options: layers.DHCPOptions{
{
Type: layers.DHCPOptMessageType,
Data: []byte{1},
},
},
},
},
want: layers.DHCPMsgTypeDiscover,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := DhcpMsgType(tt.args.dhcp); !reflect.DeepEqual(got, tt.want) {
t.Errorf("DhcpMsgType() = %v, want %v", got, tt.want)
}
})
}
}
func TestGetIpv4Addr(t *testing.T) {
type args struct {
dhcp *layers.DHCPv4
}
tests := []struct {
name string
args args
want net.IP
want1 int64
}{
{
name: "GetIpv4Addr",
args: args{
dhcp: &layers.DHCPv4{
Options: layers.DHCPOptions{
{
Type: layers.DHCPOptLeaseTime,
Data: []byte{1, 2, 3, 4, 5},
},
},
},
},
want1: int64(16909060),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, got1 := GetIpv4Addr(tt.args.dhcp)
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("GetIpv4Addr() got = %v, want %v", got, tt.want)
}
if got1 != tt.want1 {
t.Errorf("GetIpv4Addr() got1 = %v, want %v", got1, tt.want1)
}
})
}
}
func TestGetIpv6Addr(t *testing.T) {
type args struct {
dhcp6 *layers.DHCPv6
}
b, err := json.Marshal(layers.DHCPv6OptIAAddr)
if err != nil {
panic(err)
}
tests := []struct {
name string
args args
want net.IP
want1 uint32
}{
{
name: "GetIpv6Addr_error",
args: args{
dhcp6: &layers.DHCPv6{
MsgType: layers.DHCPv6MsgTypeReply,
Options: layers.DHCPv6Options{
{
Code: layers.DHCPv6OptIANA,
Data: b,
},
},
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, got1 := GetIpv6Addr(tt.args.dhcp6)
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("GetIpv6Addr() got = %v, want %v", got, tt.want)
}
if got1 != tt.want1 {
t.Errorf("GetIpv6Addr() got1 = %v, want %v", got1, tt.want1)
}
})
}
}
func TestVoltApplication_GetMacLearnerInfo(t *testing.T) {
type args struct {
cntx context.Context
deviceID string
portNumber string
vlanID string
}
vpv := &VoltPortVnet{
Device: "SDX6320031",
Port: "SDX6320031-1",
SVlan: of.VlanAny,
MacAddr: BroadcastMAC,
}
sessions := map[[6]byte]IDhcpRelaySession{}
key := [6]byte{1, 2, 3, 4, 5, 6}
sessions[key] = vpv
network := make(map[uint32]*DhcpRelayVnet)
network[uint32(256)] = &DhcpRelayVnet{
sessions: sessions,
}
dhcpNws.Networks = network
svlan := of.VlanAny
macLearning := MacLearnerInfo{
DeviceID: "SDX6320031",
PortNumber: "SDX6320031-1",
VlanID: svlan.String(),
MacAddress: BroadcastMAC.String(),
}
tests := []struct {
name string
args args
want MacLearnerInfo
wantErr bool
}{
{
name: "VoltApplication_GetMacLearnerInfo",
args: args{
cntx: context.Background(),
deviceID: "SDX6320031",
portNumber: "SDX6320031-1",
vlanID: svlan.String(),
},
want: macLearning,
},
{
name: "VoltApplication_GetMacLearnerInfo_svlan_empty",
args: args{
cntx: context.Background(),
deviceID: "SDX6320031",
portNumber: "SDX6320031-1",
vlanID: "",
},
want: macLearning,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
va := &VoltApplication{}
got, err := va.GetMacLearnerInfo(tt.args.cntx, tt.args.deviceID, tt.args.portNumber, tt.args.vlanID)
if (err != nil) != tt.wantErr {
t.Errorf("VoltApplication.GetMacLearnerInfo() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("VoltApplication.GetMacLearnerInfo() = %v, want %v", got, tt.want)
}
})
}
}
func TestVoltApplication_GetAllocations(t *testing.T) {
type args struct {
cntx context.Context
deviceID string
}
allocation := []DhcpAllocation{}
vpv := &VoltPortVnet{
Device: "SDX6320031",
services: sync.Map{},
}
voltServ := &VoltService{
VoltServiceOper: VoltServiceOper{
Device: "SDX6320031",
},
VoltServiceCfg: VoltServiceCfg{
Name: "SDX6320031-1_SDX6320031-1-4096-2310-4096-65",
},
}
sessions := map[[6]byte]IDhcpRelaySession{}
key := [6]byte{1, 2, 3, 4, 5, 6}
sessions[key] = vpv
network := make(map[uint32]*DhcpRelayVnet)
network[uint32(256)] = &DhcpRelayVnet{
sessions: sessions,
}
dhcpNws.Networks = network
tests := []struct {
name string
args args
want []DhcpAllocation
wantErr bool
}{
{
name: "VoltApplication_GetAllocations",
args: args{
cntx: context.Background(),
deviceID: "SDX6320031",
},
want: allocation,
},
{
name: "GetAllocations_with_Services",
args: args{
cntx: context.Background(),
deviceID: "SDX6320031",
},
want: allocation,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
va := &VoltApplication{}
switch tt.name {
case "VoltApplication_GetAllocations":
got, err := va.GetAllocations(tt.args.cntx, tt.args.deviceID)
if (err != nil) != tt.wantErr {
t.Errorf("VoltApplication.GetAllocations() error = %v, wantErr %v", err, tt.wantErr)
return
}
assert.NotNil(t, got)
case "GetAllocations_with_Services":
vpv.services.Store("SDX6320031-1_SDX6320031-1-4096-2310-4096-65", voltServ)
got, err := va.GetAllocations(tt.args.cntx, tt.args.deviceID)
if (err != nil) != tt.wantErr {
t.Errorf("VoltApplication.GetAllocations() error = %v, wantErr %v", err, tt.wantErr)
return
}
assert.NotNil(t, got)
}
})
}
}
func TestVoltApplication_GetAllMacLearnerInfo(t *testing.T) {
vpv := &VoltPortVnet{
Device: "SDX6320031",
Port: "SDX6320031-1",
SVlan: of.VlanAny,
MacAddr: BroadcastMAC,
}
sessions := map[[6]byte]IDhcpRelaySession{}
key := [6]byte{1, 2, 3, 4, 5, 6}
sessions[key] = vpv
network := make(map[uint32]*DhcpRelayVnet)
network[uint32(256)] = &DhcpRelayVnet{
sessions: sessions,
}
dhcpNws.Networks = network
svlan := of.VlanAny
macLearningList := []MacLearnerInfo{}
macLearning := MacLearnerInfo{
DeviceID: "SDX6320031",
PortNumber: "SDX6320031-1",
VlanID: svlan.String(),
MacAddress: BroadcastMAC.String(),
}
macLearningList = append(macLearningList, macLearning)
tests := []struct {
name string
want []MacLearnerInfo
wantErr bool
}{
{
name: "VoltApplication_GetAllMacLearnerInfo",
want: macLearningList,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
va := &VoltApplication{}
got, err := va.GetAllMacLearnerInfo()
if (err != nil) != tt.wantErr {
t.Errorf("VoltApplication.GetAllMacLearnerInfo() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("VoltApplication.GetAllMacLearnerInfo() = %v, want %v", got, tt.want)
}
})
}
}
func Test_raiseDHCPv4Indication(t *testing.T) {
voltServ := &VoltService{
VoltServiceOper: VoltServiceOper{
Device: "SDX6320031",
},
VoltServiceCfg: VoltServiceCfg{
IsActivated: true,
Pbits: []of.PbitType{
of.PbitNone,
},
},
}
voltPortVnet := &VoltPortVnet{
Device: "SDX6320031",
Port: "16777472",
DeleteInProgress: false,
services: sync.Map{},
SVlan: 4096,
CVlan: 2310,
UniVlan: 4096,
SVlanTpid: 65,
servicesCount: atomic.NewUint64(1),
}
voltPortVnet.services.Store("SDX6320031-1_SDX6320031-1-4096-2310-4096-65", voltServ)
type args struct {
msgType layers.DHCPMsgType
vpv *VoltPortVnet
smac net.HardwareAddr
ip net.IP
pktPbit uint8
device string
leaseTime int64
}
tests := []struct {
name string
args args
}{
{
name: "raiseDHCPv4Indication_DHCPMsgTypeDiscover",
args: args{
msgType: layers.DHCPMsgTypeDiscover,
vpv: voltPortVnet,
device: "SDX6320031",
},
},
{
name: "raiseDHCPv4Indication_DHCPMsgTypeRequest",
args: args{
msgType: layers.DHCPMsgTypeRequest,
vpv: voltPortVnet,
},
},
{
name: "raiseDHCPv4Indication_DHCPMsgTypeRelease",
args: args{
msgType: layers.DHCPMsgTypeRelease,
vpv: voltPortVnet,
},
},
{
name: "raiseDHCPv4Indication_DHCPMsgTypeAck",
args: args{
msgType: layers.DHCPMsgTypeAck,
vpv: voltPortVnet,
},
},
{
name: "raiseDHCPv4Indication_DHCPMsgTypeNak",
args: args{
msgType: layers.DHCPMsgTypeNak,
vpv: voltPortVnet,
},
},
{
name: "raiseDHCPv4Indication_DHCPMsgTypeOffer",
args: args{
msgType: layers.DHCPMsgTypeOffer,
vpv: voltPortVnet,
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
raiseDHCPv4Indication(tt.args.msgType, tt.args.vpv, tt.args.smac, tt.args.ip, tt.args.pktPbit, tt.args.device, tt.args.leaseTime)
})
}
}
func Test_raiseDHCPv6Indication(t *testing.T) {
voltServ := &VoltService{
VoltServiceOper: VoltServiceOper{
Device: "SDX6320031",
},
VoltServiceCfg: VoltServiceCfg{
IsActivated: true,
Pbits: []of.PbitType{
of.PbitNone,
},
},
}
voltPortVnet := &VoltPortVnet{
Device: "SDX6320031",
Port: "16777472",
DeleteInProgress: false,
services: sync.Map{},
SVlan: 4096,
CVlan: 2310,
UniVlan: 4096,
SVlanTpid: 65,
servicesCount: atomic.NewUint64(1),
}
voltPortVnet.services.Store("SDX6320031-1_SDX6320031-1-4096-2310-4096-65", voltServ)
type args struct {
msgType layers.DHCPv6MsgType
vpv *VoltPortVnet
smac net.HardwareAddr
ip net.IP
pktPbit uint8
device string
leaseTime uint32
}
tests := []struct {
name string
args args
}{
{
name: "raiseDHCPv6Indication_DHCPv6MsgTypeSolicit",
args: args{
msgType: layers.DHCPv6MsgTypeSolicit,
vpv: voltPortVnet,
device: "SDX6320031",
},
},
{
name: "raiseDHCPv4Indication_DHCPv6MsgTypeRelease",
args: args{
msgType: layers.DHCPv6MsgTypeRelease,
vpv: voltPortVnet,
},
},
{
name: "raiseDHCPv4Indication_DHCPv6MsgTypeReply",
args: args{
msgType: layers.DHCPv6MsgTypeReply,
vpv: voltPortVnet,
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
raiseDHCPv6Indication(tt.args.msgType, tt.args.vpv, tt.args.smac, tt.args.ip, tt.args.pktPbit, tt.args.device, tt.args.leaseTime)
})
}
}
func TestVoltApplication_ProcessUDP6Packet(t *testing.T) {
type args struct {
cntx context.Context
device string
port string
pkt gopacket.Packet
}
pkt := mocks.NewMockPacket(gomock.NewController(t))
dhcpv6 := &layers.DHCPv6{
MsgType: layers.DHCPv6MsgTypeSolicit,
}
ipv6 := &layers.IPv6{
Version: EtherType8100,
}
uup := &layers.UDP{
SrcPort: opt82,
}
tests := []struct {
name string
args args
want []byte
}{
{
name: "ProcessUDP6Packet_DHCPv6MsgTypeSolicit",
args: args{
cntx: context.Background(),
device: "SDX6320031",
port: "16777472",
pkt: pkt,
},
},
{
name: "ProcessUDP6Packet_DHCPv6MsgTypeAdvertise",
args: args{
cntx: context.Background(),
device: "SDX6320031",
port: "16777472",
pkt: pkt,
},
},
{
name: "ProcessUDP6Packet_DHCPv6MsgTypeRelayForward",
args: args{
cntx: context.Background(),
device: "SDX6320031",
port: "16777472",
pkt: pkt,
},
},
{
name: "ProcessUDP6Packet_DHCPv6MsgTypeRelayReply",
args: args{
cntx: context.Background(),
device: "SDX6320031",
port: "16777472",
pkt: pkt,
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
va := &VoltApplication{}
switch tt.name {
case "ProcessUDP6Packet_DHCPv6MsgTypeSolicit":
pkt.EXPECT().Layer(layers.LayerTypeDHCPv6).Return(dhcpv6).Times(2)
pkt.EXPECT().Data().Times(1)
pkt.EXPECT().Layers().Return(LayerTypeDot2Q).Times(2)
if got := va.ProcessUDP6Packet(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt); !reflect.DeepEqual(got, tt.want) {
t.Errorf("VoltApplication.ProcessUDP6Packet() = %v, want %v", got, tt.want)
}
case "ProcessUDP6Packet_DHCPv6MsgTypeAdvertise":
dhcpv6.MsgType = layers.DHCPv6MsgTypeAdvertise
pkt.EXPECT().Layer(layers.LayerTypeDHCPv6).Return(dhcpv6).Times(2)
if got := va.ProcessUDP6Packet(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt); !reflect.DeepEqual(got, tt.want) {
t.Errorf("VoltApplication.ProcessUDP6Packet() = %v, want %v", got, tt.want)
}
case "ProcessUDP6Packet_DHCPv6MsgTypeRelayForward":
dhcpv6.MsgType = layers.DHCPv6MsgTypeRelayForward
pkt.EXPECT().Layer(layers.LayerTypeDHCPv6).Return(dhcpv6).Times(2)
if got := va.ProcessUDP6Packet(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt); !reflect.DeepEqual(got, tt.want) {
t.Errorf("VoltApplication.ProcessUDP6Packet() = %v, want %v", got, tt.want)
}
case "ProcessUDP6Packet_DHCPv6MsgTypeRelayReply":
dhcpv6.MsgType = layers.DHCPv6MsgTypeRelayReply
pkt.EXPECT().Data().Times(1)
pkt.EXPECT().Layer(layers.LayerTypeEthernet).Return(eth).Times(1)
pkt.EXPECT().Layer(layers.LayerTypeIPv6).Return(ipv6).Times(1)
pkt.EXPECT().Layer(layers.LayerTypeUDP).Return(uup).Times(1)
if got := va.ProcessUDP6Packet(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt); !reflect.DeepEqual(got, tt.want) {
t.Errorf("VoltApplication.ProcessUDP6Packet() = %v, want %v", got, tt.want)
}
}
})
}
}
func TestBuildRelayFwd(t *testing.T) {
type args struct {
paddr net.IP
intfID []byte
remoteID []byte
payload []byte
isOption82Enabled bool
dhcpRelay bool
}
tests := []struct {
name string
args args
want *layers.DHCPv6
}{
{
name: "BuildRelayFwd",
args: args{
paddr: AllSystemsMulticastGroupIP,
intfID: AllSystemsMulticastGroupIP,
remoteID: AllSystemsMulticastGroupIP,
payload: AllSystemsMulticastGroupIP,
isOption82Enabled: true,
dhcpRelay: true,
},
want: &layers.DHCPv6{},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := BuildRelayFwd(tt.args.paddr, tt.args.intfID, tt.args.remoteID, tt.args.payload, tt.args.isOption82Enabled, tt.args.dhcpRelay)
assert.NotNil(t, got)
})
}
}
func TestGetRelayReplyBytes(t *testing.T) {
type args struct {
dhcp6 *layers.DHCPv6
}
tests := []struct {
name string
args args
want []byte
}{
{
name: "BuildRelayFwd",
args: args{
dhcp6: &layers.DHCPv6{
Options: make(layers.DHCPv6Options, 1),
},
},
want: AllSystemsMulticastGroupIP,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := GetRelayReplyBytes(tt.args.dhcp6)
assert.Nil(t, got)
})
}
}
func TestVoltApplication_ProcessUsDhcpv6Packet(t *testing.T) {
type args struct {
cntx context.Context
device string
port string
pkt gopacket.Packet
}
voltDevice := &VoltDevice{
Name: "11c3175b-50f3-4220-9555-93df733ded1d",
SerialNum: "SDX6320031",
SouthBoundID: "68580342-6b3e-57cb-9ea4-06125594e330",
NniPort: "16777472",
Ports: sync.Map{},
PonPortList: sync.Map{},
}
pkt := mocks.NewMockPacket(gomock.NewController(t))
tests := []struct {
name string
args args
}{
{
name: "ProcessUsDhcpv6Packet",
args: args{
cntx: context.Background(),
device: "SDX6320031",
port: "16777472",
pkt: pkt,
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
va := &VoltApplication{
DevicesDisc: sync.Map{},
}
va.DevicesDisc.Store("SDX6320031", voltDevice)
pkt.EXPECT().Data().Times(1)
pkt.EXPECT().Layers().Return(LayerTypeDot2Q).Times(2)
va.ProcessUsDhcpv6Packet(tt.args.cntx, tt.args.device, tt.args.port, tt.args.pkt)
})
}
}