blob: 940704a9b3594bc4992f52657f1d4a442ceb0056 [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.
*/
/*
This file contains unit test cases for functions in the file openolt.go.
This file also implements the fields struct to mock the Openolt and few utility functions.
*/
//Package adaptercore provides the utility for olt devices, flows and statistics
package adaptercore
import (
"context"
"errors"
com "github.com/opencord/voltha-lib-go/v3/pkg/adapters/common"
fu "github.com/opencord/voltha-lib-go/v3/pkg/flows"
"github.com/opencord/voltha-lib-go/v3/pkg/kafka"
"github.com/opencord/voltha-lib-go/v3/pkg/log"
"github.com/opencord/voltha-openolt-adapter/config"
ic "github.com/opencord/voltha-protos/v3/go/inter_container"
"github.com/opencord/voltha-protos/v3/go/openflow_13"
ofp "github.com/opencord/voltha-protos/v3/go/openflow_13"
"github.com/opencord/voltha-protos/v3/go/voltha"
"reflect"
"sync"
"testing"
)
// mocks the OpenOLT struct.
type fields struct {
deviceHandlers map[string]*DeviceHandler
coreProxy *com.CoreProxy
adapterProxy *com.AdapterProxy
eventProxy *com.EventProxy
kafkaICProxy kafka.InterContainerProxy
numOnus int
KVStoreHost string
KVStorePort int
KVStoreType string
exitChannel chan int
lockDeviceHandlersMap sync.RWMutex
ctx context.Context
}
// mockOlt mocks OpenOLT struct.
func mockOlt() *fields {
dh := newMockDeviceHandler()
newOlt := &fields{}
newOlt.deviceHandlers = map[string]*DeviceHandler{}
newOlt.deviceHandlers[dh.device.Id] = dh
return newOlt
}
// testOltObject maps fields type to OpenOLt type.
func testOltObject(testOlt *fields) *OpenOLT {
return &OpenOLT{
deviceHandlers: testOlt.deviceHandlers,
coreProxy: testOlt.coreProxy,
adapterProxy: testOlt.adapterProxy,
eventProxy: testOlt.eventProxy,
kafkaICProxy: testOlt.kafkaICProxy,
numOnus: testOlt.numOnus,
KVStoreHost: testOlt.KVStoreHost,
KVStorePort: testOlt.KVStorePort,
KVStoreType: testOlt.KVStoreType,
exitChannel: testOlt.exitChannel,
}
}
// mockDevice mocks Device.
func mockDevice() *voltha.Device {
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,
}
return device
}
func TestNewOpenOLT(t *testing.T) {
tests := []struct {
name string
fields *fields
configFlags *config.AdapterFlags
want *OpenOLT
}{
{"newopenolt-1", &fields{}, &config.AdapterFlags{OnuNumber: 1, KVStorePort: 1, KVStoreType: "consul", KVStoreHost: "1.1.1.1"},
&OpenOLT{numOnus: 1, KVStorePort: 1, KVStoreType: "consul", KVStoreHost: "1.1.1.1"}},
{"newopenolt-2", &fields{}, &config.AdapterFlags{OnuNumber: 2, KVStorePort: 2, KVStoreType: "etcd", KVStoreHost: "2.2.2.2"},
&OpenOLT{numOnus: 2, KVStorePort: 2, KVStoreType: "etcd", KVStoreHost: "2.2.2.2"}},
{"newopenolt-3", &fields{}, &config.AdapterFlags{OnuNumber: 3, KVStorePort: 3, KVStoreType: "consul", KVStoreHost: "3.3.3.3"},
&OpenOLT{numOnus: 3, KVStorePort: 3, KVStoreType: "consul", KVStoreHost: "3.3.3.3"}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := NewOpenOLT(tt.fields.ctx, tt.fields.kafkaICProxy, tt.fields.coreProxy, tt.fields.adapterProxy,
tt.fields.eventProxy, tt.configFlags); reflect.TypeOf(got) != reflect.TypeOf(tt.want) && got != nil {
t.Errorf("NewOpenOLT() error = %v, wantErr %v", got, tt.want)
}
})
}
}
func TestOpenOLT_Abandon_device(t *testing.T) {
type args struct {
device *voltha.Device
}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"abandon_device-1", &fields{}, args{}, ErrNotImplemented},
{"abandon_device-2", &fields{}, args{}, ErrNotImplemented},
{"abandon_device-3", &fields{}, args{}, ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Abandon_device(tt.args.device); err != tt.wantErr {
t.Errorf("Abandon_device() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Activate_image_update(t *testing.T) {
type args struct {
device *voltha.Device
request *voltha.ImageDownload
}
tests := []struct {
name string
fields *fields
args args
want *voltha.ImageDownload
wantErr error
}{
{"activate_image_upate-1", &fields{}, args{}, &voltha.ImageDownload{Id: "Image1-ABC123XYZ"},
ErrNotImplemented},
{"activate_image_upate-2", &fields{}, args{}, &voltha.ImageDownload{Id: "Image2-ABC123CDE"},
ErrNotImplemented},
{"activate_image_upate-3", &fields{}, args{}, &voltha.ImageDownload{Id: "Image3-ABC123EFG"},
ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
got, err := oo.Activate_image_update(tt.args.device, tt.args.request)
if err != tt.wantErr && got == nil {
t.Errorf("Activate_image_update() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Adapter_descriptor(t *testing.T) {
tests := []struct {
name string
fields *fields
wantErr error
}{
{"adapter_descriptor-1", &fields{}, ErrNotImplemented},
{"adapter_descriptor-2", &fields{}, ErrNotImplemented},
{"adapter_descriptor-3", &fields{}, ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Adapter_descriptor(); err != tt.wantErr {
t.Errorf("Adapter_descriptor() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Adopt_device(t *testing.T) {
type args struct {
device *voltha.Device
}
var device = mockDevice()
device.Id = "olt"
nilDevice := NewErrInvalidValue(log.Fields{"device": nil}, nil)
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"adopt_device-1", mockOlt(), args{}, nilDevice},
{"adopt_device-2", mockOlt(), args{device}, nilDevice},
{"adopt_device-3", mockOlt(), args{mockDevice()}, nil},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
err := oo.Adopt_device(tt.args.device)
if (err != nil) && (reflect.TypeOf(err) !=
reflect.TypeOf(tt.wantErr)) && (tt.args.device == nil) {
t.Errorf("Adopt_device() error = %v, wantErr %v", err, tt.wantErr)
}
if err == nil {
t.Log("return'd nil")
}
})
}
}
func TestOpenOLT_Cancel_image_download(t *testing.T) {
type args struct {
device *voltha.Device
request *voltha.ImageDownload
}
tests := []struct {
name string
fields *fields
args args
want *voltha.ImageDownload
wantErr error
}{
{"cancel_image_download-1", &fields{}, args{}, &voltha.ImageDownload{Id: "Image1-ABC123XYZ"},
ErrNotImplemented},
{"cancel_image_download-2", &fields{}, args{}, &voltha.ImageDownload{Id: "Image2-ABC123IJK"},
ErrNotImplemented},
{"cancel_image_download-3", &fields{}, args{}, &voltha.ImageDownload{Id: "Image3-ABC123KLM"},
ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
got, err := oo.Cancel_image_download(tt.args.device, tt.args.request)
if err != tt.wantErr && got == nil {
t.Errorf("Cancel_image_download() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Delete_device(t *testing.T) {
type args struct {
device *voltha.Device
}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"delete_device-1", &fields{}, args{mockDevice()},
NewErrNotFound("device-handler", log.Fields{"device-id": "olt"}, nil)},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Delete_device(tt.args.device); !reflect.DeepEqual(err, tt.wantErr) {
t.Errorf("Delete_device() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Device_types(t *testing.T) {
tests := []struct {
name string
fields *fields
want *voltha.DeviceTypes
wantErr error
}{
{"device_types-1", &fields{}, &voltha.DeviceTypes{},
ErrNotImplemented},
{"device_types-2", &fields{}, &voltha.DeviceTypes{},
ErrNotImplemented},
{"device_types-3", &fields{}, &voltha.DeviceTypes{},
ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
got, err := oo.Device_types()
if err != tt.wantErr && got == nil {
t.Errorf("Device_types() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Disable_device(t *testing.T) {
type args struct {
device *voltha.Device
}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"disable_device-1", mockOlt(), args{mockDevice()}, nil},
{"disable_device-2", &fields{}, args{mockDevice()},
NewErrNotFound("device-handler", log.Fields{"device-id": "olt"}, nil)},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Disable_device(tt.args.device); !reflect.DeepEqual(err, tt.wantErr) {
t.Errorf("Disable_device() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Download_image(t *testing.T) {
type args struct {
device *voltha.Device
request *voltha.ImageDownload
}
tests := []struct {
name string
fields *fields
args args
want *voltha.ImageDownload
wantErr error
}{
{"download_image-1", &fields{}, args{}, &voltha.ImageDownload{Id: "Image1-ABC123XYZ"},
ErrNotImplemented},
{"download_image-2", &fields{}, args{}, &voltha.ImageDownload{Id: "Image2-ABC123LKJ"},
ErrNotImplemented},
{"download_image-3", &fields{}, args{}, &voltha.ImageDownload{Id: "Image1-ABC123RTY"},
ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
got, err := oo.Download_image(tt.args.device, tt.args.request)
if err != tt.wantErr && got == nil {
t.Errorf("Download_image() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Get_device_details(t *testing.T) {
type args struct {
device *voltha.Device
}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"get_device_details-1", &fields{}, args{}, ErrNotImplemented},
{"get_device_details-2", &fields{}, args{}, ErrNotImplemented},
{"get_device_details-3", &fields{}, args{}, ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Get_device_details(tt.args.device); err != tt.wantErr {
t.Errorf("Get_device_details() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Get_image_download_status(t *testing.T) {
type args struct {
device *voltha.Device
request *voltha.ImageDownload
}
tests := []struct {
name string
fields *fields
args args
want *voltha.ImageDownload
wantErr error
}{
{"get_image_download_status-1", &fields{}, args{}, &voltha.ImageDownload{Id: "Image1-ABC123XYZ"},
ErrNotImplemented},
{"get_image_download_status-2", &fields{}, args{}, &voltha.ImageDownload{Id: "Image2-ABC123LKJ"},
ErrNotImplemented},
{"get_image_download_status-3", &fields{}, args{}, &voltha.ImageDownload{Id: "Image1-ABC123DFG"},
ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
got, err := oo.Get_image_download_status(tt.args.device, tt.args.request)
if err != tt.wantErr && got == nil {
t.Errorf("Get_image_download_status() got = %v want = %v error = %v, wantErr %v",
got, tt.want, err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Get_ofp_device_info(t *testing.T) {
type args struct {
device *voltha.Device
}
tests := []struct {
name string
fields *fields
args args
want *ic.SwitchCapability
wantErr error
}{
{"get_ofp_device_info-1", mockOlt(), args{mockDevice()}, &ic.SwitchCapability{
Desc: &openflow_13.OfpDesc{
MfrDesc: "VOLTHA Project",
HwDesc: "open_pon",
SwDesc: "open_pon",
},
SwitchFeatures: &openflow_13.OfpSwitchFeatures{
NBuffers: uint32(256),
NTables: uint32(2),
Capabilities: uint32(15),
},
}, nil},
{"get_ofp_device_info-2", &fields{}, args{mockDevice()}, nil,
NewErrNotFound("device-handler", log.Fields{"device-id": "olt"}, nil)},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
got, err := oo.Get_ofp_device_info(tt.args.device)
if !reflect.DeepEqual(err, tt.wantErr) || !reflect.DeepEqual(got, tt.want) {
t.Errorf("Get_ofp_device_info() got = %v want = %v error = %v, wantErr = %v",
got, tt.want, err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Get_ofp_port_info(t *testing.T) {
type args struct {
device *voltha.Device
portNo int64
}
tests := []struct {
name string
fields *fields
args args
want *ic.PortCapability
wantErr error
}{
{"get_ofp_port_info-1", mockOlt(), args{mockDevice(), 1}, &ic.PortCapability{
Port: &voltha.LogicalPort{
DeviceId: "olt",
DevicePortNo: uint32(1),
OfpPort: &openflow_13.OfpPort{
HwAddr: []uint32{1, 2, 3, 4, 5, 6},
State: uint32(4),
Curr: uint32(4128),
Advertised: uint32(4128),
Peer: uint32(4128),
CurrSpeed: uint32(32),
MaxSpeed: uint32(32),
},
},
}, nil},
{"get_ofp_port_info-2", &fields{}, args{mockDevice(), 1}, nil,
NewErrNotFound("device-handler", log.Fields{"device-id": "olt"}, nil)},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
got, err := oo.Get_ofp_port_info(tt.args.device, tt.args.portNo)
if !reflect.DeepEqual(err, tt.wantErr) || !reflect.DeepEqual(got, tt.want) {
t.Errorf("Get_ofp_port_info() got = %v want = %v error = %v, wantErr = %v",
got, tt.want, err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Health(t *testing.T) {
tests := []struct {
name string
fields *fields
want *voltha.HealthStatus
wantErr error
}{
{"health-1", &fields{}, &voltha.HealthStatus{}, ErrNotImplemented},
{"health-2", &fields{}, &voltha.HealthStatus{}, ErrNotImplemented},
{"health-3", &fields{}, &voltha.HealthStatus{}, ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
got, err := oo.Health()
if err != tt.wantErr && got == nil {
t.Errorf("Get_ofp_port_info() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Process_inter_adapter_message(t *testing.T) {
type args struct {
msg *ic.InterAdapterMessage
}
var message1 = args{
msg: &ic.InterAdapterMessage{
Header: &ic.InterAdapterHeader{
Id: "olt",
ProxyDeviceId: "",
ToDeviceId: "onu1",
},
},
}
var message2 = args{
msg: &ic.InterAdapterMessage{
Header: &ic.InterAdapterHeader{
Id: "olt",
ProxyDeviceId: "olt",
ToDeviceId: "olt",
Type: ic.InterAdapterMessageType_OMCI_REQUEST,
},
},
}
var message3 = args{
msg: &ic.InterAdapterMessage{
Header: &ic.InterAdapterHeader{
Id: "olt",
ProxyDeviceId: "olt",
ToDeviceId: "olt",
Type: ic.InterAdapterMessageType_FLOW_REQUEST,
},
},
}
tests := []struct {
name string
fields *fields
args args
wantErrType reflect.Type
}{
{"process_inter_adaptor_messgae-1", mockOlt(), message1,
reflect.TypeOf(&ErrNotFound{})},
{"process_inter_adaptor_messgae-2", mockOlt(), message2,
reflect.TypeOf(errors.New("message is nil"))},
{"process_inter_adaptor_messgae-3", mockOlt(), message3,
reflect.TypeOf(&ErrInvalidValue{})},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Process_inter_adapter_message(tt.args.msg); reflect.TypeOf(err) != tt.wantErrType {
t.Errorf("Process_inter_adapter_message() error = %v, wantErr %v",
reflect.TypeOf(err), tt.wantErrType)
}
})
}
}
func TestOpenOLT_Reboot_device(t *testing.T) {
type args struct {
device *voltha.Device
}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"reboot_device-1", mockOlt(), args{mockDevice()}, nil},
{"reboot_device-2", &fields{}, args{mockDevice()},
NewErrNotFound("device-handler", log.Fields{"device-id": "olt"}, nil)},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Reboot_device(tt.args.device); !reflect.DeepEqual(err, tt.wantErr) {
t.Errorf("Reboot_device() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Receive_packet_out(t *testing.T) {
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),
}
type args struct {
deviceID string
egressPortNo int
packet *openflow_13.OfpPacketOut
}
pktout := &ofp.OfpPacketOut{BufferId: 0, InPort: 1, Actions: acts, Data: []byte("AYDCAAAOAODsSE5TiMwCBwQA4OxITlIEBQUwLzUx" +
"BgIAFAgEMC81MQoJbG9jYWxob3N0EBwFAawbqqACAAAAoRAxLjMuNi4xLjQuMS40NDEz/gYAgMILAgD+GQCAwgkDAAAAAGQAAAAAAAAAAgICAgICAgL+" +
"GQCAwgoDAAAAAGQAAAAAAAAAAgICAgICAgIAAA==")}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"receive_packet_out-1", mockOlt(), args{mockDevice().Id, 1, pktout}, nil},
{"receive_packet_out-2", mockOlt(), args{"1234", 1, pktout},
NewErrNotFound("device-handler", log.Fields{"device-id": "1234"}, nil)},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Receive_packet_out(tt.args.deviceID, tt.args.egressPortNo, tt.args.packet); !reflect.DeepEqual(err, tt.wantErr) {
t.Errorf("Receive_packet_out() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Reconcile_device(t *testing.T) {
type args struct {
device *voltha.Device
}
expectedError := NewErrInvalidValue(log.Fields{"device": nil}, nil)
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"reconcile_device-1", &fields{}, args{}, expectedError},
{"reconcile_device-2", &fields{}, args{}, expectedError},
{"reconcile_device-3", &fields{}, args{}, expectedError},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Reconcile_device(tt.args.device); !reflect.DeepEqual(err, tt.wantErr) {
t.Errorf("Reconcile_device() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Reenable_device(t *testing.T) {
type args struct {
device *voltha.Device
}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"reenable_device-1", mockOlt(), args{mockDevice()}, nil},
{"reenable_device-2", &fields{}, args{mockDevice()},
NewErrNotFound("device-handler", log.Fields{"device-id": "olt"}, nil)},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Reenable_device(tt.args.device); !reflect.DeepEqual(err, tt.wantErr) {
t.Errorf("Reenable_device() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Revert_image_update(t *testing.T) {
type args struct {
device *voltha.Device
request *voltha.ImageDownload
}
tests := []struct {
name string
fields *fields
args args
want *voltha.ImageDownload
wantErr error
}{
{"revert_image_update-1", &fields{}, args{}, &voltha.ImageDownload{Id: "Image1-ABC123XYZ"},
ErrNotImplemented},
{"revert_image_update-2", &fields{}, args{}, &voltha.ImageDownload{Id: "Image2-ABC123TYU"},
ErrNotImplemented},
{"revert_image_update-3", &fields{}, args{}, &voltha.ImageDownload{Id: "Image3-ABC123GTH"},
ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
got, err := oo.Revert_image_update(tt.args.device, tt.args.request)
if err != tt.wantErr && got == nil {
t.Log("error :", err)
}
})
}
}
func TestOpenOLT_Self_test_device(t *testing.T) {
type args struct {
device *voltha.Device
}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"self_test_device-1", &fields{}, args{}, ErrNotImplemented},
{"self_test_device-2", &fields{}, args{}, ErrNotImplemented},
{"self_test_device-3", &fields{}, args{}, ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Self_test_device(tt.args.device); err != tt.wantErr {
t.Errorf("Self_test_device() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Start(t *testing.T) {
type args struct {
ctx context.Context
}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"start-1", &fields{}, args{}, errors.New("start error")},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Start(tt.args.ctx); err != nil {
t.Errorf("Start() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Stop(t *testing.T) {
type args struct {
ctx context.Context
}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"stop-1", &fields{exitChannel: make(chan int, 1)}, args{}, errors.New("stop error")},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
oo.Start(tt.args.ctx)
if err := oo.Stop(tt.args.ctx); err != nil {
t.Errorf("Stop() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Suppress_event(t *testing.T) {
type args struct {
filter *voltha.EventFilter
}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"suppress_event-1", &fields{}, args{}, ErrNotImplemented},
{"suppress_event-2", &fields{}, args{}, ErrNotImplemented},
{"suppress_event-3", &fields{}, args{}, ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Suppress_event(tt.args.filter); err != tt.wantErr {
t.Errorf("Suppress_event() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Unsuppress_event(t *testing.T) {
type args struct {
filter *voltha.EventFilter
}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"unsupress_event-1", &fields{}, args{}, ErrNotImplemented},
{"unsupress_event-2", &fields{}, args{}, ErrNotImplemented},
{"unsupress_event-3", &fields{}, args{}, ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Unsuppress_event(tt.args.filter); err != tt.wantErr {
t.Errorf("Unsuppress_event() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Update_flows_bulk(t *testing.T) {
type args struct {
device *voltha.Device
flows *voltha.Flows
groups *voltha.FlowGroups
flowMetadata *voltha.FlowMetadata
}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"update_flows_bulk-1", &fields{}, args{}, ErrNotImplemented},
{"update_flows_bulk-2", &fields{}, args{}, ErrNotImplemented},
{"update_flows_bulk-3", &fields{}, args{}, ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Update_flows_bulk(tt.args.device, tt.args.flows, tt.args.groups, tt.args.flowMetadata); err != tt.wantErr {
t.Errorf("Update_flows_bulk() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Update_flows_incrementally(t *testing.T) {
type args struct {
device *voltha.Device
flows *openflow_13.FlowChanges
groups *openflow_13.FlowGroupChanges
flowMetadata *voltha.FlowMetadata
}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"update_flows_incrementally-1", &fields{}, args{device: mockDevice()},
NewErrNotFound("device-handler", log.Fields{"device-id": "olt"}, nil)},
{"update_flows_incrementally-2", mockOlt(), args{device: mockDevice()}, nil},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Update_flows_incrementally(tt.args.device, tt.args.flows, tt.args.groups, tt.args.flowMetadata); !reflect.DeepEqual(err, tt.wantErr) {
t.Errorf("Update_flows_incrementally() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Update_pm_config(t *testing.T) {
type args struct {
device *voltha.Device
pmConfigs *voltha.PmConfigs
}
tests := []struct {
name string
fields *fields
args args
wantErr error
}{
{"update_pm_config-1", &fields{}, args{}, ErrNotImplemented},
{"update_pm_config-2", &fields{}, args{}, ErrNotImplemented},
{"update_pm_config-3", &fields{}, args{}, ErrNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Update_pm_config(tt.args.device, tt.args.pmConfigs); err != tt.wantErr {
t.Errorf("Update_pm_config() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_deleteDeviceHandlerToMap(t *testing.T) {
type args struct {
agent *DeviceHandler
}
tests := []struct {
name string
fields *fields
args args
}{
{"delete_device_handler_map-1", mockOlt(), args{newMockDeviceHandler()}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
oo.deleteDeviceHandlerToMap(tt.args.agent)
if len(oo.deviceHandlers) > 0 {
t.Errorf("delete device manager failed")
}
})
}
}
func TestOpenOLT_Enable_port(t *testing.T) {
type args struct {
deviceID string
port *voltha.Port
}
tests := []struct {
name string
fields *fields
args args
wantErr bool
}{
// TODO: Add test cases.
{"Enable_port-1", mockOlt(), args{deviceID: "olt", port: &voltha.Port{Type: voltha.Port_PON_OLT, PortNo: 1}}, false},
{"Enable_port-2", mockOlt(), args{deviceID: "olt", port: &voltha.Port{Type: voltha.Port_ETHERNET_NNI, PortNo: 1}}, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Enable_port(tt.args.deviceID, tt.args.port); (err != nil) != tt.wantErr {
t.Errorf("OpenOLT.Enable_port() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}
func TestOpenOLT_Disable_port(t *testing.T) {
type args struct {
deviceID string
port *voltha.Port
}
tests := []struct {
name string
fields *fields
args args
wantErr bool
}{
// TODO: Add test cases.
{"Disable_port-1", mockOlt(), args{deviceID: "olt", port: &voltha.Port{Type: voltha.Port_PON_OLT, PortNo: 1}}, false},
{"Disable_port-2", mockOlt(), args{deviceID: "olt", port: &voltha.Port{Type: voltha.Port_ETHERNET_NNI, PortNo: 1}}, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
oo := testOltObject(tt.fields)
if err := oo.Disable_port(tt.args.deviceID, tt.args.port); (err != nil) != tt.wantErr {
t.Errorf("OpenOLT.Disable_port() error = %v, wantErr %v", err, tt.wantErr)
}
})
}
}