From 8ea6d16bba042fed9f2d12347b1a9ca99074a779 Mon Sep 17 00:00:00 2001 From: Gilles Thouenon Date: Mon, 23 Sep 2019 16:21:36 +0200 Subject: [PATCH] Solve issue for testCalculateSpanlossBase Show example of unitary test on the calculateSpanlossBase method from OlmPowerServiceImpl.java. Signed-off-by: Gilles Thouenon Co-authored-by: Christophe Betoule Change-Id: I1e2003981faffdd6a3558b131633a0589f769188 --- .../OlmPowerServiceImplSpanLossBaseTest.java | 179 ++++++++++++ .../olm/util/OlmPowerServiceRpcImplUtil.java | 17 +- .../olm/util/OlmTransactionUtils.java | 270 ++++++++++++++++++ 3 files changed, 461 insertions(+), 5 deletions(-) create mode 100644 olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplSpanLossBaseTest.java create mode 100644 olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmTransactionUtils.java diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplSpanLossBaseTest.java b/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplSpanLossBaseTest.java new file mode 100644 index 000000000..257ef1e25 --- /dev/null +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/service/OlmPowerServiceImplSpanLossBaseTest.java @@ -0,0 +1,179 @@ +/* + * 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 java.math.BigDecimal; +import java.util.Optional; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.transportpce.common.NetworkUtils; +import org.opendaylight.transportpce.common.StringConstants; +import org.opendaylight.transportpce.common.Timeouts; +import org.opendaylight.transportpce.common.device.DeviceTransactionManager; +import org.opendaylight.transportpce.common.mapping.MappingUtils; +import org.opendaylight.transportpce.common.mapping.PortMapping; +import org.opendaylight.transportpce.common.mapping.PortMappingImpl; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl121; +import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfacesImpl221; +import org.opendaylight.transportpce.olm.power.PowerMgmt; +import org.opendaylight.transportpce.olm.power.PowerMgmtImpl; +import org.opendaylight.transportpce.olm.util.OlmPowerServiceRpcImplUtil; +import org.opendaylight.transportpce.olm.util.OlmTransactionUtils; +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.openroadm.common.types.rev181019.RatioDB; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.Interface; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.OrgOpenroadmDevice; +import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.OpticalTransport; +import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.Interface1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.Interface1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.ots.container.Ots; +import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.ots.container.OtsBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.CurrentPmList; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class OlmPowerServiceImplSpanLossBaseTest extends AbstractTest { + + private static final Logger LOG = LoggerFactory.getLogger(OlmPowerServiceImplSpanLossBaseTest.class); + private DeviceTransactionManager deviceTransactionManager; + private OpenRoadmInterfaces openRoadmInterfaces; + private PortMapping portMapping; + private PowerMgmt powerMgmt; + private MappingUtils mappingUtils; + private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl221; + private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121; + private OlmPowerService olmPowerService; + private DataBroker dataBroker; + + @Before + public void setUp() throws OpenRoadmInterfaceException { + this.openRoadmInterfacesImpl121 = Mockito.mock(OpenRoadmInterfacesImpl121.class); + this.openRoadmInterfacesImpl221 = Mockito.mock(OpenRoadmInterfacesImpl221.class); + this.mappingUtils = Mockito.mock(MappingUtils.class); + this.portMapping = Mockito.mock(PortMappingImpl.class); + this.deviceTransactionManager = Mockito.mock(DeviceTransactionManager.class); + this.powerMgmt = Mockito.mock(PowerMgmtImpl.class); + this.openRoadmInterfaces = new OpenRoadmInterfacesImpl(this.deviceTransactionManager, this.mappingUtils, + this.openRoadmInterfacesImpl121, this.openRoadmInterfacesImpl221); + this.olmPowerService = new OlmPowerServiceImpl(this.getDataBroker(), this.powerMgmt, + this.deviceTransactionManager, this.portMapping, this.mappingUtils, this.openRoadmInterfaces); + this.dataBroker = this.getDataBroker(); + MockitoAnnotations.initMocks(this); + Mockito.doReturn(StringConstants.OPENROADM_DEVICE_VERSION_2_2_1).when(this.mappingUtils) + .getOpenRoadmVersion(Mockito.anyString()); + + Mockito.when(this.portMapping.getMapping("ROADM-A1", "DEG2-TTP-TXRX")) + .thenReturn(OlmTransactionUtils.getMapping1()); + Mockito.when(this.portMapping.getMapping("ROADM-C1", "DEG1-TTP-TXRX")) + .thenReturn(OlmTransactionUtils.getMapping2()); + + InstanceIdentifier iidCurrentPmList = InstanceIdentifier.create(CurrentPmList.class); + Mockito.when(this.deviceTransactionManager.getDataFromDevice("ROADM-A1", LogicalDatastoreType.OPERATIONAL, + iidCurrentPmList, Timeouts.DEVICE_READ_TIMEOUT, + Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(OlmTransactionUtils.getCurrentPmListA()); + Mockito.when(this.deviceTransactionManager.getDataFromDevice("ROADM-C1", LogicalDatastoreType.OPERATIONAL, + iidCurrentPmList, Timeouts.DEVICE_READ_TIMEOUT, + Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(OlmTransactionUtils.getCurrentPmListC()); + + InstanceIdentifier interfacesIIDA = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(Interface.class, new InterfaceKey("OTS-DEG2-TTP-TXRX")); + InstanceIdentifier interfacesIIDC = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(Interface.class, new InterfaceKey("OTS-DEG1-TTP-TXRX")); + Optional interfaceA = Optional.of(new InterfaceBuilder().setName("OTS-DEG2-TTP-TXRX").build()); + Optional interfaceC = Optional.of(new InterfaceBuilder().setName("OTS-DEG1-TTP-TXRX").build()); + Mockito.when(this.deviceTransactionManager.getDataFromDevice("ROADM-A1", LogicalDatastoreType.CONFIGURATION, + interfacesIIDA, Timeouts.DEVICE_READ_TIMEOUT, + Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(interfaceA); + Mockito.when(this.deviceTransactionManager.getDataFromDevice("ROADM-C1", LogicalDatastoreType.CONFIGURATION, + interfacesIIDC, Timeouts.DEVICE_READ_TIMEOUT, + Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(interfaceC); + + Ots otsValue = new OtsBuilder().setSpanLossTransmit(new RatioDB(new BigDecimal(25))) + .setSpanLossReceive(new RatioDB(new BigDecimal(25))).build(); + Interface1 ots = new Interface1Builder().setOts(otsValue).build(); + Interface interA = new InterfaceBuilder().setName("OTS-DEG2-TTP-TXRX").setType(OpticalTransport.class) + .addAugmentation(Interface1.class, ots).build(); + Interface interC = new InterfaceBuilder().setName("OTS-DEG1-TTP-TXRX").setType(OpticalTransport.class) + .addAugmentation(Interface1.class, ots).build(); + Optional interOptA = Optional.of(interA); + Optional interOptC = Optional.of(interC); + Mockito.when(this.openRoadmInterfacesImpl221.getInterface("ROADM-A1", "OTS-DEG2-TTP-TXRX")) + .thenReturn(interOptA); + Mockito.when(this.openRoadmInterfacesImpl221.getInterface("ROADM-C1", "OTS-DEG1-TTP-TXRX")) + .thenReturn(interOptC); + + InterfaceBuilder ifABldr = new InterfaceBuilder(); + Mockito.doNothing().when(this.openRoadmInterfacesImpl221).postInterface("ROADM-A1", ifABldr); + Mockito.doNothing().when(this.openRoadmInterfacesImpl221).postInterface("ROADM-C1", ifABldr); + + } + + @Test + public void testCalculateSpanlossBaseLink() { + // initialise and store openroadm-topology in datastore + NetworkKey overlayTopologyKey = new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)); + InstanceIdentifier ietfNetworkIID = InstanceIdentifier.builder(Networks.class) + .child(Network.class, overlayTopologyKey).build(); + Network openroadmTopology = OlmTransactionUtils.getNetworkForSpanLoss(); + OlmTransactionUtils.writeTransaction(this.dataBroker, ietfNetworkIID, openroadmTopology); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + LOG.error("Write transaction failed !", e); + } + + CalculateSpanlossBaseInput input = OlmPowerServiceRpcImplUtil.getCalculateSpanlossBaseInputLink(); + CalculateSpanlossBaseOutput output = this.olmPowerService.calculateSpanlossBase(input); + + Assert.assertEquals("Success", output.getResult()); + Assert.assertEquals("ROADM-A1-to-ROADM-C1", output.getSpans().get(0).getLinkId().getValue()); + Assert.assertEquals("15", output.getSpans().get(0).getSpanloss()); + } + + @Test + public void testCalculateSpanlossBaseAll() { + + // initialise and store openroadm-topology in datastore + NetworkKey overlayTopologyKey = new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)); + InstanceIdentifier ietfNetworkIID = InstanceIdentifier.builder(Networks.class) + .child(Network.class, overlayTopologyKey).build(); + Network openroadmTopology = OlmTransactionUtils.getNetworkForSpanLoss(); + OlmTransactionUtils.writeTransaction(this.dataBroker, ietfNetworkIID, openroadmTopology); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + LOG.error("Write transaction failed !", e); + } + + CalculateSpanlossBaseInput input = OlmPowerServiceRpcImplUtil.getCalculateSpanlossBaseInputAll(); + CalculateSpanlossBaseOutput output = this.olmPowerService.calculateSpanlossBase(input); + + Assert.assertEquals("Success", output.getResult()); + Assert.assertEquals("ROADM-A1-to-ROADM-C1", output.getSpans().get(0).getLinkId().getValue()); + Assert.assertEquals("15", output.getSpans().get(0).getSpanloss()); + } +} 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 index ec9955157..8ba6ce8f0 100644 --- a/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmPowerServiceRpcImplUtil.java +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmPowerServiceRpcImplUtil.java @@ -147,11 +147,19 @@ public final class OlmPowerServiceRpcImplUtil { return input; } - public static CalculateSpanlossBaseInput getCalculateSpanlossBaseInput() { + public static CalculateSpanlossBaseInput getCalculateSpanlossBaseInputLink() { CalculateSpanlossBaseInput input = new CalculateSpanlossBaseInputBuilder() - .setLinkId(new LinkId("link 1")) - .setSrcType(CalculateSpanlossBaseInput.SrcType.Link) - .addAugmentation(null, null).build(); + .setLinkId(new LinkId("ROADM-A1-to-ROADM-C1")) + .setSrcType(CalculateSpanlossBaseInput.SrcType.Link) + .addAugmentation(null, null).build(); + return input; + } + + public static CalculateSpanlossBaseInput getCalculateSpanlossBaseInputAll() { + CalculateSpanlossBaseInput input = new CalculateSpanlossBaseInputBuilder() + .setLinkId(new LinkId("ROADM-A1-to-ROADM-C1")) + .setSrcType(CalculateSpanlossBaseInput.SrcType.All) + .addAugmentation(null, null).build(); return input; } @@ -174,5 +182,4 @@ public final class OlmPowerServiceRpcImplUtil { .setServiceName("service 1").build(); return input; } - } diff --git a/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmTransactionUtils.java b/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmTransactionUtils.java new file mode 100644 index 000000000..69c70e686 --- /dev/null +++ b/olm/src/test/java/org/opendaylight/transportpce/olm/util/OlmTransactionUtils.java @@ -0,0 +1,270 @@ +/* + * 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.eclipse.jdt.annotation.NonNull; +import org.opendaylight.mdsal.binding.api.DataBroker; +import org.opendaylight.mdsal.binding.api.WriteTransaction; +import org.opendaylight.mdsal.common.api.LogicalDatastoreType; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.Mapping; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev190702.network.nodes.MappingBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.link.types.rev181130.FiberPmd; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.link.types.rev181130.RatioDB; +import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev181130.State; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.Interface; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceKey; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.OrgOpenroadmDevice; +import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev181130.AdminStates; +import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.amplified.link.attributes.AmplifiedLink; +import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.amplified.link.attributes.amplified.link.SectionElementBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.span.attributes.LinkConcatenation; +import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.span.attributes.LinkConcatenationBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Link1; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Link1Builder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network.link.OMSAttributesBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network.link.oms.attributes.AmplifiedLinkBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network.link.oms.attributes.SpanBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmLinkType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.CurrentPmList; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.CurrentPmListBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.current.pm.group.CurrentPm; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.current.pm.group.CurrentPmBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.current.pm.list.CurrentPmEntry; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.current.pm.list.CurrentPmEntryBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.current.pm.val.group.Measurement; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.rev181019.current.pm.val.group.MeasurementBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev171215.PmDataType; +import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev171215.Validity; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.NodeBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNode; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNodeBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.LinkId; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Network1Builder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.LinkBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.link.DestinationBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.link.SourceBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.DateAndTime; +import org.opendaylight.yangtools.yang.binding.Augmentation; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public final class OlmTransactionUtils { + + private OlmTransactionUtils() { + } + + public static void writeTransaction(DataBroker dataBroker, InstanceIdentifier instanceIdentifier, + DataObject object) { + @NonNull + WriteTransaction transaction = dataBroker.newWriteOnlyTransaction(); + transaction.put(LogicalDatastoreType.CONFIGURATION, instanceIdentifier, object); + transaction.commit(); + } + + public static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks + .Network getNetworkForSpanLoss() { + + 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); + // create 2 openroadm-topology degree nodes, end points of the link to be + // measured + List supportingNodeListA = new ArrayList<>(); + supportingNodeListA.add(new SupportingNodeBuilder().setNetworkRef(new NetworkId("openroadm-network")) + .setNodeRef(new NodeId("ROADM-A1")).build()); + Node ietfNodeA = new NodeBuilder().setNodeId(new NodeId("ROADM-A1-DEG2")).setSupportingNode(supportingNodeListA) + .build(); + List supportingNodeListC = new ArrayList<>(); + supportingNodeListC.add(new SupportingNodeBuilder().setNetworkRef(new NetworkId("openroadm-network")) + .setNodeRef(new NodeId("ROADM-C1")).build()); + Node ietfNodeC = new NodeBuilder().setNodeId(new NodeId("ROADM-C1-DEG1")).setSupportingNode(supportingNodeListC) + .build(); + List ietfNodeList = new ArrayList<>(); + ietfNodeList.add(ietfNodeA); + ietfNodeList.add(ietfNodeC); + + List + amplifiedLinkValues = new ArrayList<>(); + org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.amplified.link.attributes.AmplifiedLink al = + new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.amplified.link.attributes + .AmplifiedLinkBuilder().setSectionElement(new SectionElementBuilder() + .setSectionElement(new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130 + .amplified.link.attributes.amplified.link.section.element.section.element + .SpanBuilder().setSpan(new org.opendaylight.yang.gen.v1.http.org.openroadm + .link.rev181130.amplified.link.attributes.amplified.link.section.element.section + .element.span.SpanBuilder().setAdministrativeState(AdminStates.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.rev181130.amplified.link.attributes.AmplifiedLink al2 = + new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.amplified.link.attributes + .AmplifiedLinkBuilder().setSectionElement(new SectionElementBuilder() + .setSectionElement(new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.amplified.link + .attributes.amplified.link.section.element.section.element.SpanBuilder() + .setSpan(new org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev181130.amplified.link + .attributes.amplified.link.section.element.section.element.span.SpanBuilder() + .setAdministrativeState(AdminStates.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(); + + // create the roadm-to-roadm link to be measured + List ietfLinkList = new ArrayList<>(); + Link roadm2roadmLink = new LinkBuilder().setLinkId(new LinkId("ROADM-A1-to-ROADM-C1")) + .setSource(new SourceBuilder().setSourceNode(ietfNodeA.getNodeId()).setSourceTp("DEG2-TTP-TXRX").build()) + .setDestination(new DestinationBuilder().setDestNode(ietfNodeC.getNodeId()).setDestTp("DEG1-TTP-TXRX") + .build()) + .addAugmentation(Link1.class, aug1) + .addAugmentation(Link1.class, aug2) + .build(); + ietfLinkList.add(roadm2roadmLink); + // create the ietf network + Network1 openroadmAugmToIetfNetwork = new Network1Builder().setLink(ietfLinkList).build(); + NetworkBuilder ietfNetworkBldr = new NetworkBuilder().setNetworkId(new NetworkId("openroadm-topology")) + .setNode(ietfNodeList).addAugmentation(Network1.class, openroadmAugmToIetfNetwork); + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network + openroadmTopology; + openroadmTopology = ietfNetworkBldr.build(); + return openroadmTopology; + } + + public static Mapping getMapping1() { + return new MappingBuilder().setLogicalConnectionPoint("DEG2-TTP-TXRX").setSupportingOts("OTS-DEG2-TTP-TXRX") + .build(); + } + + public static Mapping getMapping2() { + return new MappingBuilder().setLogicalConnectionPoint("DEG1-TTP-TXRX").setSupportingOts("OTS-DEG1-TTP-TXRX") + .build(); + } + + public static Optional getCurrentPmListA() { + Measurement measurementA = new MeasurementBuilder() + .setGranularity(org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev171215.PmGranularity._15min) + .setPmParameterValue(new PmDataType(new BigDecimal("-3.5"))) + .setValidity(Validity.Complete) + .build(); + List measurementListA = new ArrayList<>(); + measurementListA.add(measurementA); + CurrentPm cpA = new CurrentPmBuilder() + .setType(org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev171215.PmNamesEnum.OpticalPowerOutput) + .setMeasurement(measurementListA) + .build(); + List currentPmListA = new ArrayList<>(); + currentPmListA.add(cpA); + InstanceIdentifier interfaceIIDA = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(Interface.class, new InterfaceKey("OTS-DEG2-TTP-TXRX")); + CurrentPmEntry currentPmEntryA = new CurrentPmEntryBuilder() + .setCurrentPm(currentPmListA) + .setPmResourceInstance(interfaceIIDA) + .setPmResourceType( + org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum.Interface) + .setPmResourceTypeExtension("") + .setRetrievalTime(new DateAndTime("2018-06-07T13:22:58+00:00")) + .build(); + List currentPmEntryListA = new ArrayList<>(); + currentPmEntryListA.add(currentPmEntryA); + return Optional.of(new CurrentPmListBuilder().setCurrentPmEntry(currentPmEntryListA).build()); + } + + public static Optional getCurrentPmListC() { + Measurement measurementC = new MeasurementBuilder() + .setGranularity(org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev171215.PmGranularity._15min) + .setPmParameterValue(new PmDataType(new BigDecimal("-18.1"))) + .setValidity(Validity.Complete) + .build(); + List measurementListC = new ArrayList<>(); + measurementListC.add(measurementC); + CurrentPm cpC = new CurrentPmBuilder() + .setType(org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev171215.PmNamesEnum.OpticalPowerInput) + .setMeasurement(measurementListC) + .build(); + List currentPmListC = new ArrayList<>(); + currentPmListC.add(cpC); + InstanceIdentifier interfaceIIDC = InstanceIdentifier.create(OrgOpenroadmDevice.class) + .child(Interface.class, new InterfaceKey("OTS-DEG1-TTP-TXRX")); + CurrentPmEntry currentPmEntryC = new CurrentPmEntryBuilder() + .setCurrentPm(currentPmListC) + .setPmResourceInstance(interfaceIIDC) + .setPmResourceType( + org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev181019.ResourceTypeEnum.Interface) + .setPmResourceTypeExtension("") + .setRetrievalTime(new DateAndTime("2018-06-07T13:22:58+00:00")) + .build(); + List currentPmEntryListC = new ArrayList<>(); + currentPmEntryListC.add(currentPmEntryC); + return Optional.of(new CurrentPmListBuilder().setCurrentPmEntry(currentPmEntryListC).build()); + } +} \ No newline at end of file -- 2.36.6