blob: d6c65eac9fcac338e368cf84fe944fee942c98f5 [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 adaptercore provides the utility for olt devices, flows and statistics
package adaptercore
import (
"context"
"net"
"reflect"
"testing"
"github.com/golang/protobuf/ptypes"
"github.com/golang/protobuf/ptypes/any"
"github.com/opencord/voltha-go/common/log"
fu "github.com/opencord/voltha-go/rw_core/utils"
"github.com/opencord/voltha-openolt-adapter/adaptercore/resourcemanager"
"github.com/opencord/voltha-openolt-adapter/mocks"
ic "github.com/opencord/voltha-protos/go/inter_container"
of "github.com/opencord/voltha-protos/go/openflow_13"
ofp "github.com/opencord/voltha-protos/go/openflow_13"
oop "github.com/opencord/voltha-protos/go/openolt"
"github.com/opencord/voltha-protos/go/voltha"
)
func init() {
_, _ = log.AddPackage(log.JSON, log.DebugLevel, nil)
}
func newMockCoreProxy() *mocks.MockCoreProxy {
mcp := mocks.MockCoreProxy{}
mcp.Devices = make(map[string]*voltha.Device)
mcp.Devices["olt"] = &voltha.Device{
Id: "olt",
Root: true,
ParentId: "logical_device",
ParentPortNo: 1,
Ports: []*voltha.Port{
{PortNo: 1, Label: "pon"},
{PortNo: 2, Label: "nni"},
},
ProxyAddress: &voltha.Device_ProxyAddress{
DeviceId: "olt",
DeviceType: "onu",
ChannelId: 1,
ChannelGroupId: 1,
},
ConnectStatus: 1,
}
mcp.Devices["onu1"] = &voltha.Device{
Id: "1",
Root: false,
ParentId: "olt",
ParentPortNo: 1,
Ports: []*voltha.Port{
{PortNo: 1, Label: "pon"},
{PortNo: 2, Label: "uni"},
},
OperStatus: 4,
ProxyAddress: &voltha.Device_ProxyAddress{
OnuId: 1,
ChannelId: 1,
ChannelGroupId: 1,
},
ConnectStatus: 1,
}
mcp.Devices["onu2"] = &voltha.Device{
Id: "2",
Root: false,
ParentId: "olt",
OperStatus: 2,
Ports: []*voltha.Port{
{PortNo: 1, Label: "pon"},
{PortNo: 2, Label: "uni"},
},
ParentPortNo: 1,
ProxyAddress: &voltha.Device_ProxyAddress{
OnuId: 2,
ChannelId: 1,
ChannelGroupId: 1,
},
ConnectStatus: 1,
}
return &mcp
}
func newMockDeviceHandler() *DeviceHandler {
device := &voltha.Device{
Id: "olt",
Root: true,
ParentId: "logical_device",
Ports: []*voltha.Port{
{PortNo: 1, Label: "pon"},
{PortNo: 2, Label: "nni"},
},
ProxyAddress: &voltha.Device_ProxyAddress{
DeviceId: "olt",
DeviceType: "onu",
ChannelId: 1,
ChannelGroupId: 1,
},
ConnectStatus: 1,
}
cp := newMockCoreProxy()
ap := &mocks.MockAdapterProxy{}
ep := &mocks.MockEventProxy{}
openOLT := &OpenOLT{coreProxy: cp, adapterProxy: ap, eventProxy: ep}
dh := NewDeviceHandler(cp, ap, ep, device, openOLT)
deviceInf := &oop.DeviceInfo{Vendor: "openolt", Ranges: nil, Model: "openolt", DeviceId: dh.deviceID}
dh.resourceMgr = &resourcemanager.OpenOltResourceMgr{DeviceID: dh.deviceID, DeviceType: dh.deviceType, DevInfo: deviceInf}
dh.flowMgr = NewFlowManager(dh, dh.resourceMgr)
dh.Client = &mocks.MockOpenoltClient{}
dh.eventMgr = &OpenOltEventMgr{eventProxy: &mocks.MockEventProxy{}}
dh.transitionMap = &TransitionMap{}
return dh
}
func negativeDeviceHandler() *DeviceHandler {
dh := newMockDeviceHandler()
device := dh.device
device.Id = ""
dh.adminState = "down"
return dh
}
func Test_generateMacFromHost(t *testing.T) {
type args struct {
host string
}
tests := []struct {
name string
args args
want string
wantErr bool
}{
{"generateMacFromHost-1", args{host: "localhost"}, "00:00:7f:00:00:01", false},
{"generateMacFromHost-2", args{host: "10.10.10.10"}, "00:00:0a:0a:0a:0a", false},
//{"generateMacFromHost-3", args{host: "google.com"}, "00:00:d8:3a:c8:8e", false},
{"generateMacFromHost-4", args{host: "testing3"}, "", true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := generateMacFromHost(tt.args.host)
if (err != nil) != tt.wantErr {
t.Errorf("generateMacFromHost() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != tt.want {
t.Errorf("generateMacFromHost() = %v, want %v", got, tt.want)
}
})
}
}
func Test_macifyIP(t *testing.T) {
type args struct {
ip net.IP
}
tests := []struct {
name string
args args
want string
}{{
"macifyIP-1",
args{ip: net.ParseIP("10.10.10.10")},
"00:00:0a:0a:0a:0a",
},
{
"macifyIP-2",
args{ip: net.ParseIP("127.0.0.1")},
"00:00:7f:00:00:01",
},
{
"macifyIP-3",
args{ip: net.ParseIP("127.0.0.1/24")},
"",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := macifyIP(tt.args.ip); got != tt.want {
t.Errorf("macifyIP() = %v, want %v", got, tt.want)
}
})
}
}
func TestDeviceHandler_GetChildDevice(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := negativeDeviceHandler()
type args struct {
parentPort uint32
onuID uint32
}
tests := []struct {
name string
devicehandler *DeviceHandler
args args
want *voltha.Device
}{
{"GetChildDevice-1", dh1,
args{parentPort: 1,
onuID: 1},
&voltha.Device{},
},
{"GetChildDevice-2", dh2,
args{parentPort: 1,
onuID: 1},
&voltha.Device{},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := tt.devicehandler.GetChildDevice(tt.args.parentPort, tt.args.onuID)
t.Log("onu device id", got)
})
}
}
func TestGetportLabel(t *testing.T) {
type args struct {
portNum uint32
portType voltha.Port_PortType
}
tests := []struct {
name string
args args
want string
}{
{"GetportLabel-1", args{portNum: 0, portType: 0}, ""},
{"GetportLabel-2", args{portNum: 1, portType: 1}, "nni-1"},
{"GetportLabel-3", args{portNum: 2, portType: 2}, ""},
{"GetportLabel-4", args{portNum: 3, portType: 3}, "pon-3"},
{"GetportLabel-5", args{portNum: 4, portType: 4}, ""},
{"GetportLabel-6", args{portNum: 5, portType: 5}, ""},
{"GetportLabel-7", args{portNum: 6, portType: 6}, ""},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := GetportLabel(tt.args.portNum, tt.args.portType); got != tt.want {
t.Errorf("GetportLabel() = %v, want %v", got, tt.want)
}
})
}
}
func TestDeviceHandler_ProcessInterAdapterMessage(t *testing.T) {
dh := newMockDeviceHandler()
proxyAddr := dh.device.ProxyAddress
body := &ic.InterAdapterOmciMessage{
Message: []byte("asdfasdfasdfasdfas"),
ProxyAddress: proxyAddr,
}
body2 := &ic.InterAdapterOmciMessage{
Message: []byte("asdfasdfasdfasdfas"),
//ProxyAddress: &voltha.Device_ProxyAddress{},
}
body3 := &ic.InterAdapterTechProfileDownloadMessage{}
var marshalledData *any.Any
var err error
if marshalledData, err = ptypes.MarshalAny(body); err != nil {
log.Errorw("cannot-marshal-request", log.Fields{"error": err})
}
var marshalledData1 *any.Any
if marshalledData1, err = ptypes.MarshalAny(body2); err != nil {
log.Errorw("cannot-marshal-request", log.Fields{"error": err})
}
var marshalledData2 *any.Any
if marshalledData2, err = ptypes.MarshalAny(body3); err != nil {
log.Errorw("cannot-marshal-request", log.Fields{"error": err})
}
type args struct {
msg *ic.InterAdapterMessage
}
tests := []struct {
name string
args args
wantErr bool
}{
{"ProcessInterAdapterMessage-1", args{msg: &ic.InterAdapterMessage{
Header: &ic.InterAdapterHeader{
Id: "012345",
Type: 0,
},
Body: marshalledData,
}}, false},
{"ProcessInterAdapterMessage-2", args{msg: &ic.InterAdapterMessage{
Header: &ic.InterAdapterHeader{
Id: "012345",
Type: 1,
},
Body: marshalledData1,
}}, false},
{"ProcessInterAdapterMessage-3", args{msg: &ic.InterAdapterMessage{
Header: &ic.InterAdapterHeader{
Id: "012345",
Type: 2,
},
Body: marshalledData,
}}, false},
{"ProcessInterAdapterMessage-4", args{msg: &ic.InterAdapterMessage{
Header: &ic.InterAdapterHeader{
Id: "012345",
Type: 3,
}, Body: marshalledData,
}}, false},
{"ProcessInterAdapterMessage-5", args{msg: &ic.InterAdapterMessage{
Header: &ic.InterAdapterHeader{
Id: "012345",
Type: 4,
}, Body: marshalledData1,
}}, false},
{"ProcessInterAdapterMessage-6", args{msg: &ic.InterAdapterMessage{
Header: &ic.InterAdapterHeader{
Id: "012345",
Type: 4,
}, Body: marshalledData,
}}, false},
{"ProcessInterAdapterMessage-7", args{msg: &ic.InterAdapterMessage{
Header: &ic.InterAdapterHeader{
Id: "012345",
Type: 5,
}, Body: marshalledData,
}}, false},
{"ProcessInterAdapterMessage-8", args{msg: &ic.InterAdapterMessage{
Header: &ic.InterAdapterHeader{
Id: "012345",
Type: 6,
}, Body: marshalledData,
}}, false},
{"ProcessInterAdapterMessage-9", args{msg: &ic.InterAdapterMessage{
Header: &ic.InterAdapterHeader{
Id: "012345",
Type: 7,
}, Body: marshalledData,
}}, false},
{"ProcessInterAdapterMessage-10", args{msg: &ic.InterAdapterMessage{
Header: &ic.InterAdapterHeader{
Id: "012345",
Type: 7,
}, Body: marshalledData2,
}}, false},
//marshalledData2
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := dh.ProcessInterAdapterMessage(tt.args.msg); (err != nil) != tt.wantErr {
t.Errorf("DeviceHandler.ProcessInterAdapterMessage() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestDeviceHandler_sendProxiedMessage(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := negativeDeviceHandler()
device1 := &voltha.Device{
Id: "onu1",
Root: false,
ParentId: "logical_device",
ProxyAddress: &voltha.Device_ProxyAddress{
DeviceId: "onu1",
DeviceType: "onu",
ChannelId: 1,
ChannelGroupId: 1,
},
ConnectStatus: 1,
}
device2 := device1
device2.ConnectStatus = 2
iaomciMsg1 := &ic.InterAdapterOmciMessage{
ProxyAddress: &voltha.Device_ProxyAddress{
DeviceId: "onu2",
DeviceType: "onu",
ChannelId: 1,
ChannelGroupId: 1,
//OnuId: 2,
},
ConnectStatus: 1,
}
iaomciMsg2 := &ic.InterAdapterOmciMessage{
ProxyAddress: &voltha.Device_ProxyAddress{
DeviceId: "onu3",
DeviceType: "onu",
ChannelId: 1,
ChannelGroupId: 1,
},
ConnectStatus: 1,
}
type args struct {
onuDevice *voltha.Device
omciMsg *ic.InterAdapterOmciMessage
}
tests := []struct {
name string
devicehandler *DeviceHandler
args args
}{
{"sendProxiedMessage-1", dh1, args{onuDevice: device1, omciMsg: &ic.InterAdapterOmciMessage{}}},
{"sendProxiedMessage-2", dh1, args{onuDevice: device2, omciMsg: &ic.InterAdapterOmciMessage{}}},
{"sendProxiedMessage-3", dh1, args{onuDevice: nil, omciMsg: iaomciMsg1}},
{"sendProxiedMessage-4", dh1, args{onuDevice: nil, omciMsg: iaomciMsg2}},
{"sendProxiedMessage-5", dh2, args{onuDevice: nil, omciMsg: iaomciMsg2}},
{"sendProxiedMessage-6", dh2, args{onuDevice: device1, omciMsg: &ic.InterAdapterOmciMessage{}}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tt.devicehandler.sendProxiedMessage(tt.args.onuDevice, tt.args.omciMsg)
})
}
}
func TestDeviceHandler_SendPacketInToCore(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := negativeDeviceHandler()
type args struct {
logicalPort uint32
packetPayload []byte
}
tests := []struct {
name string
devicehandler *DeviceHandler
args args
}{
{"SendPacketInToCore-1", dh1, args{logicalPort: 1, packetPayload: []byte("test1")}},
{"SendPacketInToCore-2", dh1, args{logicalPort: 1, packetPayload: []byte("")}},
{"SendPacketInToCore-3", dh2, args{logicalPort: 1, packetPayload: []byte("test1")}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tt.devicehandler.SendPacketInToCore(tt.args.logicalPort, tt.args.packetPayload)
})
}
}
func TestDeviceHandler_DisableDevice(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := negativeDeviceHandler()
type args struct {
device *voltha.Device
}
tests := []struct {
name string
devicehandler *DeviceHandler
args args
wantErr bool
}{
{"DisableDevice-1", dh1, args{device: dh1.device}, false},
{"DisableDevice-2", dh1, args{device: dh1.device}, true},
{"DisableDevice-3", dh2, args{device: dh2.device}, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := tt.devicehandler.DisableDevice(tt.args.device); (err != nil) != tt.wantErr {
t.Errorf("DeviceHandler.DisableDevice() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestDeviceHandler_ReenableDevice(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := negativeDeviceHandler()
type args struct {
device *voltha.Device
}
tests := []struct {
name string
devicehandler *DeviceHandler
args args
wantErr bool
}{
{"ReenableDevice-1", dh1, args{device: dh1.device}, false},
{"ReenableDevice-2", dh1, args{device: &voltha.Device{}}, true},
{"ReenableDevice-3", dh2, args{device: dh1.device}, false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
dh := tt.devicehandler
if err := dh.ReenableDevice(tt.args.device); (err != nil) != tt.wantErr {
t.Errorf("DeviceHandler.ReenableDevice() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestDeviceHandler_RebootDevice(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := newMockDeviceHandler()
type args struct {
device *voltha.Device
}
tests := []struct {
name string
devicehandler *DeviceHandler
args args
wantErr bool
}{
// TODO: Add test cases.
{"RebootDevice-1", dh1, args{device: dh1.device}, false},
{"RebootDevice-2", dh1, args{device: dh2.device}, true},
{"RebootDevice-3", dh2, args{device: dh2.device}, false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := tt.devicehandler.RebootDevice(tt.args.device); (err != nil) != tt.wantErr {
t.Errorf("DeviceHandler.RebootDevice() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestDeviceHandler_handleIndication(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := negativeDeviceHandler()
dh3 := newMockDeviceHandler()
dh3.onus = map[string]*OnuDevice{"onu1": NewOnuDevice("onu1", "onu1", "onu1", 1, 1, "onu1"),
"onu2": NewOnuDevice("onu2", "onu2", "onu2", 2, 2, "onu2")}
type args struct {
indication *oop.Indication
}
tests := []struct {
name string
deviceHandler *DeviceHandler
args args
}{
// TODO: Add test cases.
{"handleIndication-1", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OltInd{OltInd: &oop.OltIndication{OperState: "up"}}}}},
{"handleIndication-2", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OltInd{OltInd: &oop.OltIndication{OperState: "down"}}}}},
{"handleIndication-3", dh1, args{indication: &oop.Indication{Data: &oop.Indication_IntfInd{IntfInd: &oop.IntfIndication{IntfId: 1, OperState: "up"}}}}},
{"handleIndication-4", dh1, args{indication: &oop.Indication{Data: &oop.Indication_IntfInd{IntfInd: &oop.IntfIndication{IntfId: 1, OperState: "down"}}}}},
{"handleIndication-5", dh1, args{indication: &oop.Indication{Data: &oop.Indication_IntfOperInd{IntfOperInd: &oop.IntfOperIndication{Type: "nni", IntfId: 1, OperState: "up"}}}}},
{"handleIndication-6", dh1, args{indication: &oop.Indication{Data: &oop.Indication_IntfOperInd{IntfOperInd: &oop.IntfOperIndication{Type: "pon", IntfId: 1, OperState: "up"}}}}},
{"handleIndication-7", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OnuDiscInd{OnuDiscInd: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}}}}},
{"handleIndication-8", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "up", AdminState: "up"}}}}},
{"handleIndication-9", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "up", AdminState: "down"}}}}},
{"handleIndication-10", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "down", AdminState: "up"}}}}},
{"handleIndication-11", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "down", AdminState: "down"}}}}},
{"handleIndication-12", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OmciInd{OmciInd: &oop.OmciIndication{IntfId: 1, OnuId: 1, Pkt: []byte("onu123-random value")}}}}},
{"handleIndication-13", dh1, args{indication: &oop.Indication{Data: &oop.Indication_PktInd{PktInd: &oop.PacketIndication{IntfType: "nni", IntfId: 1, GemportId: 1, FlowId: 1234, PortNo: 1}}}}},
{"handleIndication-14", dh1, args{indication: &oop.Indication{Data: &oop.Indication_PortStats{PortStats: &oop.PortStatistics{IntfId: 1, RxBytes: 100, RxPackets: 100, RxUcastPackets: 100, RxMcastPackets: 100, RxBcastPackets: 100, RxErrorPackets: 100, TxBytes: 100, TxPackets: 100, TxUcastPackets: 100, TxMcastPackets: 100, TxBcastPackets: 100, TxErrorPackets: 100, RxCrcErrors: 100, BipErrors: 100, Timestamp: 1000}}}}},
{"handleIndication-15", dh1, args{indication: &oop.Indication{Data: &oop.Indication_FlowStats{FlowStats: &oop.FlowStatistics{RxBytes: 100, RxPackets: 100, TxBytes: 100, TxPackets: 100, Timestamp: 1000}}}}},
{"handleIndication-16", dh1, args{indication: &oop.Indication{Data: &oop.Indication_AlarmInd{AlarmInd: &oop.AlarmIndication{}}}}},
{"handleIndication-17", dh1, args{indication: &oop.Indication{Data: &oop.Indication_PktInd{PktInd: &oop.PacketIndication{IntfType: "nni", FlowId: 1234, PortNo: 1}}}}},
{"handleIndication-18", dh1, args{indication: &oop.Indication{Data: &oop.Indication_PktInd{PktInd: &oop.PacketIndication{}}}}},
// Negative testcases
{"handleIndication-19", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OltInd{OltInd: &oop.OltIndication{OperState: "up"}}}}},
{"handleIndication-20", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OltInd{OltInd: &oop.OltIndication{OperState: "down"}}}}},
{"handleIndication-21", dh2, args{indication: &oop.Indication{Data: &oop.Indication_IntfInd{IntfInd: &oop.IntfIndication{IntfId: 1, OperState: "up"}}}}},
{"handleIndication-22", dh2, args{indication: &oop.Indication{Data: &oop.Indication_IntfInd{IntfInd: &oop.IntfIndication{IntfId: 1, OperState: "down"}}}}},
{"handleIndication-23", dh2, args{indication: &oop.Indication{Data: &oop.Indication_IntfOperInd{IntfOperInd: &oop.IntfOperIndication{Type: "nni", IntfId: 1, OperState: "up"}}}}},
{"handleIndication-24", dh2, args{indication: &oop.Indication{Data: &oop.Indication_IntfOperInd{IntfOperInd: &oop.IntfOperIndication{Type: "pon", IntfId: 1, OperState: "up"}}}}},
{"handleIndication-25", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OnuDiscInd{OnuDiscInd: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}}}}},
{"handleIndication-26", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "up", AdminState: "up"}}}}},
{"handleIndication-27", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "up", AdminState: "down"}}}}},
{"handleIndication-28", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "down", AdminState: "up"}}}}},
{"handleIndication-29", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "down", AdminState: "down"}}}}},
{"handleIndication-30", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OmciInd{OmciInd: &oop.OmciIndication{IntfId: 1, OnuId: 1, Pkt: []byte("onu123-random value")}}}}},
{"handleIndication-31", dh2, args{indication: &oop.Indication{Data: &oop.Indication_PktInd{PktInd: &oop.PacketIndication{IntfType: "nni", IntfId: 1, GemportId: 1, FlowId: 1234, PortNo: 1}}}}},
{"handleIndication-32", dh2, args{indication: &oop.Indication{Data: &oop.Indication_PortStats{PortStats: &oop.PortStatistics{IntfId: 1, RxBytes: 100, RxPackets: 100, RxUcastPackets: 100, RxMcastPackets: 100, RxBcastPackets: 100, RxErrorPackets: 100, TxBytes: 100, TxPackets: 100, TxUcastPackets: 100, TxMcastPackets: 100, TxBcastPackets: 100, TxErrorPackets: 100, RxCrcErrors: 100, BipErrors: 100, Timestamp: 1000}}}}},
{"handleIndication-33", dh2, args{indication: &oop.Indication{Data: &oop.Indication_FlowStats{FlowStats: &oop.FlowStatistics{RxBytes: 100, RxPackets: 100, TxBytes: 100, TxPackets: 100, Timestamp: 1000}}}}},
{"handleIndication-34", dh2, args{indication: &oop.Indication{Data: &oop.Indication_AlarmInd{AlarmInd: &oop.AlarmIndication{}}}}},
//
{"handleIndication-35", dh3, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "up", AdminState: "up"}}}}},
{"handleIndication-36", dh3, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "down", AdminState: "up"}}}}},
{"handleIndication-37", dh3, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "up", AdminState: "down"}}}}},
{"handleIndication-38", dh3, args{indication: &oop.Indication{Data: &oop.Indication_OnuInd{OnuInd: &oop.OnuIndication{IntfId: 1, OnuId: 1, OperState: "down", AdminState: "down"}}}}},
{"handleIndication-30", dh1, args{indication: &oop.Indication{Data: &oop.Indication_OmciInd{OmciInd: &oop.OmciIndication{IntfId: 1, OnuId: 4, Pkt: []byte("onu123-random value")}}}}},
{"handleIndication-30", dh2, args{indication: &oop.Indication{Data: &oop.Indication_OmciInd{OmciInd: &oop.OmciIndication{IntfId: 1, OnuId: 4, Pkt: []byte("onu123-random value")}}}}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
dh := tt.deviceHandler
dh.handleIndication(tt.args.indication)
})
}
}
func TestDeviceHandler_addPort(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := negativeDeviceHandler()
type args struct {
intfID uint32
portType voltha.Port_PortType
state string
}
tests := []struct {
name string
devicehandler *DeviceHandler
args args
}{
// State up
{"addPort.1", dh1, args{intfID: 1, portType: voltha.Port_UNKNOWN, state: "up"}},
{"addPort.2", dh1, args{intfID: 1, portType: voltha.Port_VENET_OLT, state: "up"}},
{"addPort.3", dh1, args{intfID: 1, portType: voltha.Port_VENET_ONU, state: "up"}},
{"addPort.4", dh1, args{intfID: 1, portType: voltha.Port_ETHERNET_NNI, state: "up"}},
{"addPort.5", dh1, args{intfID: 1, portType: voltha.Port_ETHERNET_UNI, state: "up"}},
{"addPort.6", dh1, args{intfID: 1, portType: voltha.Port_PON_OLT, state: "up"}},
{"addPort.7", dh1, args{intfID: 1, portType: voltha.Port_PON_ONU, state: "up"}},
{"addPort.8", dh1, args{intfID: 1, portType: 8, state: "up"}},
// state discovery
{"addPort.9", dh1, args{intfID: 1, portType: voltha.Port_UNKNOWN, state: "down"}},
{"addPort.10", dh1, args{intfID: 1, portType: voltha.Port_VENET_OLT, state: "down"}},
{"addPort.11", dh1, args{intfID: 1, portType: voltha.Port_VENET_ONU, state: "down"}},
{"addPort.12", dh1, args{intfID: 1, portType: voltha.Port_ETHERNET_NNI, state: "down"}},
{"addPort.13", dh1, args{intfID: 1, portType: voltha.Port_ETHERNET_UNI, state: "down"}},
{"addPort.14", dh1, args{intfID: 1, portType: voltha.Port_PON_OLT, state: "down"}},
{"addPort.15", dh1, args{intfID: 1, portType: voltha.Port_PON_ONU, state: "down"}},
{"addPort.16", dh1, args{intfID: 1, portType: 8, state: "down"}},
{"addPort.17", dh2, args{intfID: 1, portType: voltha.Port_ETHERNET_NNI, state: "up"}},
{"addPort.18", dh2, args{intfID: 1, portType: voltha.Port_ETHERNET_UNI, state: "up"}},
{"addPort.19", dh2, args{intfID: 1, portType: voltha.Port_ETHERNET_NNI, state: "down"}},
{"addPort.20", dh2, args{intfID: 1, portType: voltha.Port_ETHERNET_UNI, state: "down"}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tt.devicehandler.addPort(tt.args.intfID, tt.args.portType, tt.args.state)
})
}
}
func Test_macAddressToUint32Array(t *testing.T) {
type args struct {
mac string
}
tests := []struct {
name string
args args
want []uint32
}{
// TODO: Add test cases.
{"macAddressToUint32Array-1", args{mac: "00:00:00:00:00:01"}, []uint32{0, 0, 0, 0, 0, 1}},
{"macAddressToUint32Array-2", args{mac: "0abcdef"}, []uint32{11259375}},
{"macAddressToUint32Array-3", args{mac: "testing"}, []uint32{1, 2, 3, 4, 5, 6}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := macAddressToUint32Array(tt.args.mac); !reflect.DeepEqual(got, tt.want) {
t.Errorf("macAddressToUint32Array() = %v, want %v", got, tt.want)
}
})
}
}
func TestDeviceHandler_handleOltIndication(t *testing.T) {
type args struct {
oltIndication *oop.OltIndication
}
tests := []struct {
name string
args args
}{
{"handleOltIndication-1", args{oltIndication: &oop.OltIndication{OperState: "up"}}},
{"handleOltIndication-2", args{oltIndication: &oop.OltIndication{OperState: "down"}}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
dh := newMockDeviceHandler()
dh.handleOltIndication(tt.args.oltIndication)
})
}
}
func TestDeviceHandler_AdoptDevice(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := negativeDeviceHandler()
type args struct {
device *voltha.Device
}
tests := []struct {
name string
devicehandler *DeviceHandler
args args
}{
// TODO: Add test cases.
{"AdoptDevice-1", dh1, args{device: dh1.device}},
{"AdoptDevice-1", dh2, args{device: dh2.device}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
//dh.doStateInit()
// context.
//dh.AdoptDevice(tt.args.device)
tt.devicehandler.postInit()
})
}
}
func TestDeviceHandler_activateONU(t *testing.T) {
dh := newMockDeviceHandler()
dh1 := negativeDeviceHandler()
type args struct {
intfID uint32
onuID int64
serialNum *oop.SerialNumber
serialNumber string
}
tests := []struct {
name string
devicehandler *DeviceHandler
args args
}{
{"activateONU-1", dh, args{intfID: 1, onuID: 1, serialNum: &oop.SerialNumber{VendorId: []byte("onu1")}}},
{"activateONU-2", dh, args{intfID: 2, onuID: 2, serialNum: &oop.SerialNumber{VendorId: []byte("onu2")}}},
{"activateONU-3", dh1, args{intfID: 1, onuID: 1, serialNum: &oop.SerialNumber{VendorId: []byte("onu1")}}},
{"activateONU-4", dh1, args{intfID: 2, onuID: 2, serialNum: &oop.SerialNumber{VendorId: []byte("onu2")}}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tt.devicehandler.activateONU(tt.args.intfID, tt.args.onuID,
tt.args.serialNum, tt.args.serialNumber)
})
}
}
func TestDeviceHandler_start(t *testing.T) {
dh := newMockDeviceHandler()
dh1 := negativeDeviceHandler()
dh.start(context.Background())
dh.stop(context.Background())
dh1.start(context.Background())
dh1.stop(context.Background())
}
func TestDeviceHandler_PacketOut(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := negativeDeviceHandler()
acts := []*ofp.OfpAction{
fu.SetField(fu.Metadata_ofp(uint64(ofp.OfpInstructionType_OFPIT_WRITE_METADATA))),
fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101)),
fu.Output(1),
}
pktout := &ofp.OfpPacketOut{BufferId: 0, InPort: 1, Actions: acts, Data: []byte("AYDCAAAOAODsSE5TiMwCBwQA4OxITlIEBQUwLzUxBgIAFAgEMC81MQoJbG9jYWxob3N0EBwFAawbqqACAAAAoRAxLjMuNi4xLjQuMS40NDEz/gYAgMILAgD+GQCAwgkDAAAAAGQAAAAAAAAAAgICAgICAgL+GQCAwgoDAAAAAGQAAAAAAAAAAgICAgICAgIAAA==")}
type args struct {
egressPortNo int
packet *of.OfpPacketOut
}
tests := []struct {
name string
devicehandler *DeviceHandler
args args
wantErr bool
}{
// TODO: Add test cases.
//{"test1", args{egressPortNo: 0, packet: &ofp.OfpPacketOut{}}, true},
{"PacketOut-1", dh1, args{egressPortNo: 0, packet: pktout}, false},
{"PacketOut-2", dh2, args{egressPortNo: 1, packet: pktout}, false},
{"PacketOut-2", dh2, args{egressPortNo: 115000, packet: pktout}, false},
{"PacketOut-3", dh1, args{egressPortNo: 65536, packet: pktout}, false},
{"PacketOut-4", dh2, args{egressPortNo: 65535, packet: pktout}, false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
dh := tt.devicehandler
if err := dh.PacketOut(tt.args.egressPortNo, tt.args.packet); (err != nil) != tt.wantErr {
t.Errorf("DeviceHandler.PacketOut() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
//
func TestDeviceHandler_doStateUp(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := newMockDeviceHandler()
dh2.deviceID = ""
dh3 := negativeDeviceHandler()
tests := []struct {
name string
devicehandler *DeviceHandler
wantErr bool
}{
{"dostateup-1", dh1, false},
{"dostateup-2", dh2, false},
{"dostateup-3", dh3, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := tt.devicehandler.doStateUp(); (err != nil) != tt.wantErr {
t.Logf("DeviceHandler.doStateUp() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestDeviceHandler_doStateDown(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := negativeDeviceHandler()
dh3 := newMockDeviceHandler()
dh3.device.OperStatus = voltha.OperStatus_UNKNOWN
tests := []struct {
name string
devicehandler *DeviceHandler
wantErr bool
}{
{"dostatedown-1", dh1, false},
{"dostatedown-2", dh2, true},
{"dostatedown-2", dh3, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if err := tt.devicehandler.doStateDown(); (err != nil) != tt.wantErr {
t.Logf("DeviceHandler.doStateDown() error = %v", err)
}
})
}
}
func TestDeviceHandler_GetOfpDeviceInfo(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := negativeDeviceHandler()
type args struct {
device *voltha.Device
}
tests := []struct {
name string
devicehandler *DeviceHandler
args args
wantErr bool
}{
// TODO: Add test cases.
{"GetOfpDeviceInfo-1", dh1, args{dh1.device}, false},
{"GetOfpDeviceInfo-2", dh1, args{&voltha.Device{}}, false},
{"GetOfpDeviceInfo-3", dh2, args{dh1.device}, false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
dh := tt.devicehandler
_, err := dh.GetOfpDeviceInfo(tt.args.device)
if (err != nil) != tt.wantErr {
t.Errorf("DeviceHandler.GetOfpDeviceInfo() error = %v, wantErr %v", err, tt.wantErr)
return
}
})
}
}
func TestDeviceHandler_GetOfpPortInfo(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := negativeDeviceHandler()
type args struct {
device *voltha.Device
portNo int64
}
tests := []struct {
name string
devicehandler *DeviceHandler
args args
wantErr bool
}{
{"GetOfpPortInfo-1", dh1, args{device: dh1.device, portNo: 1}, false},
{"GetOfpPortInfo-2", dh2, args{device: dh2.device, portNo: 1}, false},
{"GetOfpPortInfo-3", dh1, args{device: dh1.device, portNo: 0}, false},
{"GetOfpPortInfo-4", dh2, args{device: dh2.device, portNo: 0}, false},
{"GetOfpPortInfo-5", dh1, args{device: &voltha.Device{}, portNo: 1}, false},
{"GetOfpPortInfo-6", dh2, args{device: &voltha.Device{}, portNo: 0}, false},
// TODO: Add test cases.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
dh := tt.devicehandler
_, err := dh.GetOfpPortInfo(tt.args.device, tt.args.portNo)
if (err != nil) != tt.wantErr {
t.Errorf("DeviceHandler.GetOfpPortInfo() error = %v, wantErr %v", err, tt.wantErr)
return
}
})
}
}
func TestDeviceHandler_onuDiscIndication(t *testing.T) {
dh1 := newMockDeviceHandler()
dh1.discOnus = map[string]bool{"onu1": true, "onu2": false}
dh2 := negativeDeviceHandler()
type args struct {
onuDiscInd *oop.OnuDiscIndication
sn string
}
tests := []struct {
name string
devicehandler *DeviceHandler
args args
}{
// TODO: Add test cases.
{"onuDiscIndication-1", dh1, args{onuDiscInd: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}}},
{"onuDiscIndication-2", dh1, args{onuDiscInd: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{}}}},
{"onuDiscIndication-3", dh1, args{onuDiscInd: &oop.OnuDiscIndication{SerialNumber: &oop.SerialNumber{}}}},
{"onuDiscIndication-4", dh1, args{onuDiscInd: &oop.OnuDiscIndication{}}},
{"onuDiscIndication-5", dh1, args{onuDiscInd: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}, sn: "onu1"}},
{"onuDiscIndication-6", dh1, args{onuDiscInd: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}, sn: "onu2"}},
{"onuDiscIndication-7", dh2, args{onuDiscInd: &oop.OnuDiscIndication{IntfId: 1, SerialNumber: &oop.SerialNumber{VendorId: []byte("TWSH"), VendorSpecific: []byte("1234")}}}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tt.devicehandler.onuDiscIndication(tt.args.onuDiscInd, tt.args.sn)
})
}
}
func TestDeviceHandler_populateDeviceInfo(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := negativeDeviceHandler()
tests := []struct {
name string
devicehandler *DeviceHandler
wantErr bool
}{
// TODO: Add test cases.
{"populateDeviceInfo-1", dh1, false},
{"populateDeviceInfo-2", dh1, true},
{"populateDeviceInfo-3", dh1, true},
{"populateDeviceInfo-4", dh1, true},
{"populateDeviceInfo-5", dh2, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
_, err := tt.devicehandler.populateDeviceInfo()
if (err != nil) != tt.wantErr {
t.Errorf("DeviceHandler.populateDeviceInfo() error = %v, wantErr %v", err, tt.wantErr)
return
}
})
}
}
func TestDeviceHandler_readIndications(t *testing.T) {
dh1 := newMockDeviceHandler()
dh2 := newMockDeviceHandler()
dh2.adminState = "down"
dh3 := newMockDeviceHandler()
dh3.device.AdminState = voltha.AdminState_DISABLED
dh4 := negativeDeviceHandler()
tests := []struct {
name string
devicehandler *DeviceHandler
}{
// TODO: Add test cases.
{"readIndications-1", dh1},
{"readIndications-2", dh2},
{"readIndications-3", dh2},
{"readIndications-4", dh2},
{"readIndications-5", dh2},
{"readIndications-6", dh3},
{"readIndications-7", dh3},
{"readIndications-8", dh4},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tt.devicehandler.readIndications()
})
}
}