From fac8fd6e25c5f230290b7f79744e32ad80c2cbe2 Mon Sep 17 00:00:00 2001 From: "doha.khaled" Date: Thu, 15 Nov 2018 08:14:30 +0200 Subject: [PATCH] initial olm unit testing commit Change-Id: I9cb9b69e7c215c899f31f5e49485482fe82a18ca JIRA: TRNSPRTPCE-59 --- olm/pom.xml | 13 +- .../olm/OlmPowerServiceRpcImpl.java | 1 + .../olm/service/OlmPowerServiceImpl.java | 2 +- .../olm/OlmPowerServiceRpcImplTest.java | 264 ++++++++++++ .../transportpce/olm/power/PowerMgmtTest.java | 224 +++++++++++ .../olm/service/OlmPowerServiceImplTest.java | 314 +++++++++++++++ .../olm/stub/MountPointServiceStub.java | 38 ++ .../transportpce/olm/stub/MountPointStub.java | 50 +++ .../transportpce/olm/stub/OlmServiceStub.java | 66 +++ .../olm/util/OlmPowerServiceRpcImplUtil.java | 136 +++++++ .../olm/util/TransactionUtils.java | 376 ++++++++++++++++++ .../org.mockito.plugins.MockMaker | 1 + 12 files changed, 1483 insertions(+), 2 deletions(-) create mode 100644 olm/src/test/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImplTest.java create mode 100644 olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtTest.java create mode 100644 olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplTest.java create mode 100644 olm/src/test/java/org/opendaylight/transportpce/olm/stub/MountPointServiceStub.java create mode 100644 olm/src/test/java/org/opendaylight/transportpce/olm/stub/MountPointStub.java create mode 100644 olm/src/test/java/org/opendaylight/transportpce/olm/stub/OlmServiceStub.java create mode 100644 olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmPowerServiceRpcImplUtil.java create mode 100644 olm/src/test/java/org/opendaylight/transportpce/olm/util/TransactionUtils.java create mode 100644 olm/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker diff --git a/olm/pom.xml b/olm/pom.xml index 61e622eec..1b6d8a003 100644 --- a/olm/pom.xml +++ b/olm/pom.xml @@ -52,6 +52,11 @@ and is available at http://www.eclipse.org/legal/epl-v10.html transportpce-renderer ${project.version} + + ${project.groupId} + transportpce-common + ${project.version} + org.opendaylight.controller.model model-topology @@ -67,12 +72,18 @@ and is available at http://www.eclipse.org/legal/epl-v10.html junit test - org.mockito mockito-core + 2.19.0 test + + org.opendaylight.transportpce + test-common + 0.2.1-SNAPSHOT + test + diff --git a/olm/src/main/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImpl.java b/olm/src/main/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImpl.java index 60b237b71..ff7d8eb9b 100644 --- a/olm/src/main/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImpl.java +++ b/olm/src/main/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImpl.java @@ -5,6 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ + package org.opendaylight.transportpce.olm; import com.google.common.util.concurrent.ListenableFuture; diff --git a/olm/src/main/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImpl.java b/olm/src/main/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImpl.java index c76401a8e..41adb8d3d 100644 --- a/olm/src/main/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImpl.java +++ b/olm/src/main/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImpl.java @@ -88,7 +88,7 @@ import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class OlmPowerServiceImpl implements OlmPowerService { +public class OlmPowerServiceImpl implements OlmPowerService { private static final Logger LOG = LoggerFactory.getLogger(OlmPowerServiceImpl.class); private static final String SUCCESS = "Success"; private static final String FAILED = "Failed"; diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImplTest.java b/olm/src/test/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImplTest.java new file mode 100644 index 000000000..bfda307de --- /dev/null +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/OlmPowerServiceRpcImplTest.java @@ -0,0 +1,264 @@ +/* + * Copyright © 2018 Orange, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.transportpce.olm; + +import com.google.common.util.concurrent.ListenableFuture; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.concurrent.ExecutionException; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.md.sal.binding.api.MountPoint; +import org.opendaylight.controller.md.sal.binding.api.MountPointService; +import org.opendaylight.transportpce.common.crossconnect.CrossConnect; +import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl; +import org.opendaylight.transportpce.common.device.DeviceTransactionManager; +import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; +import org.opendaylight.transportpce.common.mapping.PortMapping; +import org.opendaylight.transportpce.common.mapping.PortMappingImpl; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; +import org.opendaylight.transportpce.olm.power.PowerMgmt; +import org.opendaylight.transportpce.olm.service.OlmPowerService; +import org.opendaylight.transportpce.olm.service.OlmPowerServiceImpl; +import org.opendaylight.transportpce.olm.stub.MountPointServiceStub; +import org.opendaylight.transportpce.olm.stub.MountPointStub; +import org.opendaylight.transportpce.olm.util.OlmPowerServiceRpcImplUtil; +import org.opendaylight.transportpce.test.AbstractTest; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseOutputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossCurrentInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossCurrentOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerResetInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerResetOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupOutputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownOutputBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev161014.CurrentPmlist; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev161014.CurrentPmlistBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev161014.current.pm.LayerRateBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev161014.current.pm.Measurements; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev161014.current.pm.MeasurementsBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev161014.current.pm.measurements.MeasurementBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev161014.currentpmlist.CurrentPm; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev161014.currentpmlist.CurrentPmBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev161014.PmDataType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev161014.PmGranularity; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev161014.PmNamesEnum; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev161014.pm.measurement.PmParameterNameBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.DeviceBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.ResourceTypeBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.resource.resource.CircuitPackBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev161014.ResourceTypeEnum; +import org.opendaylight.yangtools.yang.common.RpcResult; + +public class OlmPowerServiceRpcImplTest extends AbstractTest { + + private MountPoint mountPoint; + private MountPointService mountPointService; + private DeviceTransactionManager deviceTransactionManager; + private CrossConnect crossConnect; + private OpenRoadmInterfaces openRoadmInterfaces; + private PortMapping portMapping; + private PowerMgmt powerMgmt; + private OlmPowerService olmPowerService; + private OlmPowerServiceRpcImpl olmPowerServiceRpc; + + + @Before + public void setUp() { + this.mountPoint = new MountPointStub(this.getDataBroker()); + this.mountPointService = new MountPointServiceStub(mountPoint); + this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000); + this.crossConnect = new CrossConnectImpl(this.deviceTransactionManager); + this.openRoadmInterfaces = new OpenRoadmInterfacesImpl((this.deviceTransactionManager)); + this.portMapping = new PortMappingImpl(this.getDataBroker(), this.deviceTransactionManager, + this.openRoadmInterfaces); + this.powerMgmt = new PowerMgmt(this.getDataBroker(), this.openRoadmInterfaces, this.crossConnect, + this.deviceTransactionManager); + this.olmPowerService = new OlmPowerServiceImpl(this.getDataBroker(), this.powerMgmt, + this.deviceTransactionManager, this.portMapping); + this.olmPowerServiceRpc = new OlmPowerServiceRpcImpl(this.olmPowerService); + } + + @Test + public void pmIsNotPresentTest() throws ExecutionException, InterruptedException { + GetPmInput input = OlmPowerServiceRpcImplUtil.getGetPmInput(); + ListenableFuture> output = this.olmPowerServiceRpc.getPm(input); + Assert.assertEquals(new GetPmOutputBuilder().build(), output.get().getResult()); + Assert.assertEquals(null, output.get().getResult().getResourceId()); + Assert.assertEquals(null, output.get().getResult().getMeasurements()); + Assert.assertEquals(null, output.get().getResult().getGranularity()); + Assert.assertEquals(null, output.get().getResult().getNodeId()); + Assert.assertEquals(null, output.get().getResult().getResourceIdentifier()); + Assert.assertEquals(null, output.get().getResult().getResourceType()); + } + + @Test + public void testGetPm1() throws ExecutionException, InterruptedException { + Measurements measurements = new MeasurementsBuilder().setMeasurement( + new MeasurementBuilder() + .setPmParameterUnit("unit") + .setPmParameterName(new PmParameterNameBuilder() + .setExtension("123") + .setType(PmNamesEnum.DefectSeconds).build()) + .setPmParameterValue(new PmDataType(BigInteger.valueOf(1234))).build()) + .build(); + List measurementsList = new ArrayList(); + measurementsList.add(measurements); + + org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.Resource resource = + new org.opendaylight.yang.gen.v1.http.org.openroadm.resource.rev161014.resource.ResourceBuilder() + .setResource(new CircuitPackBuilder().setCircuitPackName("circuit pack name").build()).build(); + + org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev161014.current.pm.Resource resource2 = + new org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev161014.current.pm.ResourceBuilder() + .setDevice(new DeviceBuilder().setNodeId("node 1").build()) + .setResourceType(new ResourceTypeBuilder() + .setExtension("123") + .setType(ResourceTypeEnum.Device).build()) + .setResource(resource).build(); + CurrentPm currentPm = new CurrentPmBuilder() + .setGranularity(PmGranularity._15min) + .setId("id") + .setLayerRate(new LayerRateBuilder().build()) + .setMeasurements(measurementsList) + .setResource(resource2) + .setRetrievalTime(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715 + .DateAndTime("2018-11-01T12:00:31.456449+06:00")).build(); + + List currentPmList = new ArrayList<>(); + currentPmList.add(currentPm); + + Optional currentPmlistOptional = Optional.of(new CurrentPmlistBuilder() + .setCurrentPm(currentPmList).build()); + + org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.get.pm.output.Measurements + measurements1 = new org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.get.pm + .output.MeasurementsBuilder().setPmparameterName("name").setPmparameterValue("1234").build(); + + + List measurementsList1 = new ArrayList<>(); + measurementsList1.add(measurements1); + + GetPmInput input = OlmPowerServiceRpcImplUtil.getGetPmInput(); + GetPmOutputBuilder pmOutputBuilder = new GetPmOutputBuilder().setNodeId(input.getNodeId()) + .setResourceType(input.getResourceType()) + .setResourceIdentifier(input.getResourceIdentifier()) + .setGranularity(input.getGranularity()) + .setMeasurements(measurementsList1); + + + ListenableFuture> output = this.olmPowerServiceRpc.getPm(input); + Assert.assertEquals(new GetPmOutputBuilder().build(), output.get().getResult()); + Assert.assertEquals(null, output.get().getResult().getResourceId()); + } + +// @Test +// public void testGetPm2() throws ExecutionException, InterruptedException { +// this.olmPowerService = Mockito.spy(this.olmPowerService); +// GetPmInput input = new GetPmInputBuilder().setGranularity(PmGranularity._15min).setNodeId("node1") +// .setResourceIdentifier(new ResourceIdentifierBuilder().setCircuitPackName("circuit pack name") +// .setResourceName("resource name").build()).setResourceType(ResourceTypeEnum.Device).build(); +// org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.olm.rev170418.get.pm.output.Measurements +// measurements1 = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.olm.rev170418.get.pm +// .output.MeasurementsBuilder().setPmparameterName("name").setPmparameterValue("1234").build(); +// +// +// List measurementsList1 = new ArrayList<>(); +// measurementsList1.add(measurements1); +// +// GetPmOutputBuilder pmOutputBuilder = new GetPmOutputBuilder().setNodeId(input.getNodeId()) +// .setResourceType(input.getResourceType()) +// .setResourceIdentifier(input.getResourceIdentifier()) +// .setGranularity(input.getGranularity()) +// .setMeasurements(measurementsList1); +// +// Mockito.doReturn(pmOutputBuilder.build()).when(this.olmPowerService).getPm(Mockito.any()); +// ListenableFuture> output = this.olmPowerServiceRpc.getPm(input); +// Assert.assertEquals(pmOutputBuilder.build(), output.get().getResult()); +// Assert.assertEquals(true, output.get().isSuccessful()); +// } + + @Test + public void testGetPm3() throws ExecutionException, InterruptedException { + GetPmInput input = OlmPowerServiceRpcImplUtil.getGetPmInput(); + ListenableFuture> output = this.olmPowerServiceRpc.getPm(input); + Assert.assertEquals(new GetPmOutputBuilder().build(), output.get().getResult()); + Assert.assertEquals(null, output.get().getResult().getResourceId()); + Assert.assertEquals(null, output.get().getResult().getMeasurements()); + Assert.assertEquals(null, output.get().getResult().getGranularity()); + Assert.assertEquals(null, output.get().getResult().getNodeId()); + Assert.assertEquals(null, output.get().getResult().getResourceIdentifier()); + Assert.assertEquals(null, output.get().getResult().getResourceType()); + } + + @Test + public void testServicePowerSetup1() throws ExecutionException, InterruptedException { + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput(); + ListenableFuture> output = this.olmPowerServiceRpc.servicePowerSetup(input); + Assert.assertEquals(new ServicePowerSetupOutputBuilder().setResult("Success").build(), output.get() + .getResult()); + Assert.assertEquals("Success", output.get().getResult().getResult()); + Assert.assertEquals(true, output.get().isSuccessful()); + } + + + @Test + public void testServicePowerTurndown1() throws ExecutionException, InterruptedException { + ServicePowerTurndownInput input = OlmPowerServiceRpcImplUtil.getServicePowerTurndownInput(); + ListenableFuture> output = this.olmPowerServiceRpc + .servicePowerTurndown(input); + Assert.assertEquals(new ServicePowerTurndownOutputBuilder().setResult("Success").build(), output.get() + .getResult()); + Assert.assertEquals("Success", output.get().getResult().getResult()); + Assert.assertEquals(true, output.get().isSuccessful()); + } + + @Test + public void testCalculateSpanlossBase1() throws ExecutionException, InterruptedException { + CalculateSpanlossBaseInput input = OlmPowerServiceRpcImplUtil.getCalculateSpanlossBaseInput(); + ListenableFuture> output = this.olmPowerServiceRpc + .calculateSpanlossBase(input); + Assert.assertEquals(new CalculateSpanlossBaseOutputBuilder().setResult("Failed").build(), + output.get().getResult()); + Assert.assertEquals("Failed", output.get().getResult().getResult()); + Assert.assertEquals(true, output.get().isSuccessful()); + } + + @Test + public void testCalculateSpanlossCurrent1() throws ExecutionException, InterruptedException { + CalculateSpanlossCurrentInput input = OlmPowerServiceRpcImplUtil.getCalculateSpanlossCurrentInput(); + ListenableFuture> output = this.olmPowerServiceRpc + .calculateSpanlossCurrent(input); + Assert.assertEquals(null, output.get().getResult()); + Assert.assertEquals(true, output.get().isSuccessful()); + } + + @Test + public void testServicePowerResetInput() throws ExecutionException, InterruptedException { + ServicePowerResetInput input = OlmPowerServiceRpcImplUtil.getServicePowerResetInput(); + ListenableFuture> output = this.olmPowerServiceRpc + .servicePowerReset(input); + Assert.assertEquals(null, output.get().getResult()); + Assert.assertEquals(true, output.get().isSuccessful()); + } +} diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtTest.java b/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtTest.java new file mode 100644 index 000000000..8c57f8608 --- /dev/null +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/power/PowerMgmtTest.java @@ -0,0 +1,224 @@ +/* + * Copyright © 2018 Orange, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.transportpce.olm.power; + +import java.util.List; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.controller.md.sal.binding.api.MountPoint; +import org.opendaylight.controller.md.sal.binding.api.MountPointService; +import org.opendaylight.transportpce.common.crossconnect.CrossConnect; +import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl; +import org.opendaylight.transportpce.common.device.DeviceTransactionManager; +import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; +import org.opendaylight.transportpce.common.mapping.PortMapping; +import org.opendaylight.transportpce.common.mapping.PortMappingImpl; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; +import org.opendaylight.transportpce.olm.stub.MountPointServiceStub; +import org.opendaylight.transportpce.olm.stub.MountPointStub; +import org.opendaylight.transportpce.olm.util.OlmPowerServiceRpcImplUtil; +import org.opendaylight.transportpce.olm.util.TransactionUtils; +import org.opendaylight.transportpce.test.AbstractTest; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupInput; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NodeId; + +public class PowerMgmtTest extends AbstractTest { + + private MountPoint mountPoint; + private MountPointService mountPointService; + private DeviceTransactionManager deviceTransactionManager; + private CrossConnect crossConnect; + private OpenRoadmInterfaces openRoadmInterfaces; + private PortMapping portMapping; + private PowerMgmt powerMgmt; + + @Before + public void setUp() { + this.mountPoint = new MountPointStub(this.getDataBroker()); + this.mountPointService = new MountPointServiceStub(mountPoint); + this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000); + this.crossConnect = new CrossConnectImpl(this.deviceTransactionManager); + this.openRoadmInterfaces = new OpenRoadmInterfacesImpl((this.deviceTransactionManager)); + this.portMapping = new PortMappingImpl(this.getDataBroker(), this.deviceTransactionManager, + this.openRoadmInterfaces); + this.powerMgmt = new PowerMgmt(this.getDataBroker(), this.openRoadmInterfaces, this.crossConnect, + this.deviceTransactionManager); + } + + @Test + public void testSetPower() { + + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(true, output); + + } + + @Test + public void testSetPower2() { + + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput2(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(true, output); + + } + + @Test + public void testSetPower3() { + + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput3(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(true, output); + + } + + @Test + public void testSetPower4() { + + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput4(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(true, output); + + } + + @Test + public void testSetPowerPresentNodes() throws InterruptedException { + List nodes = TransactionUtils.getNodeIds(); + for (NodeId nodeId : nodes) { + TransactionUtils.writeNodeTransaction(nodeId.getValue(), this.getDataBroker(), null); + Thread.sleep(500); + } + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(true, output); + } + + @Test + public void testSetPowerPresentNodes2() throws InterruptedException { + List nodes = TransactionUtils.getNodeIds(); + for (NodeId nodeId : nodes) { + TransactionUtils.writeNodeTransaction2(nodeId.getValue(), this.getDataBroker(), null); + Thread.sleep(500); + } + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(true, output); + } + + @Test + public void testSetPowerPresentNodes3() throws InterruptedException { + List nodes = TransactionUtils.getNodeIds(); + for (NodeId nodeId : nodes) { + TransactionUtils.writeNodeTransaction3(nodeId.getValue(), this.getDataBroker(), null); + Thread.sleep(500); + } + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(true, output); + } + + @Test + public void testSetPowerPresentNodes31() throws InterruptedException { + List nodes = TransactionUtils.getNodeIds(); + for (NodeId nodeId : nodes) { + TransactionUtils.writeNodeTransaction3(nodeId.getValue(), this.getDataBroker(), "deg"); + Thread.sleep(500); + } + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput3(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(false, output); + } + + @Test + public void testSetPowerPresentNodes312() throws InterruptedException { + List nodes = TransactionUtils.getNodeIds(); + for (NodeId nodeId : nodes) { + TransactionUtils.writeNodeTransaction3(nodeId.getValue(), this.getDataBroker(), "deg"); + Thread.sleep(500); + } + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput4(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(true, output); + } + + @Test + public void testSetPowerPresentNodes32() throws InterruptedException { + List nodes = TransactionUtils.getNodeIds(); + for (NodeId nodeId : nodes) { + TransactionUtils.writeNodeTransaction3(nodeId.getValue(), this.getDataBroker(), null); + Thread.sleep(500); + } + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput3(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(true, output); + } + + @Test + public void testSetPowerPresentNodes4() throws InterruptedException { + List nodes = TransactionUtils.getNodeIds(); + for (NodeId nodeId : nodes) { + TransactionUtils.writeNodeTransaction(nodeId.getValue(), this.getDataBroker(), "network"); + Thread.sleep(500); + } + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput2(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(true, output); + } + + @Test + public void testSetPowerPresentNodes41() throws InterruptedException { + List nodes = TransactionUtils.getNodeIds(); + for (NodeId nodeId : nodes) { + TransactionUtils.writeNodeTransaction(nodeId.getValue(), this.getDataBroker(), null); + Thread.sleep(500); + } + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput2(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(false, output); + } + + @Test + public void testSetPowerPresentNodes42() throws InterruptedException { + List nodes = TransactionUtils.getNodeIds(); + for (NodeId nodeId : nodes) { + TransactionUtils.writeNodeTransaction(nodeId.getValue(), this.getDataBroker(), "deg"); + Thread.sleep(500); + } + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput3(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(true, output); + } + + @Test + public void testSetPowerPresentNodes422() throws InterruptedException { + List nodes = TransactionUtils.getNodeIds(); + for (NodeId nodeId : nodes) { + TransactionUtils.writeNodeTransaction(nodeId.getValue(), this.getDataBroker(), "deg"); + Thread.sleep(500); + } + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput4(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(true, output); + } + + @Test + public void testSetPowerPresentNodes43() throws InterruptedException { + List nodes = TransactionUtils.getNodeIds(); + for (NodeId nodeId : nodes) { + TransactionUtils.writeNodeTransaction(nodeId.getValue(), this.getDataBroker(), null); + Thread.sleep(500); + } + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput3(); + boolean output = this.powerMgmt.setPower(input); + Assert.assertEquals(true, output); + } + +} diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplTest.java b/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplTest.java new file mode 100644 index 000000000..6ec03219c --- /dev/null +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplTest.java @@ -0,0 +1,314 @@ +/* + * Copyright © 2018 Orange, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.transportpce.olm.service; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.opendaylight.controller.md.sal.binding.api.MountPoint; +import org.opendaylight.controller.md.sal.binding.api.MountPointService; +import org.opendaylight.transportpce.common.NetworkUtils; +import org.opendaylight.transportpce.common.crossconnect.CrossConnect; +import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl; +import org.opendaylight.transportpce.common.device.DeviceTransactionManager; +import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl; +import org.opendaylight.transportpce.common.mapping.PortMapping; +import org.opendaylight.transportpce.common.mapping.PortMappingImpl; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; +import org.opendaylight.transportpce.olm.power.PowerMgmt; +import org.opendaylight.transportpce.olm.stub.MountPointServiceStub; +import org.opendaylight.transportpce.olm.stub.MountPointStub; +import org.opendaylight.transportpce.olm.util.OlmPowerServiceRpcImplUtil; +import org.opendaylight.transportpce.olm.util.TransactionUtils; +import org.opendaylight.transportpce.test.AbstractTest; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossCurrentInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossCurrentOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerResetInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerResetOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupOutputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownOutputBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkId; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Network1; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class OlmPowerServiceImplTest extends AbstractTest { + + private static final Logger LOG = LoggerFactory.getLogger(OlmPowerServiceImplTest.class); + private MountPoint mountPoint; + private MountPointService mountPointService; + private DeviceTransactionManager deviceTransactionManager; + private CrossConnect crossConnect; + private OpenRoadmInterfaces openRoadmInterfaces; + private PortMapping portMapping; + private PowerMgmt powerMgmt; + private OlmPowerService olmPowerService; + private PowerMgmt powerMgmtMock; + @InjectMocks + private OlmPowerService olmPowerServiceMock; + + + + @Before + public void setUp() { + this.mountPoint = new MountPointStub(this.getDataBroker()); + this.mountPointService = new MountPointServiceStub(mountPoint); + this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000); + this.crossConnect = new CrossConnectImpl(this.deviceTransactionManager); + this.openRoadmInterfaces = new OpenRoadmInterfacesImpl((this.deviceTransactionManager)); + this.portMapping = new PortMappingImpl(this.getDataBroker(), this.deviceTransactionManager, + this.openRoadmInterfaces); + this.powerMgmt = new PowerMgmt(this.getDataBroker(), this.openRoadmInterfaces, this.crossConnect, + this.deviceTransactionManager); + this.olmPowerService = new OlmPowerServiceImpl(this.getDataBroker(), this.powerMgmt, + this.deviceTransactionManager, this.portMapping); + this.powerMgmtMock = Mockito.mock(PowerMgmt.class); + this.olmPowerServiceMock = new OlmPowerServiceImpl(this.getDataBroker(), this.powerMgmtMock, + this.deviceTransactionManager, this.portMapping); + MockitoAnnotations.initMocks(this); + } + + @Test + public void dummyTest() { + OlmPowerServiceImpl olmPowerServiceImpl = (OlmPowerServiceImpl) this.olmPowerService; + olmPowerServiceImpl.init(); + olmPowerServiceImpl.close(); + } + + + @Test + public void testGetPm() { + GetPmInput input = OlmPowerServiceRpcImplUtil.getGetPmInput(); + GetPmOutput output = this.olmPowerService.getPm(input); + Assert.assertEquals(new GetPmOutputBuilder().build(), output); + Assert.assertEquals(null, output.getResourceId()); + } + + @Test + public void testServicePowerSetupSuccess() { + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput(); + Mockito.when(this.powerMgmtMock.setPower(Mockito.any())).thenReturn(true); + ServicePowerSetupOutput output = this.olmPowerServiceMock.servicePowerSetup(input); + Assert.assertEquals(new ServicePowerSetupOutputBuilder().setResult("Success").build(), output); + Assert.assertEquals("Success", output.getResult()); + } + + @Test + public void testServicePowerSetupFailed() { + ServicePowerSetupInput input = OlmPowerServiceRpcImplUtil.getServicePowerSetupInput(); + Mockito.when(this.powerMgmtMock.setPower(Mockito.any())).thenReturn(false); + ServicePowerSetupOutput output = this.olmPowerServiceMock.servicePowerSetup(input); + Assert.assertEquals("Failed", output.getResult()); + } + + @Test + public void testServicePowerTurnDownSuccess() { + ServicePowerTurndownInput input = OlmPowerServiceRpcImplUtil.getServicePowerTurndownInput(); + Mockito.when(this.powerMgmtMock.powerTurnDown(Mockito.any())).thenReturn(true); + ServicePowerTurndownOutput output = this.olmPowerServiceMock.servicePowerTurndown(input); + Assert.assertEquals(new ServicePowerTurndownOutputBuilder().setResult("Success").build(), output); + Assert.assertEquals("Success", output.getResult()); + } + + @Test + public void testServicePowerTurnDownFailed() { + ServicePowerTurndownInput input = OlmPowerServiceRpcImplUtil.getServicePowerTurndownInput(); + Mockito.when(this.powerMgmtMock.powerTurnDown(Mockito.any())).thenReturn(false); + ServicePowerTurndownOutput output = this.olmPowerServiceMock.servicePowerTurndown(input); + Assert.assertEquals(new ServicePowerTurndownOutputBuilder().setResult("Failed").build(), output); + Assert.assertEquals("Failed", output.getResult()); + } + + @Test + public void testCalculateSpanlossBase() { + CalculateSpanlossBaseInput input = OlmPowerServiceRpcImplUtil.getCalculateSpanlossBaseInput(); + CalculateSpanlossBaseOutput output = this.olmPowerService.calculateSpanlossBase(input); + Assert.assertEquals("Failed", output.getResult()); + + } + + @Test + public void testCalculateSpanlossBase2() { + NetworkKey overlayTopologyKey = new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)); + InstanceIdentifier networkIID = InstanceIdentifier.builder(Network.class, overlayTopologyKey) + .augmentation(Network1.class) + .build(); + Network1 network = TransactionUtils.getNetwork(); + TransactionUtils.writeTransaction(this.getDataBroker(), networkIID, network); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + LOG.error("Write transaction failed !",e); + } + CalculateSpanlossBaseInput input = OlmPowerServiceRpcImplUtil.getCalculateSpanlossBaseInput(); + CalculateSpanlossBaseOutput output = this.olmPowerService.calculateSpanlossBase(input); + Assert.assertEquals("Failed", output.getResult()); + + } + + @Test + public void testCalculateSpanlossBase3() { + NetworkKey overlayTopologyKey = new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)); + InstanceIdentifier networkIID = InstanceIdentifier.builder(Network.class, overlayTopologyKey) + .augmentation(Network1.class) + .build(); + Network1 network = TransactionUtils.getNetwork(); + TransactionUtils.writeTransaction(this.getDataBroker(), networkIID, network); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + LOG.error("Write transaction failed !",e); + } + CalculateSpanlossBaseInput input = OlmPowerServiceRpcImplUtil.getCalculateSpanlossBaseInput2(); + CalculateSpanlossBaseOutput output = this.olmPowerService.calculateSpanlossBase(input); + Assert.assertEquals("Failed", output.getResult()); + + } + + + @Test + public void testCalculateSpanlossBase4() { + NetworkKey overlayTopologyKey = new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)); + InstanceIdentifier networkIID = InstanceIdentifier.builder(Network.class, overlayTopologyKey) + .augmentation(Network1.class) + .build(); + Network1 network = TransactionUtils.getEmptyNetwork(); + TransactionUtils.writeTransaction(this.getDataBroker(), networkIID, network); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + LOG.error("Write transaction failed !",e); + } + CalculateSpanlossBaseInput input = OlmPowerServiceRpcImplUtil.getCalculateSpanlossBaseInput2(); + CalculateSpanlossBaseOutput output = this.olmPowerService.calculateSpanlossBase(input); + Assert.assertEquals("Failed", output.getResult()); + + } + + @Test + public void testCalculateSpanlossBase5() { + NetworkKey overlayTopologyKey = new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)); + InstanceIdentifier networkIID = InstanceIdentifier.builder(Network.class, overlayTopologyKey) + .augmentation(Network1.class) + .build(); + Network1 network = TransactionUtils.getNullNetwork(); + TransactionUtils.writeTransaction(this.getDataBroker(), networkIID, network); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + LOG.error("Write transaction failed !",e); + } + CalculateSpanlossBaseInput input = OlmPowerServiceRpcImplUtil.getCalculateSpanlossBaseInput2(); + CalculateSpanlossBaseOutput output = this.olmPowerService.calculateSpanlossBase(input); + Assert.assertEquals("Failed", output.getResult()); + + } + +// @Test +// public void testCalculateSpanlossBase4() throws InterruptedException { +// NetworkKey overlayTopologyKey = new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)); +// InstanceIdentifier networkIID = InstanceIdentifier.builder(Network.class, overlayTopologyKey) +// .augmentation(Network1.class) +// .build(); +// Network1 network = TransactionUtils.getNetwork2(); +// TransactionUtils.writeTransaction(this.getDataBroker(), networkIID, network); +// +// Thread.sleep(500); +// +// List nodes = TransactionUtils.getNodes(); +// Node n; +// SupportingNode sn; +// +// List snl; +// NodeId n5 = new NodeId("node 5"); +// KeyedInstanceIdentifier mappedNodeII2 = +// InstanceIdentifiers.UNDERLAY_NETWORK_II.child(Node.class, new NodeKey(n5)); +// +// sn = new SupportingNodeBuilder().setNetworkRef(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID)) +// .setNodeRef(n5).build(); +// snl = new ArrayList<>(); +// snl.add(sn); +// n = new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608 +// .network.NodeBuilder().setNodeId(n5).build(); +// TransactionUtils.writeTransaction(this.getDataBroker(), mappedNodeII2, n); +// Thread.sleep(500); +// +// for(int i=0; i < nodes.size(); i++) { +// KeyedInstanceIdentifier mappedNodeII = +// InstanceIdentifiers.OVERLAY_NETWORK_II.child(Node.class, new NodeKey(nodes.get(i))); +// if (i != 0){ +// sn = new SupportingNodeBuilder().setNetworkRef(new NetworkId(NetworkUtils.UNDERLAY_NETWORK_ID)) +// .setNodeRef(nodes.get(i-1)).build(); +// }else { +// sn = new SupportingNodeBuilder().setNodeRef(n5).build(); +// } +// snl = new ArrayList<>(); +// snl.add(sn); +// n = new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608 +// .network.NodeBuilder().setNodeId(nodes.get(i)).setSupportingNode(snl).build(); +// TransactionUtils.writeTransaction(this.getDataBroker(), mappedNodeII, n); +// Thread.sleep(500); +// } +// +// Thread.sleep(1000); +// +// CalculateSpanlossBaseInput input = OlmPowerServiceRpcImplUtil.getCalculateSpanlossBaseInput2(); +// CalculateSpanlossBaseOutput output = this.olmPowerService.calculateSpanlossBase(input); +// Assert.assertEquals("Failed", output.getResult()); +// +// } + + @Test + public void testCalculateSpanlossCurrent1() { + CalculateSpanlossCurrentInput input = OlmPowerServiceRpcImplUtil.getCalculateSpanlossCurrentInput(); + CalculateSpanlossCurrentOutput output = this.olmPowerService.calculateSpanlossCurrent(input); + Assert.assertEquals(null, output); + } + + @Test + public void testCalculateSpanlossCurrent2() { + NetworkKey overlayTopologyKey = new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)); + InstanceIdentifier networkIID = InstanceIdentifier.builder(Network.class, overlayTopologyKey) + .augmentation(Network1.class) + .build(); + Network1 network = TransactionUtils.getNetwork(); + TransactionUtils.writeTransaction(this.getDataBroker(), networkIID, network); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + LOG.error("Write transaction failed !",e); + } + CalculateSpanlossCurrentInput input = OlmPowerServiceRpcImplUtil.getCalculateSpanlossCurrentInput(); + CalculateSpanlossCurrentOutput output = this.olmPowerService.calculateSpanlossCurrent(input); + Assert.assertEquals(null, output); + } + + @Test + public void testServicePowerReset() { + ServicePowerResetInput input = OlmPowerServiceRpcImplUtil.getServicePowerResetInput(); + ServicePowerResetOutput output = this.olmPowerService.servicePowerReset(input); + Assert.assertEquals(null, output); + } +} diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/stub/MountPointServiceStub.java b/olm/src/test/java/org/opendaylight/transportpce/olm/stub/MountPointServiceStub.java new file mode 100644 index 000000000..011e4265d --- /dev/null +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/stub/MountPointServiceStub.java @@ -0,0 +1,38 @@ +/* + * Copyright © 2018 Orange Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.transportpce.olm.stub; + +import com.google.common.base.Optional; +import org.opendaylight.controller.md.sal.binding.api.MountPoint; +import org.opendaylight.controller.md.sal.binding.api.MountPointService; +import org.opendaylight.yangtools.concepts.ListenerRegistration; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MountPointServiceStub implements MountPointService { + + MountPoint returnedMountPoint; + + public MountPointServiceStub(MountPoint usedMountPoint) { + this.returnedMountPoint = usedMountPoint; + } + + @Override + public Optional getMountPoint(InstanceIdentifier mountPoint) { + if (returnedMountPoint == null) { + return Optional.absent(); + } + return Optional.of(returnedMountPoint); + } + + @Override + public ListenerRegistration registerListener(InstanceIdentifier path, + T listener) { + return null; + } +} diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/stub/MountPointStub.java b/olm/src/test/java/org/opendaylight/transportpce/olm/stub/MountPointStub.java new file mode 100644 index 000000000..82d1f14df --- /dev/null +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/stub/MountPointStub.java @@ -0,0 +1,50 @@ +/* + * Copyright © 2018 Orange Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.transportpce.olm.stub; + +import com.google.common.base.Optional; +import javax.annotation.Nonnull; +import org.opendaylight.controller.md.sal.binding.api.BindingService; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.MountPoint; +import org.opendaylight.controller.sal.binding.api.RpcConsumerRegistry; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MountPointStub implements MountPoint { + + private DataBroker dataBroker; + + private RpcConsumerRegistry rpcConsumerRegistry; + + public MountPointStub(DataBroker dataBroker) { + + this.dataBroker = dataBroker; + } + + public void setRpcConsumerRegistry(RpcConsumerRegistry rpcConsumerRegistry) { + this.rpcConsumerRegistry = rpcConsumerRegistry; + } + + @Override + public Optional getService(Class service) { + if (service.isInstance(dataBroker)) { + return Optional.fromNullable((T)dataBroker); + } + if (service.isInstance(rpcConsumerRegistry)) { + return Optional.fromNullable((T)rpcConsumerRegistry); + } + return Optional.absent(); + } + + @Nonnull + @Override + public InstanceIdentifier getIdentifier() { + return null; + } +} diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/stub/OlmServiceStub.java b/olm/src/test/java/org/opendaylight/transportpce/olm/stub/OlmServiceStub.java new file mode 100644 index 000000000..96803ef06 --- /dev/null +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/stub/OlmServiceStub.java @@ -0,0 +1,66 @@ +/* + * Copyright © 2018 Orange Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.transportpce.olm.stub; + +import com.google.common.util.concurrent.ListenableFuture; +import java.util.ArrayList; + +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossCurrentInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossCurrentOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmOutputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerResetInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerResetOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupOutputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownOutputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.TransportpceOlmService; +import org.opendaylight.yangtools.yang.common.RpcResult; +import org.opendaylight.yangtools.yang.common.RpcResultBuilder; + +public class OlmServiceStub implements TransportpceOlmService { + + @Override public ListenableFuture> calculateSpanlossCurrent( + CalculateSpanlossCurrentInput input) { + return null; + } + + @Override public ListenableFuture> getPm(GetPmInput input) { + GetPmOutput output = new GetPmOutputBuilder() + .setNodeId("node1").setMeasurements(new ArrayList<>()).build(); + return RpcResultBuilder.success( + output).buildFuture(); + } + + @Override public ListenableFuture> servicePowerTurndown( + ServicePowerTurndownInput input) { + return RpcResultBuilder.success((new ServicePowerTurndownOutputBuilder()) + .setResult("Success").build()).buildFuture(); + } + + @Override public ListenableFuture> calculateSpanlossBase( + CalculateSpanlossBaseInput input) { + return null; + } + + @Override public ListenableFuture> servicePowerReset( + ServicePowerResetInput input) { + return null; + } + + @Override public ListenableFuture> servicePowerSetup( + ServicePowerSetupInput input) { + return RpcResultBuilder.success(new ServicePowerSetupOutputBuilder().build()).buildFuture(); + } +} diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmPowerServiceRpcImplUtil.java b/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmPowerServiceRpcImplUtil.java new file mode 100644 index 000000000..fcb236dc1 --- /dev/null +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmPowerServiceRpcImplUtil.java @@ -0,0 +1,136 @@ +/* + * Copyright © 2018 Orange, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.transportpce.olm.util; + +import java.util.ArrayList; +import java.util.List; + +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossBaseInputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossCurrentInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.CalculateSpanlossCurrentInputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.GetPmInputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerResetInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerResetInputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerSetupInputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownInput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.ServicePowerTurndownInputBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Link1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Link1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev161014.PmGranularity; +import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev161014.ResourceTypeEnum; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev170907.olm.get.pm.input.ResourceIdentifierBuilder; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev170907.olm.renderer.input.Nodes; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev170907.olm.renderer.input.NodesBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.LinkId; + +public final class OlmPowerServiceRpcImplUtil { + + private OlmPowerServiceRpcImplUtil() {} + + public static GetPmInput getGetPmInput() { + GetPmInput input = new GetPmInputBuilder().setGranularity(PmGranularity._15min).setNodeId("node1") + .setResourceIdentifier(new ResourceIdentifierBuilder().setCircuitPackName("circuit pack name") + .setResourceName("resource name").build()).setResourceType(ResourceTypeEnum.Device).build(); + return input; + } + + public static ServicePowerSetupInput getServicePowerSetupInput() { + Nodes node1 = new NodesBuilder().setDestTp("dest").setSrcTp("src").setNodeId("node 1").build(); + Nodes node2 = new NodesBuilder().setDestTp("dest").setSrcTp("src").setNodeId("node 2").build(); + List nodes = new ArrayList<>(); + nodes.add(node1); + nodes.add(node2); + ServicePowerSetupInput input = new ServicePowerSetupInputBuilder().setNodes(nodes) + .setServiceName("service 1") + .setWaveNumber(Long.valueOf("1234")).build(); + return input; + } + + public static ServicePowerSetupInput getServicePowerSetupInput2() { + Nodes node1 = new NodesBuilder().setDestTp("network").setSrcTp("src").setNodeId("node 1").build(); + Nodes node2 = new NodesBuilder().setDestTp("network").setSrcTp("src").setNodeId("node 2").build(); + List nodes = new ArrayList<>(); + nodes.add(node1); + nodes.add(node2); + ServicePowerSetupInput input = new ServicePowerSetupInputBuilder().setNodes(nodes) + .setServiceName("service 1") + .setWaveNumber(Long.valueOf("1234")).build(); + return input; + } + + public static ServicePowerSetupInput getServicePowerSetupInput3() { + Nodes node1 = new NodesBuilder().setDestTp("deg").setSrcTp("src").setNodeId("node 1").build(); + Nodes node2 = new NodesBuilder().setDestTp("deg").setSrcTp("src").setNodeId("node 2").build(); + List nodes = new ArrayList<>(); + nodes.add(node1); + nodes.add(node2); + ServicePowerSetupInput input = new ServicePowerSetupInputBuilder().setNodes(nodes) + .setServiceName("service 1") + .setWaveNumber(Long.valueOf("1234")).build(); + return input; + } + + public static ServicePowerSetupInput getServicePowerSetupInput4() { + Nodes node1 = new NodesBuilder().setDestTp("srg").setSrcTp("src").setNodeId("node 1").build(); + Nodes node2 = new NodesBuilder().setDestTp("srg").setSrcTp("src").setNodeId("node 2").build(); + List nodes = new ArrayList<>(); + nodes.add(node1); + nodes.add(node2); + ServicePowerSetupInput input = new ServicePowerSetupInputBuilder().setNodes(nodes) + .setServiceName("service 1") + .setWaveNumber(Long.valueOf("1234")).build(); + return input; + } + + public static ServicePowerTurndownInput getServicePowerTurndownInput() { + Nodes node1 = new NodesBuilder().setDestTp("dest").setSrcTp("src").setNodeId("node 1").build(); + Nodes node2 = new NodesBuilder().setDestTp("dest").setSrcTp("src").setNodeId("node 2").build(); + List nodes = new ArrayList<>(); + nodes.add(node1); + nodes.add(node2); + ServicePowerTurndownInput input = new ServicePowerTurndownInputBuilder() + .setNodes(nodes) + .setServiceName("service 1") + .setWaveNumber(Long.valueOf("1234")).build(); + + return input; + } + + public static CalculateSpanlossBaseInput getCalculateSpanlossBaseInput() { + CalculateSpanlossBaseInput input = new CalculateSpanlossBaseInputBuilder() + .setLinkId(new LinkId("link 1")) + .setSrcType(CalculateSpanlossBaseInput.SrcType.Link) + .addAugmentation(null, null).build(); + return input; + } + + public static CalculateSpanlossBaseInput getCalculateSpanlossBaseInput2() { + Link1 link1 = new Link1Builder().build(); + CalculateSpanlossBaseInput input = new CalculateSpanlossBaseInputBuilder() + .setLinkId(new LinkId("link 1")) + .setSrcType(CalculateSpanlossBaseInput.SrcType.All).build(); + return input; + } + + public static CalculateSpanlossCurrentInput getCalculateSpanlossCurrentInput() { + CalculateSpanlossCurrentInput input = new CalculateSpanlossCurrentInputBuilder() + .addAugmentation(null, null).build(); + return input; + } + + public static ServicePowerResetInput getServicePowerResetInput() { + ServicePowerResetInput input = new ServicePowerResetInputBuilder() + .setServiceName("service 1").build(); + return input; + } + +} diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/util/TransactionUtils.java b/olm/src/test/java/org/opendaylight/transportpce/olm/util/TransactionUtils.java new file mode 100644 index 000000000..4ae7f820b --- /dev/null +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/util/TransactionUtils.java @@ -0,0 +1,376 @@ +/* + * Copyright © 2018 Orange Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.transportpce.olm.util; + +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.Network; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.Nodes; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.NodesBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.NodesKey; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.CpToDegree; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.CpToDegreeBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.Mapping; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.MappingBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev170228.network.nodes.MappingKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.NodeTypes; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev170929.FiberPmd; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev170929.RatioDB; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev170929.State; +import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev170929.amplified.link.attributes.amplified.link.SectionElementBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev170929.span.attributes.LinkConcatenation; +import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev170929.span.attributes.LinkConcatenationBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Link1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.Link1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.link.OMSAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.link.oms.attributes.AmplifiedLinkBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev170929.network.link.oms.attributes.SpanBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev170929.OpenroadmLinkType; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NetworkId; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev150608.NodeId; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.LinkId; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Network1; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.Network1Builder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.Link; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.LinkBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.link.DestinationBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.link.SourceBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.link.SupportingLink; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev150608.network.link.SupportingLinkBuilder; +import org.opendaylight.yangtools.yang.binding.Augmentation; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public final class TransactionUtils { + + private TransactionUtils() { + + } + + public static boolean writeTransaction(DataBroker dataBroker, InstanceIdentifier instanceIdentifier, + DataObject object) { + ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction(); + transaction.put(LogicalDatastoreType.CONFIGURATION, instanceIdentifier, object, true); + transaction.commit();// submit(Timeouts.DATASTORE_WRITE, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT).get(); + return true; + } + +// +// public static boolean writeTransaction(DataBroker dataBroker, LogicalDatastoreType logicalDatastoreType, +// InstanceIdentifier instanceIdentifier, +// DataObject object) + +// public static DataObject readTransaction(DeviceTransactionManager deviceTransactionManager, +// String nodeId, +// LogicalDatastoreType logicalDatastoreType, +// InstanceIdentifier instanceIdentifier) +// throws ExecutionException, InterruptedException { +// Future> deviceTxFuture = +// deviceTransactionManager.getDeviceTransaction(nodeId); +// if (!deviceTxFuture.get().isPresent()) { +// return null; +// } +// DeviceTransaction deviceTx = deviceTxFuture.get().get(); +// com.google.common.base.Optional readOpt +// = deviceTx.read(logicalDatastoreType, instanceIdentifier).get(); +// if (!readOpt.isPresent()) { +// return null; +// } +// return readOpt.get(); +// } + + public static Network1 getNullNetwork() { + Network1 network = new Network1Builder().setLink(null).build(); + Optional.of(network); + return network; + } + + public static Network1 getEmptyNetwork() { + Network1 network = new Network1Builder().setLink(new ArrayList<>()).build(); + Optional.of(network); + return network; + } + + public static Network1 getNetwork() { + List supportingLinks = new ArrayList<>(); + SupportingLink supportingLink1 = new SupportingLinkBuilder().setLinkRef("ref1") + .setNetworkRef(new NetworkId("net1")).build(); + SupportingLink supportingLink2 = new SupportingLinkBuilder().setLinkRef("ref2") + .setNetworkRef(new NetworkId("net2")).build(); + supportingLinks.add(supportingLink1); + supportingLinks.add(supportingLink2); + List links = new ArrayList<>(); + Link link1 = new LinkBuilder().setLinkId(new LinkId("link 1")) + .setDestination(new DestinationBuilder().setDestNode(new NodeId("node 1")) + .setDestTp("dest tp").build()) + .setSource(new SourceBuilder().setSourceNode(new NodeId("node 2")) + .setSourceTp("src tp").build()) + .setSupportingLink(supportingLinks).build(); + + Link link2 = new LinkBuilder().setLinkId(new LinkId("link 2")) + .setDestination(new DestinationBuilder().setDestNode(new NodeId("node 3")) + .setDestTp("dest tp").build()) + .setSource(new SourceBuilder().setSourceNode(new NodeId("node 4")) + .setSourceTp("src tp").build()) + .setSupportingLink(supportingLinks).build(); + links.add(link1); + links.add(link2); + Network1 network = new Network1Builder().setLink(links).build(); + Optional.of(network); + return network; + } + + public static Network1 getNetwork2() { + List linkConcentationValues = new ArrayList<>(); + LinkConcatenation linkConcatenation = new LinkConcatenationBuilder() + .setFiberType(LinkConcatenation.FiberType.Truewave) + .setPmd(new FiberPmd(BigDecimal.ONE)) + .setSRLGId(Long.valueOf(1)) + .setSRLGLength(Long.valueOf(1)) + .build(); + LinkConcatenation linkConcatenation2 = new LinkConcatenationBuilder() + .setFiberType(LinkConcatenation.FiberType.Truewave) + .setPmd(new FiberPmd(BigDecimal.ONE)) + .setSRLGId(Long.valueOf(1)) + .setSRLGLength(Long.valueOf(1)) + .build(); + linkConcentationValues.add(linkConcatenation); + linkConcentationValues.add(linkConcatenation2); + List + amplifiedLinkValues = new ArrayList<>(); + org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev170929.amplified.link.attributes.AmplifiedLink al = new + org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev170929.amplified.link.attributes + .AmplifiedLinkBuilder().setSectionElement(new SectionElementBuilder() + .setSectionElement(new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev170929.amplified.link + .attributes.amplified.link.section.element.section.element.SpanBuilder() + .setSpan(new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev170929.amplified.link + .attributes.amplified.link.section.element.section.element.span.SpanBuilder() + .setAdministrativeState(State.InService) + .setAutoSpanloss(true) + .setClfi("clfi") + .setEngineeredSpanloss(new RatioDB(BigDecimal.ONE)) + .setLinkConcatenation(linkConcentationValues) + .setSpanlossBase(new RatioDB(BigDecimal.ONE)) + .setSpanlossCurrent(new RatioDB(BigDecimal.ONE)) + .build()) + .build()) + .build()) + .setSectionEltNumber(Integer.valueOf(1)).build(); + org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev170929.amplified.link.attributes.AmplifiedLink al2 = new + org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev170929.amplified.link.attributes + .AmplifiedLinkBuilder().setSectionElement(new SectionElementBuilder() + .setSectionElement(new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev170929.amplified.link + .attributes.amplified.link.section.element.section.element.SpanBuilder() + .setSpan(new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev170929.amplified.link + .attributes.amplified.link.section.element.section.element.span.SpanBuilder() + .setAdministrativeState(State.InService) + .setAutoSpanloss(true) + .setClfi("clfi") + .setEngineeredSpanloss(new RatioDB(BigDecimal.ONE)) + .setLinkConcatenation(linkConcentationValues) + .setSpanlossBase(new RatioDB(BigDecimal.ONE)) + .setSpanlossCurrent(new RatioDB(BigDecimal.ONE)) + .build()) + .build()) + .build()) + .setSectionEltNumber(Integer.valueOf(1)).build(); + amplifiedLinkValues.add(al); + amplifiedLinkValues.add(al2); + Map>, Augmentation> map = Collections.emptyMap(); + Augmentation aug1 = new Link1Builder().setAdministrativeGroup(Long.valueOf(123)) + .setAdministrativeState(State.InService) + .setAmplified(true) + .setLinkLatency(Long.valueOf(123)) + .setLinkLength(BigDecimal.valueOf(123)) + .setLinkType(OpenroadmLinkType.ROADMTOROADM) + .setOMSAttributes(new OMSAttributesBuilder() + .setAmplifiedLink(new AmplifiedLinkBuilder().setAmplifiedLink(amplifiedLinkValues).build()) + .setOppositeLink(new LinkId("link 1")) + .setSpan(new SpanBuilder().build()) + .setTEMetric(Long.valueOf(123)).build()) + .setOperationalState(State.InService).build(); + Augmentation aug2 = new Link1Builder().setAdministrativeGroup(Long.valueOf(123)) + .setAdministrativeState(State.InService) + .setAmplified(true) + .setLinkLatency(Long.valueOf(123)) + .setLinkLength(BigDecimal.valueOf(123)) + .setLinkType(OpenroadmLinkType.ROADMTOROADM) + .setOMSAttributes(new OMSAttributesBuilder() + .setAmplifiedLink(new AmplifiedLinkBuilder().setAmplifiedLink(amplifiedLinkValues).build()) + .setOppositeLink(new LinkId("link 1")) + .setSpan(new SpanBuilder().build()) + .setTEMetric(Long.valueOf(123)).build()) + .setOperationalState(State.InService).build(); + + List supportingLinks = new ArrayList<>(); + SupportingLink supportingLink = new SupportingLinkBuilder().setLinkRef("ref1") + .setNetworkRef(new NetworkId("net1")).build(); + SupportingLink supportingLink2 = new SupportingLinkBuilder().setLinkRef("ref2") + .setNetworkRef(new NetworkId("net1")).build(); + supportingLinks.add(supportingLink); + supportingLinks.add(supportingLink2); + List links = new ArrayList<>(); + Link link1 = new LinkBuilder().setLinkId(new LinkId("link 1")) + .setDestination(new DestinationBuilder().setDestNode(new NodeId("node 1")) + .setDestTp("dest tp").build()) + .setSource(new SourceBuilder().setSourceNode(new NodeId("node 2")) + .setSourceTp("src tp").build()) + .setSupportingLink(supportingLinks) + .addAugmentation(Link1.class, aug1) + .addAugmentation(Link1.class, aug2).build(); + + Link link2 = new LinkBuilder().setLinkId(new LinkId("link 2")) + .setDestination(new DestinationBuilder().setDestNode(new NodeId("node 3")) + .setDestTp("dest tp").build()) + .setSource(new SourceBuilder().setSourceNode(new NodeId("node 4")) + .setSourceTp("src tp").build()) + .setSupportingLink(supportingLinks).build(); + links.add(link1); + links.add(link2); + Network1 network = new Network1Builder().setLink(links).build(); + Optional.of(network); + return network; + } + + public static List getNodeIds() { + List nodes = new ArrayList<>(); + NodeId node = new NodeId("node 1"); + NodeId node2 = new NodeId("node 1"); + NodeId node3 = new NodeId("node 1"); + NodeId node4 = new NodeId("node 1"); + nodes.add(node); + nodes.add(node2); + nodes.add(node3); + nodes.add(node4); + return nodes; + } + + public static Nodes getNodes(String nodeId, String mappingKey) { + List cpList = new ArrayList<>(); + CpToDegree cp1 = new CpToDegreeBuilder() + .setCircuitPackName("circuit name") + .setDegreeNumber(Long.valueOf(123)) + .build(); + CpToDegree cp2 = new CpToDegreeBuilder() + .setCircuitPackName("circuit name") + .setDegreeNumber(Long.valueOf(123)) + .build(); + cpList.add(cp1); + cpList.add(cp2); + List mappingList = new ArrayList<>(); + Mapping map1 = new MappingBuilder() + .setLogicalConnectionPoint("point") + .setSupportingCircuitPackName("circuit name") + .setSupportingOms("oms") + .setSupportingOts("ots") + .setSupportingPort("port") + .withKey(new MappingKey((mappingKey != null) ? mappingKey : "null")) + .build(); + mappingList.add(map1); + Nodes nodes = new NodesBuilder() + .setNodeId(nodeId) + .setNodeType(NodeTypes.Xpdr) + .setCpToDegree(cpList) + .setMapping(mappingList) + .build(); + return nodes; + } + + public static Nodes getNodes2(String nodeId, String mappingKey) { + List cpList = new ArrayList<>(); + CpToDegree cp1 = new CpToDegreeBuilder() + .setCircuitPackName("circuit name") + .setDegreeNumber(Long.valueOf(123)) + .build(); + CpToDegree cp2 = new CpToDegreeBuilder() + .setCircuitPackName("circuit name") + .setDegreeNumber(Long.valueOf(123)) + .build(); + cpList.add(cp1); + cpList.add(cp2); + List mappingList = new ArrayList<>(); + Mapping map1 = new MappingBuilder() + .setLogicalConnectionPoint("point") + .setSupportingCircuitPackName("circuit name") + .setSupportingOms("oms") + .setSupportingOts("ots") + .setSupportingPort("port") + .withKey(new MappingKey((mappingKey != null) ? mappingKey : "null")) + .build(); + mappingList.add(map1); + Nodes nodes = new NodesBuilder() + .setNodeId(nodeId) + .setNodeType(null) + .setCpToDegree(cpList) + .setMapping(mappingList) + .build(); + return nodes; + } + + public static Nodes getNodes3(String nodeId, String mappingKey) { + List cpList = new ArrayList<>(); + CpToDegree cp1 = new CpToDegreeBuilder() + .setCircuitPackName("circuit name") + .setDegreeNumber(Long.valueOf(123)) + .build(); + CpToDegree cp2 = new CpToDegreeBuilder() + .setCircuitPackName("circuit name") + .setDegreeNumber(Long.valueOf(123)) + .build(); + cpList.add(cp1); + cpList.add(cp2); + List mappingList = new ArrayList<>(); + Mapping map1 = new MappingBuilder() + .setLogicalConnectionPoint("point") + .setSupportingCircuitPackName("circuit name") + .setSupportingOms("oms") + .setSupportingOts("ots") + .setSupportingPort("port") + .withKey(new MappingKey((mappingKey != null) ? mappingKey : "null")) + .build(); + mappingList.add(map1); + Nodes nodes = new NodesBuilder() + .setNodeId(nodeId) + .setNodeType(NodeTypes.Rdm) + .setCpToDegree(cpList) + .setMapping(mappingList) + .build(); + return nodes; + } + + public static void writeNodeTransaction(String nodeId, DataBroker dataBroker, String mappingKey) { + InstanceIdentifier nodesIID = InstanceIdentifier.create(Network.class) + .child(Nodes.class, new NodesKey(nodeId)); + Nodes nodes = getNodes(nodeId, mappingKey); + writeTransaction(dataBroker, nodesIID, nodes); + } + + public static void writeNodeTransaction2(String nodeId, DataBroker dataBroker, String mappingKey) { + InstanceIdentifier nodesIID = InstanceIdentifier.create(Network.class) + .child(Nodes.class, new NodesKey(nodeId)); + Nodes nodes = getNodes2(nodeId, mappingKey); + writeTransaction(dataBroker, nodesIID, nodes); + } + + public static void writeNodeTransaction3(String nodeId, DataBroker dataBroker, String mappingKey) { + InstanceIdentifier nodesIID = InstanceIdentifier.create(Network.class) + .child(Nodes.class, new NodesKey(nodeId)); + Nodes nodes = getNodes3(nodeId, mappingKey); + writeTransaction(dataBroker, nodesIID, nodes); + } + +} diff --git a/olm/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker b/olm/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker new file mode 100644 index 000000000..ca6ee9cea --- /dev/null +++ b/olm/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker @@ -0,0 +1 @@ +mock-maker-inline \ No newline at end of file -- 2.36.6