blob: 4311e80a0625624fda43570e9c5ad9738dc2b862 [file] [log] [blame]
/*
* Copyright 2018-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 devices
import (
"github.com/google/gopacket/layers"
"github.com/opencord/bbsim/internal/common"
omcilib "github.com/opencord/bbsim/internal/common/omci"
"github.com/stretchr/testify/assert"
"net"
"testing"
)
func createTestUni() *UniPort {
onu := &Onu{
ID: 0,
SerialNumber: NewSN(1, 1, 1),
PonPortID: 0,
}
services := []*Service{
{Name: "hsia", HwAddress: net.HardwareAddr{0x2e, 0x00}},
}
uni := UniPort{
ID: 1,
MeId: omcilib.GenerateUniPortEntityId(1),
PortNo: 16,
Onu: onu,
logger: uniLogger,
}
for _, s := range services {
uni.Services = append(uni.Services, s)
}
return &uni
}
func TestNewUniPortAtt(t *testing.T) {
const (
hsia = "hsia"
voip = "voip"
vod = "vod"
mc = "mc"
)
type args struct {
services []common.ServiceYaml
nextCtag map[string]int
nextStag map[string]int
}
type wants struct {
expectedCtags map[string]int
expectedStags map[string]int
}
tests := []struct {
name string
args args
wants wants
}{
{"newUniPort-att",
args{
services: []common.ServiceYaml{
{Name: hsia, CTag: 900, CTagAllocation: common.TagAllocationUnique.String(), STag: 900, STagAllocation: common.TagAllocationShared.String(), NeedsEapol: true, NeedsDhcp: true, NeedsIgmp: true},
},
nextCtag: map[string]int{hsia: 920},
nextStag: map[string]int{hsia: 900},
},
wants{
expectedCtags: map[string]int{hsia: 921},
expectedStags: map[string]int{hsia: 900},
},
},
{"newUniPort-dt",
args{
services: []common.ServiceYaml{
{Name: hsia, CTag: 900, CTagAllocation: common.TagAllocationShared.String(), STag: 900, STagAllocation: common.TagAllocationUnique.String(), UniTagMatch: 4096},
},
nextCtag: map[string]int{hsia: 920},
nextStag: map[string]int{hsia: 900},
},
wants{
expectedCtags: map[string]int{hsia: 920},
expectedStags: map[string]int{hsia: 901},
},
},
{"newUniPort-tt",
args{
services: []common.ServiceYaml{
{Name: hsia, CTag: 900, CTagAllocation: common.TagAllocationUnique.String(), STag: 900, STagAllocation: common.TagAllocationShared.String(), UniTagMatch: 35, TechnologyProfileID: 64},
{Name: voip, CTag: 444, CTagAllocation: common.TagAllocationShared.String(), STag: 333, STagAllocation: common.TagAllocationShared.String(), UniTagMatch: 65, TechnologyProfileID: 65, ConfigureMacAddress: true, UsPonCTagPriority: 7, UsPonSTagPriority: 7, DsPonCTagPriority: 7, DsPonSTagPriority: 7},
{Name: vod, CTag: 55, CTagAllocation: common.TagAllocationShared.String(), STag: 555, STagAllocation: common.TagAllocationShared.String(), UniTagMatch: 55, TechnologyProfileID: 66, NeedsDhcp: true, NeedsIgmp: true, ConfigureMacAddress: true, UsPonCTagPriority: 5, UsPonSTagPriority: 5, DsPonCTagPriority: 5, DsPonSTagPriority: 5},
},
nextCtag: map[string]int{hsia: 920},
nextStag: map[string]int{hsia: 900},
},
wants{
expectedCtags: map[string]int{hsia: 921, voip: 444, vod: 55},
expectedStags: map[string]int{hsia: 900, voip: 333, vod: 555},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
common.Services = tt.args.services
onu := &Onu{
ID: 0,
SerialNumber: NewSN(1, 1, 1),
}
uni, err := NewUniPort(1, onu, tt.args.nextCtag, tt.args.nextStag)
assert.NoError(t, err)
assert.Equal(t, uint32(1), uni.ID)
assert.Equal(t, uint16(258), uni.MeId.ToUint16())
assert.Equal(t, len(tt.args.services), len(uni.Services))
assert.Equal(t, len(tt.args.services), len(uni.Services))
for i, configuredService := range tt.args.services {
service := uni.Services[i].(*Service)
assert.Equal(t, tt.wants.expectedCtags[service.Name], service.CTag)
assert.Equal(t, tt.wants.expectedStags[service.Name], service.STag)
assert.Equal(t, configuredService.NeedsEapol, service.NeedsEapol)
assert.Equal(t, configuredService.NeedsDhcp, service.NeedsDhcp)
assert.Equal(t, configuredService.NeedsIgmp, service.NeedsIgmp)
assert.Equal(t, configuredService.UniTagMatch, service.UniTagMatch)
assert.Equal(t, configuredService.TechnologyProfileID, service.TechnologyProfileID)
assert.Equal(t, configuredService.ConfigureMacAddress, service.ConfigureMacAddress)
assert.Equal(t, configuredService.UsPonCTagPriority, service.UsPonCTagPriority)
assert.Equal(t, configuredService.DsPonCTagPriority, service.DsPonCTagPriority)
assert.Equal(t, configuredService.UsPonSTagPriority, service.UsPonSTagPriority)
assert.Equal(t, configuredService.DsPonSTagPriority, service.DsPonSTagPriority)
}
})
}
}
func Test_AddGemPortToService_eapol(t *testing.T) {
uni := createTestUni()
hsia := Service{Name: "hsia", NeedsEapol: true, CTag: 900, UniPort: uni}
voip := Service{Name: "voip", NeedsEapol: false, CTag: 55, UniPort: uni}
uni.Services = []ServiceIf{&hsia, &voip}
uni.addGemPortToService(1024, uint32(layers.EthernetTypeEAPOL), 0, 0)
assert.Equal(t, hsia.GemPort, uint32(1024))
assert.Equal(t, voip.GemPort, uint32(0))
}
func Test_AddGemPortToService_dhcp(t *testing.T) {
uni := createTestUni()
hsia := Service{Name: "hsia", NeedsEapol: true, UniPort: uni}
voip := Service{Name: "voip", NeedsDhcp: true, CTag: 900, UniPort: uni}
mc := Service{Name: "mc", CTag: 900, UniPort: uni}
uni.Services = []ServiceIf{&hsia, &voip, &mc}
uni.addGemPortToService(1025, uint32(layers.EthernetTypeIPv4), 900, 0)
assert.Equal(t, hsia.GemPort, uint32(0))
assert.Equal(t, voip.GemPort, uint32(1025))
assert.Equal(t, mc.GemPort, uint32(0))
}
func Test_AddGemPortToService_dataplane(t *testing.T) {
uni := createTestUni()
hsia := Service{Name: "hsia", NeedsEapol: true, CTag: 900, STag: 500, UniPort: uni}
voip := Service{Name: "voip", NeedsDhcp: true, CTag: 900, UniPort: uni}
uni.Services = []ServiceIf{&hsia, &voip}
uni.addGemPortToService(1024, uint32(layers.EthernetTypeLLC), 500, 900)
assert.Equal(t, hsia.GemPort, uint32(1024))
assert.Equal(t, voip.GemPort, uint32(0))
}
func Test_FindServiceByMacAddress(t *testing.T) {
mac := net.HardwareAddr{0x2e, 0x60, byte(1), byte(1), byte(1), byte(2)}
uni := createTestUni()
hsia := Service{Name: "hsia", HwAddress: net.HardwareAddr{0x2e, 0x60, byte(1), byte(1), byte(1), byte(1)}, UniPort: uni}
voip := Service{Name: "voip", HwAddress: mac, UniPort: uni}
vod := Service{Name: "vod", HwAddress: net.HardwareAddr{0x2e, 0x60, byte(1), byte(1), byte(1), byte(3)}, UniPort: uni}
uni.Services = []ServiceIf{&hsia, &voip, &vod}
service, err := uni.findServiceByMacAddress(mac)
assert.NoError(t, err)
assert.Equal(t, service.HwAddress.String(), mac.String())
}