Adding UTs part-1
Change-Id: I7fdb7751f536d1a616cf2a81b7ef16747d71f692
diff --git a/internal/pkg/application/service_test.go b/internal/pkg/application/service_test.go
new file mode 100644
index 0000000..b9c458b
--- /dev/null
+++ b/internal/pkg/application/service_test.go
@@ -0,0 +1,1552 @@
+/*
+* 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"
+ "errors"
+ "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"
+ "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"
+)
+
+var test_device = "test_device"
+var voltPort = &VoltPort{
+ Name: "test_name",
+ Device: test_device,
+}
+var voltDevice = &VoltDevice{
+ Name: "test_name",
+ State: controller.DeviceStateUP,
+ FlowAddEventMap: util.NewConcurrentMap(),
+ FlowDelEventMap: util.NewConcurrentMap(),
+ SerialNum: "test_serial_number",
+}
+
+var voltMeter = &VoltMeter{
+ Name: "test_volt_meter",
+ Version: "test_version",
+}
+
+var voltVnet = &VoltVnet{
+ Version: "test_version",
+ VnetConfig: VnetConfig{
+ Name: "test_name",
+ },
+}
+
+var voltPortVnet1 = []*VoltPortVnet{
+ {
+ Device: "4096-4096-4096",
+ SVlan: of.VlanAny,
+ CVlan: of.VlanAny,
+ UniVlan: of.VlanAny,
+ IgmpEnabled: true,
+ servicesCount: &atomic.Uint64{},
+ },
+}
+
+var voltDevice1 = &VoltDevice{
+ State: cntlr.DeviceStateDOWN,
+}
+
+var GetDeviceFromPort_error = "GetDeviceFromPort_error"
+
+func TestVoltApplication_RestoreSvcsFromDb(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "VoltApplication_RestoreSvcsFromDb",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: "invalid_value_type",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: "unmarshal_error",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ voltService := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ Device: "SDX6320031",
+ ForceDelete: true,
+ DeleteInProgress: true,
+ },
+ VoltServiceCfg: VoltServiceCfg{
+ Name: "test_service_name",
+ },
+ }
+ serviceToDelete := map[string]bool{}
+ serviceToDelete[voltService.VoltServiceCfg.Name] = true
+ va := &VoltApplication{
+ ServicesToDelete: serviceToDelete,
+ }
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ switch tt.name {
+ case "VoltApplication_RestoreSvcsFromDb":
+
+ b, err := json.Marshal(voltService)
+ if err != nil {
+ panic(err)
+ }
+ kvPair := map[string]*kvstore.KVPair{}
+ kvPair["key"] = &kvstore.KVPair{
+ Key: "test_key",
+ Value: b,
+ Version: 1,
+ }
+ dbintf.EXPECT().GetServices(tt.args.cntx).Return(kvPair, nil).Times(1)
+ va.RestoreSvcsFromDb(tt.args.cntx)
+ case "invalid_value_type":
+ kvPair := map[string]*kvstore.KVPair{}
+ kvPair["key"] = &kvstore.KVPair{
+ Key: "test_key",
+ Value: "invalid_value",
+ Version: 1,
+ }
+ dbintf.EXPECT().GetServices(tt.args.cntx).Return(kvPair, nil).Times(1)
+ va.RestoreSvcsFromDb(tt.args.cntx)
+ case "unmarshal_error":
+ b, err := json.Marshal("test")
+ if err != nil {
+ panic(err)
+ }
+ kvPair := map[string]*kvstore.KVPair{}
+ kvPair["key"] = &kvstore.KVPair{
+ Key: "test_key",
+ Value: b,
+ Version: 1,
+ }
+ dbintf.EXPECT().GetServices(tt.args.cntx).Return(kvPair, nil).Times(1)
+ va.RestoreSvcsFromDb(tt.args.cntx)
+ }
+ })
+ }
+}
+
+func TestVoltService_FlowRemoveFailure(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ cookie string
+ errorCode uint32
+ errReason string
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "VoltService_FlowRemoveFailure",
+ args: args{
+ cntx: context.Background(),
+ cookie: "test_cookie",
+ errorCode: 200,
+ errReason: "test_reason",
+ },
+ },
+ {
+ name: "cookie_not_found",
+ args: args{
+ cntx: context.Background(),
+ cookie: "test_cookie",
+ errorCode: 200,
+ errReason: "test_reason",
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ switch tt.name {
+ case "VoltService_FlowRemoveFailure":
+ associatedFlows := map[string]bool{}
+ associatedFlows["test_cookie"] = true
+ vs := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ AssociatedFlows: associatedFlows,
+ },
+ }
+ vs.FlowRemoveFailure(tt.args.cntx, tt.args.cookie, tt.args.errorCode, tt.args.errReason)
+ case "cookie_not_found":
+ associatedFlows := map[string]bool{}
+ associatedFlows["cookie"] = true
+ vs := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ AssociatedFlows: associatedFlows,
+ },
+ }
+ vs.FlowRemoveFailure(tt.args.cntx, tt.args.cookie, tt.args.errorCode, tt.args.errReason)
+ }
+ })
+ }
+}
+
+func TestVoltApplication_GetServiceNameFromCookie(t *testing.T) {
+ type args struct {
+ cookie uint64
+ portName string
+ pbit uint8
+ device string
+ tableMetadata uint64
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "VoltApplication_GetServiceNameFromCookie",
+ args: args{
+ cookie: uint64(1),
+ portName: "test_port_name",
+ device: "SDX6320031",
+ pbit: 2,
+ tableMetadata: uint64(2),
+ },
+ },
+ }
+ voltDev := &VoltDevice{
+ Name: "SDX6320031",
+ SerialNum: "SDX6320031",
+ NniDhcpTrapVid: 123,
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ ga := GetApplication()
+ ga.DevicesDisc.Store("SDX6320031", voltDev)
+ voltPortVnets := make([]*VoltPortVnet, 0)
+ voltPortVnet := &VoltPortVnet{
+ Device: test_device,
+ VlanControl: ONUCVlanOLTSVlan,
+ }
+ voltPortVnets = append(voltPortVnets, voltPortVnet)
+ ga.VnetsByPort.Store("test_port_name", voltPortVnets)
+ got := ga.GetServiceNameFromCookie(tt.args.cookie, tt.args.portName, tt.args.pbit, tt.args.device, tt.args.tableMetadata)
+ assert.Nil(t, got)
+ })
+ }
+}
+
+func TestVoltService_SvcUpInd(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "VoltService_SvcUpInd",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vs := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ PendingFlows: make(map[string]bool),
+ },
+ VoltServiceCfg: VoltServiceCfg{
+ SVlanTpid: layers.EthernetTypeDot1Q,
+ MacAddr: layers.EthernetBroadcast,
+ },
+ }
+ vs.Port = test_device
+ vs.Device = "device"
+ ga := GetApplication()
+ _ = cntlr.NewController(context.Background(), mocks.NewMockApp(gomock.NewController(t)))
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+ ga.PortsDisc.Store(test_device, voltPort)
+ ga.DevicesDisc.Store(test_device, voltDevice)
+ vs.SvcUpInd(tt.args.cntx)
+ })
+ }
+}
+
+func TestVoltService_SvcDownInd(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "VoltService_SvcDownInd",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vs := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ UsHSIAFlowsApplied: true,
+ DsHSIAFlowsApplied: true,
+ },
+ VoltServiceCfg: VoltServiceCfg{
+ SVlanTpid: layers.EthernetTypeQinQ,
+ MacAddr: layers.EthernetBroadcast,
+ },
+ }
+ vs.Port = test_device
+ vs.Device = "device"
+ ga := GetApplication()
+ _ = cntlr.NewController(context.Background(), mocks.NewMockApp(gomock.NewController(t)))
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+ ga.PortsDisc.Store(test_device, voltPort)
+ ga.DevicesDisc.Store(test_device, voltDevice)
+ vs.SvcDownInd(tt.args.cntx)
+ })
+ }
+}
+
+func TestVoltApplication_AddService(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ cfg VoltServiceCfg
+ oper *VoltServiceOper
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "VoltApplication_AddService",
+ args: args{
+ cntx: context.Background(),
+ cfg: VoltServiceCfg{
+ Name: "test_name",
+ Port: "test_port",
+ DsMeterProfile: "4096-4096-4096",
+ UsMeterProfile: "4096-4096-4096",
+ SVlan: of.VlanAny,
+ CVlan: of.VlanAny,
+ UniVlan: of.VlanAny,
+ MacLearning: Learn,
+ IsActivated: true,
+ },
+ oper: &VoltServiceOper{
+ Device: "4096-4096-4096",
+ },
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ va := &VoltApplication{
+ MeterMgr: MeterMgr{
+ Meters: sync.Map{},
+ },
+ VnetsByPort: sync.Map{},
+ VnetsByTag: sync.Map{},
+ }
+ va.MeterMgr.Meters.Store("4096-4096-4096", voltMeter)
+ va.VnetsByTag.Store("4096-4096-4096", voltVnet)
+ voltPortVnet1[0].SVlan = of.VlanAny
+ voltPortVnet1[0].CVlan = of.VlanAny
+ voltPortVnet1[0].UniVlan = of.VlanAny
+ voltPortVnet1[0].servicesCount = atomic.NewUint64(uint64(56))
+ voltPortVnet1[0].MacAddr = layers.EthernetBroadcast
+ voltPortVnet1[0].Port = "test_port"
+ va.VnetsByPort.Store("test_port", voltPortVnet1)
+ ga := GetApplication()
+ voltPort1 := &VoltPort{
+ Name: "test_name",
+ Device: test_device,
+ }
+ deviceConfig := &DeviceConfig{
+ SerialNumber: "test_serial_number",
+ }
+ ga.PortsDisc.Store("test_port", voltPort1)
+ ga.DevicesDisc.Store(test_device, voltDevice)
+ ga.DevicesConfig.Store("test_serial_number", deviceConfig)
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+ dbintf.EXPECT().PutVpv(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).Times(1)
+ err := va.AddService(tt.args.cntx, tt.args.cfg, tt.args.oper)
+ assert.Nil(t, err)
+ })
+ }
+}
+
+func TestVoltApplication_DelService(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ name string
+ forceDelete bool
+ newSvc *VoltServiceCfg
+ serviceMigration bool
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "VoltApplication_DelService",
+ args: args{
+ cntx: context.Background(),
+ name: "test_name",
+ forceDelete: true,
+ newSvc: &VoltServiceCfg{
+ Name: "vs_cfg_name",
+ Port: "test_port",
+ },
+ serviceMigration: true,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ va := &VoltApplication{
+ ServiceByName: sync.Map{},
+ VnetsByPort: sync.Map{},
+ }
+ voltService := &VoltService{
+ Version: "test_version",
+ VoltServiceCfg: VoltServiceCfg{
+ Port: "4096-4096-4096",
+ SVlan: of.VlanAny,
+ CVlan: of.VlanAny,
+ UniVlan: of.VlanAny,
+ },
+ }
+ va.ServiceByName.Store(tt.args.name, voltService)
+ va.VnetsByPort.Store("4096-4096-4096", voltPortVnet1)
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().DelService(gomock.Any(), gomock.Any()).AnyTimes()
+ dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+ va.DelService(tt.args.cntx, tt.args.name, tt.args.forceDelete, tt.args.newSvc, tt.args.serviceMigration)
+ })
+ }
+}
+
+func TestVoltService_FlowInstallSuccess(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ cookie string
+ bwAvailInfo of.BwAvailDetails
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "VoltService_FlowInstallSuccess",
+ args: args{
+ cntx: context.Background(),
+ cookie: "test_cookie",
+ bwAvailInfo: of.BwAvailDetails{
+ PrevBw: "test_prev_BW",
+ PresentBw: "test_present_BW",
+ },
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ pendingFlows := map[string]bool{}
+ pendingFlows["test_cookie"] = true
+ associatedFlows := map[string]bool{}
+ associatedFlows["test_cookie"] = true
+ vs := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ PendingFlows: pendingFlows,
+ AssociatedFlows: associatedFlows,
+ DsHSIAFlowsApplied: true,
+ },
+ VoltServiceCfg: VoltServiceCfg{
+ Port: "test_port",
+ },
+ }
+ ga := GetApplication()
+ ga.PortsDisc.Store("test_port", voltPort)
+ ga.DevicesDisc.Store(test_device, voltDevice)
+ vs.FlowInstallSuccess(tt.args.cntx, tt.args.cookie, tt.args.bwAvailInfo)
+ })
+ }
+}
+
+func TestVoltService_AddMeterToDevice(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "VoltService_AddMeterToDevice",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: GetDeviceFromPort_error,
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: "DeviceState_down",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ switch tt.name {
+ case "VoltService_AddMeterToDevice":
+ vs := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ DeleteInProgress: true,
+ },
+ VoltServiceCfg: VoltServiceCfg{
+ Port: "test_port",
+ },
+ }
+ ga := GetApplication()
+ ga.PortsDisc.Store("test_port", voltPort)
+ ga.DevicesDisc.Store(test_device, voltDevice)
+ err := vs.AddMeterToDevice(tt.args.cntx)
+ assert.Nil(t, err)
+ case GetDeviceFromPort_error:
+ vs := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ DeleteInProgress: true,
+ },
+ VoltServiceCfg: VoltServiceCfg{
+ Port: "",
+ },
+ }
+ err := vs.AddMeterToDevice(tt.args.cntx)
+ assert.NotNil(t, err)
+ case "DeviceState_down":
+ vs := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ DeleteInProgress: true,
+ },
+ VoltServiceCfg: VoltServiceCfg{
+ Port: "test_port",
+ },
+ }
+ ga := GetApplication()
+ ga.PortsDisc.Store("test_port", voltPort)
+ ga.DevicesDisc.Store(test_device, voltDevice1)
+ err := vs.AddMeterToDevice(tt.args.cntx)
+ assert.Nil(t, err)
+ }
+ })
+ }
+}
+
+func TestVoltService_AddUsHsiaFlows(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "DeleteInProgress_true",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: "GetDeviceFromPort_error",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ {
+ name: "DeviceState_down",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ switch tt.name {
+ case "DeleteInProgress_true":
+ vs := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ DeleteInProgress: true,
+ },
+ }
+ err := vs.AddUsHsiaFlows(tt.args.cntx)
+ assert.Nil(t, err)
+ case "GetDeviceFromPort_error":
+ vs := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ DeleteInProgress: false,
+ },
+ }
+ err := vs.AddUsHsiaFlows(tt.args.cntx)
+ assert.NotNil(t, err)
+ case "DeviceState_down":
+ vs := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ DeleteInProgress: false,
+ },
+ VoltServiceCfg: VoltServiceCfg{
+ Port: "test_port",
+ },
+ }
+ ga := GetApplication()
+ ga.PortsDisc.Store("test_port", voltPort)
+ ga.DevicesDisc.Store(test_device, voltDevice1)
+ err := vs.AddUsHsiaFlows(tt.args.cntx)
+ assert.Nil(t, err)
+ }
+ })
+ }
+}
+
+func TestVoltService_AddHsiaFlows(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "AddUsHsiaFlows_error",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vs := &VoltService{
+ VoltServiceCfg: VoltServiceCfg{
+ Port: "test_port",
+ VlanControl: 5,
+ },
+ }
+ ga := GetApplication()
+ ga.PortsDisc.Store("test_port", voltPort)
+ ga.DevicesDisc.Store(test_device, voltDevice)
+ vs.AddHsiaFlows(tt.args.cntx)
+ })
+ }
+}
+
+func TestVoltService_ForceWriteToDb(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ tests := []struct {
+ name string
+ args args
+ }{
+ {
+ name: "PutService_error",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ switch tt.name {
+ case "PutService_error":
+ vs := &VoltService{}
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(errors.New("error")).AnyTimes()
+ vs.ForceWriteToDb(tt.args.cntx)
+ }
+ })
+ }
+}
+
+func TestVoltService_isDataRateAttrPresent(t *testing.T) {
+ tests := []struct {
+ name string
+ want bool
+ }{
+ {
+ name: "VoltService_isDataRateAttrPresent",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vs := &VoltService{}
+ if got := vs.isDataRateAttrPresent(); got != tt.want {
+ t.Errorf("VoltService.isDataRateAttrPresent() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestVoltService_GetServicePbit(t *testing.T) {
+ tests := []struct {
+ name string
+ want int
+ }{
+ {
+ name: "VoltService_GetServicePbit",
+ want: -1,
+ },
+ {
+ name: "!IsPbitExist",
+ want: 8,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ switch tt.name {
+ case "VoltService_GetServicePbit":
+ vs := &VoltService{
+ VoltServiceCfg: VoltServiceCfg{
+ Pbits: []of.PbitType{of.PbitMatchAll},
+ },
+ }
+ if got := vs.GetServicePbit(); got != tt.want {
+ t.Errorf("VoltService.GetServicePbit() = %v, want %v", got, tt.want)
+ }
+ case "!IsPbitExist":
+ vs := &VoltService{}
+ if got := vs.GetServicePbit(); got != tt.want {
+ t.Errorf("VoltService.GetServicePbit() = %v, want %v", got, tt.want)
+ }
+ }
+ })
+ }
+}
+
+func TestVoltApplication_DeactivateService(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ deviceID string
+ portNo string
+ sVlan of.VlanType
+ cVlan of.VlanType
+ tpID uint16
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "VoltApplication_DeactivateService",
+ args: args{
+ cntx: context.Background(),
+ deviceID: "test_device_id",
+ portNo: "test_port",
+ sVlan: of.VlanNone,
+ cVlan: of.VlanAny,
+ tpID: AnyVlan,
+ },
+ },
+ {
+ name: "VoltPortVnet_nil",
+ args: args{
+ cntx: context.Background(),
+ deviceID: "test_device_id",
+ portNo: "test_port",
+ sVlan: of.VlanNone,
+ cVlan: of.VlanAny,
+ tpID: AnyVlan,
+ },
+ },
+ {
+ name: "sVlan != of.VlanNone",
+ args: args{
+ cntx: context.Background(),
+ deviceID: "test_device_id",
+ portNo: "test_port",
+ sVlan: of.VlanAny,
+ cVlan: of.VlanAny,
+ tpID: AnyVlan,
+ },
+ },
+ {
+ name: GetDeviceFromPort_error,
+ args: args{
+ cntx: context.Background(),
+ deviceID: "test_device_id",
+ portNo: "test_port",
+ sVlan: of.VlanNone,
+ cVlan: of.VlanAny,
+ tpID: AnyVlan,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ va := &VoltApplication{
+ ServiceByName: sync.Map{},
+ VnetsByPort: sync.Map{},
+ DevicesDisc: sync.Map{},
+ PortsDisc: sync.Map{},
+ }
+ voltServiceTest := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ Device: test_device,
+ },
+ Version: "test_version",
+ VoltServiceCfg: VoltServiceCfg{
+ Port: "test_port",
+ Name: "test_name",
+ IsActivated: true,
+ CVlan: of.VlanAny,
+ SVlan: of.VlanAny,
+ UniVlan: of.VlanAny,
+ },
+ }
+ switch tt.name {
+ case "VoltApplication_DeactivateService":
+ va.ServiceByName.Store("test_name", voltServiceTest)
+ va.PortsDisc.Store("test_port", voltPort)
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+ va.DevicesDisc.Store(test_device, voltDevice)
+ voltDevice.Ports.Store("test_port", voltPort)
+ va.VnetsByPort.Store("test_port", voltPortVnet1)
+ voltPortVnet1[0].servicesCount.Store(uint64(1))
+ dbintf.EXPECT().PutVpv(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+ if err := va.DeactivateService(tt.args.cntx, tt.args.deviceID, tt.args.portNo, tt.args.sVlan, tt.args.cVlan, tt.args.tpID); (err != nil) != tt.wantErr {
+ t.Errorf("VoltApplication.DeactivateService() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "VoltPortVnet_nil":
+ va.ServiceByName.Store("test_name", voltServiceTest)
+ va.PortsDisc.Store("test_port", voltPort)
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+ va.DevicesDisc.Store(test_device, voltDevice)
+ voltDevice.Ports.Store("test_port", voltPort)
+ if err := va.DeactivateService(tt.args.cntx, tt.args.deviceID, tt.args.portNo, tt.args.sVlan, tt.args.cVlan, tt.args.tpID); (err != nil) != tt.wantErr {
+ t.Errorf("VoltApplication.DeactivateService() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "sVlan != of.VlanNone":
+ va.ServiceByName.Store("test_name", voltServiceTest)
+ if err := va.DeactivateService(tt.args.cntx, tt.args.deviceID, tt.args.portNo, tt.args.sVlan, tt.args.cVlan, tt.args.tpID); (err != nil) != tt.wantErr {
+ t.Errorf("VoltApplication.DeactivateService() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case GetDeviceFromPort_error:
+ va.ServiceByName.Store("test_name", voltServiceTest)
+ if err := va.DeactivateService(tt.args.cntx, tt.args.deviceID, tt.args.portNo, tt.args.sVlan, tt.args.cVlan, tt.args.tpID); (err != nil) != tt.wantErr {
+ t.Errorf("VoltApplication.DeactivateService() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ }
+ })
+ }
+}
+
+func TestVoltApplication_ActivateService(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ deviceID string
+ portNo string
+ sVlan of.VlanType
+ cVlan of.VlanType
+ tpID uint16
+ }
+ tests := []struct {
+ name string
+ args args
+ wantErr bool
+ }{
+ {
+ name: "VoltApplication_ActivateService",
+ args: args{
+ cntx: context.Background(),
+ deviceID: "test_name",
+ portNo: "test_port",
+ sVlan: of.VlanNone,
+ cVlan: of.VlanAny,
+ tpID: AnyVlan,
+ },
+ },
+ {
+ name: "VoltPortVnet_nil",
+ args: args{
+ cntx: context.Background(),
+ deviceID: "test_name",
+ portNo: "test_port",
+ sVlan: of.VlanNone,
+ cVlan: of.VlanAny,
+ tpID: AnyVlan,
+ },
+ },
+ {
+ name: GetDeviceFromPort_error,
+ args: args{
+ cntx: context.Background(),
+ deviceID: "test_name",
+ portNo: "test_port",
+ sVlan: of.VlanNone,
+ cVlan: of.VlanAny,
+ tpID: AnyVlan,
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ va := &VoltApplication{
+ DevicesDisc: sync.Map{},
+ }
+ var voltPortTest = &VoltPort{
+ Name: "test_name",
+ State: PortStateUp,
+ }
+ voltServiceTest := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ Device: test_device,
+ },
+ Version: "test_version",
+ VoltServiceCfg: VoltServiceCfg{
+ Port: "test_port",
+ Name: "test_name",
+ IsActivated: false,
+ CVlan: of.VlanAny,
+ SVlan: of.VlanAny,
+ UniVlan: of.VlanAny,
+ },
+ }
+ switch tt.name {
+ case "VoltApplication_ActivateService":
+ voltPortTest.Device = test_device
+ va.PortsDisc.Store("test_port", voltPortTest)
+ va.DevicesDisc.Store(test_device, voltDevice)
+ va.ServiceByName.Store("test_name", voltServiceTest)
+ va.VnetsByPort.Store("test_port", voltPortVnet1)
+ voltDevice.Ports.Store("test_port", voltPortTest)
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+ if err := va.ActivateService(tt.args.cntx, tt.args.deviceID, tt.args.portNo, tt.args.sVlan, tt.args.cVlan, tt.args.tpID); (err != nil) != tt.wantErr {
+ t.Errorf("VoltApplication.ActivateService() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case "VoltPortVnet_nil":
+ voltPortTest.Device = test_device
+ va.ServiceByName.Store("test_name", voltServiceTest)
+ va.PortsDisc.Store("test_port", voltPortTest)
+ dbintf := mocks.NewMockDBIntf(gomock.NewController(t))
+ db = dbintf
+ dbintf.EXPECT().PutService(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+ va.DevicesDisc.Store(test_device, voltDevice)
+ voltDevice.Ports.Store("test_port", voltPortTest)
+ if err := va.ActivateService(tt.args.cntx, tt.args.deviceID, tt.args.portNo, tt.args.sVlan, tt.args.cVlan, tt.args.tpID); (err != nil) != tt.wantErr {
+ t.Errorf("VoltApplication.ActivateService() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ case GetDeviceFromPort_error:
+ err := va.ActivateService(tt.args.cntx, tt.args.deviceID, tt.args.portNo, tt.args.sVlan, tt.args.cVlan, tt.args.tpID)
+ assert.NotNil(t, err)
+ }
+ })
+ }
+}
+
+func TestVoltApplication_GetProgrammedSubscribers(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ deviceID string
+ portNo string
+ }
+ tests := []struct {
+ name string
+ args args
+ want []*VoltService
+ wantErr bool
+ }{
+ {
+ name: "VoltApplication_GetProgrammedSubscribers",
+ args: args{
+ cntx: context.Background(),
+ deviceID: test_device,
+ portNo: "test_port",
+ },
+ },
+ {
+ name: "portNo_nil",
+ args: args{
+ cntx: context.Background(),
+ deviceID: test_device,
+ },
+ },
+ {
+ name: "deviceID_nil",
+ args: args{
+ cntx: context.Background(),
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ va := &VoltApplication{
+ vendorID: "test_vendor",
+ }
+ voltServiceTest := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ Device: test_device,
+ },
+ Version: "test_version",
+ VoltServiceCfg: VoltServiceCfg{
+ Port: "test_port",
+ Name: "test_name",
+ IsActivated: false,
+ CVlan: of.VlanAny,
+ SVlan: of.VlanAny,
+ UniVlan: of.VlanAny,
+ },
+ }
+ switch tt.name {
+ case "VoltApplication_GetProgrammedSubscribers":
+ va.ServiceByName.Store("test_name", voltServiceTest)
+ got, err := va.GetProgrammedSubscribers(tt.args.cntx, tt.args.deviceID, tt.args.portNo)
+ assert.NotNil(t, got)
+ assert.Nil(t, err)
+ case "portNo_nil":
+ va.ServiceByName.Store("test_name", voltServiceTest)
+ got, err := va.GetProgrammedSubscribers(tt.args.cntx, tt.args.deviceID, tt.args.portNo)
+ assert.NotNil(t, got)
+ assert.Nil(t, err)
+ case "deviceID_nil":
+ va.ServiceByName.Store("test_name", voltServiceTest)
+ got, err := va.GetProgrammedSubscribers(tt.args.cntx, tt.args.deviceID, tt.args.portNo)
+ assert.NotNil(t, got)
+ assert.Nil(t, err)
+ }
+ })
+ }
+}
+
+func TestVoltService_JSONMarshal(t *testing.T) {
+ tests := []struct {
+ name string
+ }{
+ {
+ name: "VoltService_JSONMarshal",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vs := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ Device: test_device,
+ },
+ Version: "test_version",
+ VoltServiceCfg: VoltServiceCfg{
+ Name: "test_name",
+ },
+ }
+ got, err := vs.JSONMarshal()
+ assert.NotNil(t, got)
+ assert.Nil(t, err)
+ })
+ }
+}
+
+func TestVoltService_triggerServiceInProgressInd(t *testing.T) {
+ tests := []struct {
+ name string
+ }{
+ {
+ name: "VoltService_triggerServiceInProgressInd",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ vs := &VoltService{
+ Version: "test_version",
+ }
+ vs.triggerServiceInProgressInd()
+ })
+ }
+}
+
+func TestVoltService_TriggerAssociatedFlowDelete(t *testing.T) {
+ type args struct {
+ cntx context.Context
+ }
+ tests := []struct {
+ name string
+ args args
+ want bool
+ }{
+ {
+ name: "VoltService_TriggerAssociatedFlowDelete",
+ args: args{
+ cntx: context.Background(),
+ },
+ want: true,
+ },
+ {
+ name: "cookieList_nil",
+ args: args{
+ cntx: context.Background(),
+ },
+ want: false,
+ },
+ }
+ associatedFlows := map[string]bool{}
+ associatedFlows["5765317"] = true
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ switch tt.name {
+ case "VoltService_TriggerAssociatedFlowDelete":
+ vs := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ UsHSIAFlowsApplied: true,
+ DsHSIAFlowsApplied: true,
+ AssociatedFlows: associatedFlows,
+ Device: test_device,
+ },
+ }
+ ga := GetApplication()
+ ga.DevicesDisc.Store(test_device, voltDevice)
+ if got := vs.TriggerAssociatedFlowDelete(tt.args.cntx); got != tt.want {
+ t.Errorf("VoltService.TriggerAssociatedFlowDelete() = %v, want %v", got, tt.want)
+ }
+ case "cookieList_nil":
+ vs := &VoltService{
+ VoltServiceOper: VoltServiceOper{
+ UsHSIAFlowsApplied: true,
+ DsHSIAFlowsApplied: true,
+ Device: test_device,
+ },
+ }
+ ga := GetApplication()
+ ga.DevicesDisc.Store(test_device, voltDevice)
+ if got := vs.TriggerAssociatedFlowDelete(tt.args.cntx); got != tt.want {
+ t.Errorf("VoltService.TriggerAssociatedFlowDelete() = %v, want %v", got, tt.want)
+ }
+ }
+ })
+ }
+}
+
+func TestVoltApplication_DeepEqualServicecfg(t *testing.T) {
+ type args struct {
+ evs *VoltServiceCfg
+ nvs *VoltServiceCfg
+ }
+ a := map[int]int{}
+ a[0] = 0
+ tests := []struct {
+ name string
+ args args
+ want bool
+ }{
+ {
+ name: "VoltApplication_DeepEqualServicecfg",
+ args: args{
+ evs: &VoltServiceCfg{
+ Port: "test_port",
+ },
+ nvs: &VoltServiceCfg{
+ Port: "test_port",
+ },
+ },
+ want: true,
+ },
+ {
+ name: "nvs.Name != evs.Name",
+ args: args{
+ evs: &VoltServiceCfg{
+ Name: "test_name",
+ },
+ nvs: &VoltServiceCfg{
+ Port: "test_port",
+ },
+ },
+ want: false,
+ },
+ {
+ name: "nvs.UniVlan != evs.UniVlan",
+ args: args{
+ evs: &VoltServiceCfg{
+ UniVlan: of.VlanAny,
+ },
+ nvs: &VoltServiceCfg{
+ Port: "test_port",
+ },
+ },
+ want: false,
+ },
+ {
+ name: "nvs.CVlan != evs.CVlan",
+ args: args{
+ evs: &VoltServiceCfg{
+ CVlan: of.VlanAny,
+ },
+ nvs: &VoltServiceCfg{
+ Port: "test_port",
+ },
+ },
+ want: false,
+ },
+ {
+ name: "nvs.SVlan != evs.SVlan",
+ args: args{
+ evs: &VoltServiceCfg{
+ SVlan: of.VlanAny,
+ },
+ nvs: &VoltServiceCfg{
+ Port: "test_port",
+ },
+ },
+ want: false,
+ },
+ {
+ name: "nvs.SVlanTpid != 0",
+ args: args{
+ evs: &VoltServiceCfg{
+ SVlanTpid: layers.EthernetTypeARP,
+ },
+ nvs: &VoltServiceCfg{
+ SVlanTpid: layers.EthernetTypeCiscoDiscovery,
+ },
+ },
+ want: false,
+ },
+ {
+ name: "nvs.Pbits != evs.Pbits",
+ args: args{
+ evs: &VoltServiceCfg{
+ Pbits: []of.PbitType{
+ PbitMatchAll,
+ },
+ },
+ nvs: &VoltServiceCfg{
+ Port: "test_port",
+ },
+ },
+ want: false,
+ },
+ {
+ name: "nvs.DsRemarkPbitsMap != evs.DsRemarkPbitsMap",
+ args: args{
+ evs: &VoltServiceCfg{
+ DsRemarkPbitsMap: a,
+ },
+ nvs: &VoltServiceCfg{
+ Port: "test_port",
+ },
+ },
+ want: false,
+ },
+ {
+ name: "nvs.TechProfileID != evs.TechProfileID",
+ args: args{
+ evs: &VoltServiceCfg{
+ TechProfileID: uint16(1),
+ },
+ nvs: &VoltServiceCfg{
+ Port: "test_port",
+ },
+ },
+ want: false,
+ },
+ {
+ name: "nvs.CircuitID != evs.CircuitID",
+ args: args{
+ evs: &VoltServiceCfg{
+ CircuitID: "test_circuit_id",
+ },
+ nvs: &VoltServiceCfg{
+ Port: "test_port",
+ },
+ },
+ want: false,
+ },
+ {
+ name: "nvs.RemoteID != evs.RemoteID",
+ args: args{
+ evs: &VoltServiceCfg{
+ RemoteID: []byte{1},
+ },
+ nvs: &VoltServiceCfg{
+ Port: "test_port",
+ },
+ },
+ want: false,
+ },
+ {
+ name: "nvs.Port != evs.Port",
+ args: args{
+ evs: &VoltServiceCfg{},
+ nvs: &VoltServiceCfg{
+ Port: "test_port",
+ },
+ },
+ want: false,
+ },
+ {
+ name: "nvs.PonPort != evs.PonPort",
+ args: args{
+ evs: &VoltServiceCfg{},
+ nvs: &VoltServiceCfg{
+ PonPort: uint32(1),
+ },
+ },
+ want: false,
+ },
+ {
+ name: "evs.MacLearning == MacLearningNone",
+ args: args{
+ evs: &VoltServiceCfg{
+ MacAddr: layers.EthernetBroadcast,
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.IgmpEnabled != evs.IgmpEnabled",
+ args: args{
+ evs: &VoltServiceCfg{
+ IgmpEnabled: true,
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.McastService != evs.McastService",
+ args: args{
+ evs: &VoltServiceCfg{
+ McastService: true,
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.ONTEtherTypeClassification != evs.ONTEtherTypeClassification",
+ args: args{
+ evs: &VoltServiceCfg{
+ ONTEtherTypeClassification: 1,
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.UsMeterProfile != evs.UsMeterProfile",
+ args: args{
+ evs: &VoltServiceCfg{
+ UsMeterProfile: "UsMeterProfile",
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.DsMeterProfile != evs.DsMeterProfile",
+ args: args{
+ evs: &VoltServiceCfg{
+ DsMeterProfile: "DsMeterProfile",
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.AggDsMeterProfile != evs.AggDsMeterProfile",
+ args: args{
+ evs: &VoltServiceCfg{
+ AggDsMeterProfile: "AggDsMeterProfile",
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.VnetID != evs.VnetID",
+ args: args{
+ evs: &VoltServiceCfg{
+ VnetID: "VnetID",
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.MvlanProfileName != evs.MvlanProfileName",
+ args: args{
+ evs: &VoltServiceCfg{
+ MvlanProfileName: "MvlanProfileName",
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.RemoteIDType != evs.RemoteIDType",
+ args: args{
+ evs: &VoltServiceCfg{
+ RemoteIDType: "RemoteIDType",
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.SchedID != evs.SchedID",
+ args: args{
+ evs: &VoltServiceCfg{
+ SchedID: 1,
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.AllowTransparent != evs.AllowTransparent",
+ args: args{
+ evs: &VoltServiceCfg{
+ AllowTransparent: true,
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.EnableMulticastKPI != evs.EnableMulticastKPI",
+ args: args{
+ evs: &VoltServiceCfg{
+ EnableMulticastKPI: true,
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.DataRateAttr != evs.DataRateAttr",
+ args: args{
+ evs: &VoltServiceCfg{
+ DataRateAttr: "DataRateAttr",
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.MinDataRateUs != evs.MinDataRateUs",
+ args: args{
+ evs: &VoltServiceCfg{
+ MinDataRateUs: uint32(1),
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.MinDataRateDs != evs.MinDataRateDs",
+ args: args{
+ evs: &VoltServiceCfg{
+ MinDataRateDs: uint32(1),
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.MaxDataRateUs != evs.MaxDataRateUs",
+ args: args{
+ evs: &VoltServiceCfg{
+ MaxDataRateUs: uint32(1),
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ {
+ name: "nvs.MaxDataRateDs != evs.MaxDataRateDs",
+ args: args{
+ evs: &VoltServiceCfg{
+ MaxDataRateDs: uint32(1),
+ },
+ nvs: &VoltServiceCfg{},
+ },
+ want: false,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ va := &VoltApplication{
+ vendorID: "test_vendor_id",
+ }
+ switch tt.name {
+ case "VoltApplication_DeepEqualServicecfg", "nvs.Name != evs.Name", "nvs.UniVlan != evs.UniVlan",
+ "nvs.CVlan != evs.CVlan", "nvs.SVlan != evs.SVlan", "nvs.SVlanTpid != 0", "nvs.Pbits != evs.Pbits",
+ "nvs.DsRemarkPbitsMap != evs.DsRemarkPbitsMap", "nvs.TechProfileID != evs.TechProfileID",
+ "nvs.CircuitID != evs.CircuitID", "nvs.RemoteID != evs.RemoteID", "nvs.Port != evs.Port",
+ "evs.MacLearning == MacLearningNone", "nvs.PonPort != evs.PonPort", "nvs.IgmpEnabled != evs.IgmpEnabled",
+ "nvs.McastService != evs.McastService", "nvs.ONTEtherTypeClassification != evs.ONTEtherTypeClassification",
+ "nvs.UsMeterProfile != evs.UsMeterProfile",
+ "nvs.DsMeterProfile != evs.DsMeterProfile", "nvs.AggDsMeterProfile != evs.AggDsMeterProfile",
+ "nvs.VnetID != evs.VnetID", "nvs.MvlanProfileName != evs.MvlanProfileName",
+ "nvs.RemoteIDType != evs.RemoteIDType", "nvs.SchedID != evs.SchedID",
+ "nvs.AllowTransparent != evs.AllowTransparent",
+ "nvs.EnableMulticastKPI != evs.EnableMulticastKPI", "nvs.DataRateAttr != evs.DataRateAttr",
+ "nvs.MinDataRateUs != evs.MinDataRateUs", "nvs.MinDataRateDs != evs.MinDataRateDs",
+ "nvs.MaxDataRateUs != evs.MaxDataRateUs", "nvs.MaxDataRateDs != evs.MaxDataRateDs":
+ if got := va.DeepEqualServicecfg(tt.args.evs, tt.args.nvs); got != tt.want {
+ t.Errorf("VoltApplication.DeepEqualServicecfg() = %v, want %v", got, tt.want)
+ }
+ }
+ })
+ }
+}