common/src/test/java/org/opendaylight/transportpce/common/mapping/PortMappingVersion121Test.java

   1 /*
   2  * Copyright © 2020 Orange Labs, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.transportpce.common.mapping;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertFalse;
  13 import static org.junit.Assert.assertTrue;
  14 import static org.junit.Assert.fail;
  15 import static org.mockito.Mockito.mock;
  16 import static org.mockito.Mockito.when;
  17
  18 import java.util.ArrayList;
  19 import java.util.Arrays;
  20 import java.util.Collections;
  21 import java.util.HashMap;
  22 import java.util.List;
  23 import java.util.Map;
  24 import java.util.Optional;
  25 import java.util.Random;
  26 import java.util.concurrent.ExecutionException;
  27 import org.eclipse.jdt.annotation.NonNull;
  28 import org.junit.Before;
  29 import org.junit.Test;
  30 import org.opendaylight.mdsal.binding.api.DataBroker;
  31 import org.opendaylight.mdsal.binding.api.ReadTransaction;
  32 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  33 import org.opendaylight.transportpce.common.Timeouts;
  34 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  35 import org.opendaylight.transportpce.test.DataStoreContext;
  36 import org.opendaylight.transportpce.test.DataStoreContextImpl;
  37 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.Network;
  38 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.NetworkBuilder;
  39 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.mapping.Mapping;
  40 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.network.Nodes;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.Direction;
  42 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.NodeTypes;
  43 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.OrgOpenroadmDeviceData;
  44 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.Port;
  45 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.ParentCircuitPackBuilder;
  46 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.Ports;
  47 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.PortsBuilder;
  48 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.pack.PortsKey;
  49 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacks;
  50 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacksBuilder;
  51 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.circuit.packs.CircuitPacksKey;
  52 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.ConnectionPorts;
  53 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.ConnectionPortsBuilder;
  54 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.ConnectionPortsKey;
  55 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.Interface;
  56 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceBuilder;
  57 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.interfaces.grp.InterfaceKey;
  58 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDevice;
  59 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.OrgOpenroadmDeviceBuilder;
  60 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.ConnectionMap;
  61 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.ConnectionMapBuilder;
  62 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.ConnectionMapKey;
  63 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Degree;
  64 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.DegreeBuilder;
  65 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.DegreeKey;
  66 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Info;
  67 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.InfoBuilder;
  68 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.Protocols;
  69 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.ProtocolsBuilder;
  70 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup;
  71 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupBuilder;
  72 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.SharedRiskGroupKey;
  73 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.connection.map.Destination;
  74 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.connection.map.DestinationBuilder;
  75 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.connection.map.DestinationKey;
  76 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.connection.map.SourceBuilder;
  77 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.Interfaces;
  78 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.InterfacesBuilder;
  79 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.port.PartnerPortBuilder;
  80 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.Protocols1Builder;
  81 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.LldpBuilder;
  82 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.lldp.PortConfig;
  83 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.lldp.PortConfigBuilder;
  84 import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev161014.lldp.container.lldp.PortConfigKey;
  85 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  86 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  87 import org.opendaylight.yangtools.yang.binding.Augmentation;
  88 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  89 import org.opendaylight.yangtools.yang.common.Uint16;
  90 import org.opendaylight.yangtools.yang.common.Uint32;
  91 import org.slf4j.Logger;
  92 import org.slf4j.LoggerFactory;
  93
  94 public class PortMappingVersion121Test {
  95
  96     private static final Logger LOG = LoggerFactory.getLogger(PortMappingVersion121Test.class);
  97     private static DataBroker dataBroker;
  98     private static DeviceTransactionManager deviceTransactionManager;
  99     private static PortMappingVersion121 portMappingVersion121;
 100     private Random ran = new Random();
 101
 102     @Before
 103     public void setUp() throws Exception {
 104         // test createMappingData for a xpdr node with 3 network + 1 client + bidirectional & unidirectional ports
 105         DataStoreContext dataStoreContext = new DataStoreContextImpl();
 106         dataBroker = dataStoreContext.getDataBroker();
 107         deviceTransactionManager = mock(DeviceTransactionManager.class);
 108         portMappingVersion121 = new PortMappingVersion121(dataBroker, deviceTransactionManager);
 109     }
 110
 111     @Test
 112     public void createMappingDataTestRdm() {
 113         // mock node info
 114         final Info info = getInfo2();
 115
 116         List<Interfaces> interfacesList = Arrays.asList(getInterfaces("i1"), getInterfaces("i2"));
 117
 118         // mock 1 bidirectional port for degree
 119         Ports ports = getPortsWithInterfaces(interfacesList, "p1");
 120         List<Ports> portsList = Arrays.asList(ports);
 121
 122         // mock 2 unidirectional ports for degree
 123         Ports ports2 = getPorts("p2", Port.PortQual.RoadmExternal, "c3", "p3", Direction.Rx);
 124         Ports ports3 = getPorts("p3", Port.PortQual.RoadmExternal, "c3", "p2", Direction.Tx);
 125         List<Ports> portsList2 = Arrays.asList(ports2, ports3);
 126
 127         // mock 2 unidirectional ports for degree, reverse direction
 128         Ports ports22 = getPorts("p22", Port.PortQual.RoadmExternal, "c5", "p33", Direction.Tx);
 129         Ports ports33 = getPorts("p33", Port.PortQual.RoadmExternal, "c5", "p22", Direction.Rx);
 130         List<Ports> portsList22 = Arrays.asList(ports22, ports33);
 131
 132         // mock 2 unidirectional ports for srg
 133         Ports ports4 = getPorts("p4", Port.PortQual.RoadmExternal, "c4", "p5", Direction.Rx);
 134         Ports ports5 = getPorts("p5", Port.PortQual.RoadmExternal, "c4", "p4", Direction.Tx);
 135         List<Ports> portsList4 = Arrays.asList(ports4, ports5);
 136
 137         // mock 2 unidirectional ports for srg, reverse direction
 138         Ports ports44 = getPorts("p44", Port.PortQual.RoadmExternal, "c6", "p55", Direction.Tx);
 139         Ports ports55 = getPorts("p55", Port.PortQual.RoadmExternal, "c6", "p44", Direction.Rx);
 140         List<Ports> portsList44 = Arrays.asList(ports44, ports55);
 141
 142         // mock 6 circuit packs
 143         final CircuitPacks circuitPackObject = getCircuitPacks(portsList, "c1", "pc1");
 144         final CircuitPacks circuitPackObject2 = getCircuitPacks(portsList, "c2", "pc2");
 145         final CircuitPacks circuitPackObject3 = getCircuitPacks(portsList2, "c3", "pc3");
 146         final CircuitPacks circuitPackObject4 = getCircuitPacks(portsList4, "c4", "pc4");
 147         final CircuitPacks circuitPackObject5 = getCircuitPacks(portsList22, "c5", "pc5");
 148         final CircuitPacks circuitPackObject6 = getCircuitPacks(portsList44, "c6", "pc6");
 149
 150         // mock 6 connection ports
 151         ConnectionPorts connectionPorts = getConnectionPorts("c1", "p1");
 152         Map<ConnectionPortsKey, ConnectionPorts> connectionPortsMap = new HashMap<>();
 153         connectionPortsMap.put(connectionPorts.key(), connectionPorts);
 154
 155         ConnectionPorts connectionPorts2 = getConnectionPorts("c2", "p1");
 156         List<ConnectionPorts> connectionPortsList2 = new ArrayList<ConnectionPorts>();
 157         connectionPortsList2.add(connectionPorts2);
 158
 159         ConnectionPorts connectionPorts3 = getConnectionPorts("c3", "p2");
 160         ConnectionPorts connectionPorts4 = getConnectionPorts("c3", "p3");
 161         Map<ConnectionPortsKey, ConnectionPorts> connectionPortsMap3 = new HashMap<>();
 162         connectionPortsMap3.put(connectionPorts3.key(), connectionPorts3);
 163         connectionPortsMap3.put(connectionPorts4.key(), connectionPorts4);
 164
 165         ConnectionPorts connectionPorts5 = getConnectionPorts("c4", "p4");
 166         ConnectionPorts connectionPorts6 = getConnectionPorts("c4", "p5");
 167         List<ConnectionPorts> connectionPortsList4 = new ArrayList<ConnectionPorts>();
 168         connectionPortsList4.add(connectionPorts5);
 169         connectionPortsList4.add(connectionPorts6);
 170
 171         ConnectionPorts connectionPorts33 = getConnectionPorts("c5", "p22");
 172         ConnectionPorts connectionPorts44 = getConnectionPorts("c5", "p33");
 173         Map<ConnectionPortsKey, ConnectionPorts> connectionPortsMap33 = new HashMap<>();
 174         connectionPortsMap33.put(connectionPorts33.key(), connectionPorts33);
 175         connectionPortsMap33.put(connectionPorts44.key(), connectionPorts44);
 176
 177         ConnectionPorts connectionPorts55 = getConnectionPorts("c6", "p44");
 178         ConnectionPorts connectionPorts66 = getConnectionPorts("c6", "p55");
 179         Map<ConnectionPortsKey, ConnectionPorts> connectionPortsMap44 = new HashMap<>();
 180         connectionPortsMap44.put(connectionPorts55.key(), connectionPorts55);
 181         connectionPortsMap44.put(connectionPorts66.key(), connectionPorts66);
 182
 183         // mock one degree with bidirectional port
 184         org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks circuitPacks =
 185                 new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksBuilder()
 186                 .withKey(new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
 187                         .degree.CircuitPacksKey(Uint32.valueOf(1)))
 188                         .setCircuitPackName("c1").build();
 189         Map<
 190                 org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksKey,
 191                 org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks> circuitPacksMap =
 192                         new HashMap<>();
 193         circuitPacksMap.put(circuitPacks.key(), circuitPacks);
 194
 195         final Degree ordmDegreeObject = new DegreeBuilder().setDegreeNumber(Uint16.valueOf(1))
 196                 .setCircuitPacks(circuitPacksMap).setConnectionPorts(connectionPortsMap).build();
 197
 198         // mock one srg with bidirectional port
 199         org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks srgCircuitPacks =
 200                 new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacksBuilder()
 201                 .withKey(new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
 202                         .srg.CircuitPacksKey(Uint32.valueOf(2)))
 203                         .setCircuitPackName("c2").build();
 204         Map<
 205                 org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacksKey,
 206                 org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks> srgCircuitPacksList =
 207                         new HashMap<>();
 208         srgCircuitPacksList.put(srgCircuitPacks.key(), srgCircuitPacks);
 209
 210         final SharedRiskGroup ordmSrgObject = new SharedRiskGroupBuilder().setSrgNumber(Uint16.valueOf(1))
 211                 .setCircuitPacks(srgCircuitPacksList).build();
 212
 213         // mock one degree with 2 unidirectional ports
 214         org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks circuitPacks3 =
 215                 new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksBuilder()
 216                 .withKey(new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
 217                         .degree.CircuitPacksKey(Uint32.valueOf(3)))
 218                         .setCircuitPackName("c3").build();
 219         List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks> circuitPacksList3 =
 220                 new ArrayList<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks>();
 221         circuitPacksList3.add(circuitPacks3);
 222
 223         Map<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksKey,
 224             org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks> values =
 225             new HashMap<>();
 226         org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksKey circuitPackKey =
 227                 new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksKey(
 228                         Uint32.valueOf(3));
 229         values.put(circuitPackKey, circuitPacks3);
 230         final Degree ordmDegreeObject3 = new DegreeBuilder().setDegreeNumber(Uint16.valueOf(2)).setCircuitPacks(values)
 231                 .setConnectionPorts(connectionPortsMap3).build();
 232         // mock one srg with 2 unidirectional ports
 233         org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks srgCircuitPacks4 =
 234                 new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacksBuilder()
 235                 .withKey(new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
 236                         .srg.CircuitPacksKey(Uint32.valueOf(4)))
 237                         .setCircuitPackName("c4").build();
 238         Map<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacksKey,
 239                 org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks>
 240             srgCircuitPacksList4 = new HashMap<>();
 241         srgCircuitPacksList4.put(srgCircuitPacks4.key(), srgCircuitPacks4);
 242
 243         final SharedRiskGroup ordmSrgObject4 = new SharedRiskGroupBuilder().setSrgNumber(Uint16.valueOf(2))
 244                 .setCircuitPacks(srgCircuitPacksList4).build();
 245
 246         // mock one degree with unidirectional ports, reverse direction
 247         org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks circuitPacks5 =
 248                 new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksBuilder()
 249                 .withKey(new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
 250                         .degree.CircuitPacksKey(Uint32.valueOf(5)))
 251                         .setCircuitPackName("c5").build();
 252         List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks> circuitPacksList5 =
 253                 new ArrayList<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacks>();
 254         circuitPacksList5.add(circuitPacks5);
 255         values = new HashMap<>();
 256         circuitPackKey = new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.CircuitPacksKey(
 257                 Uint32.valueOf(5));
 258         values.put(circuitPackKey, circuitPacks5);
 259         final Degree ordmDegreeObject5 = new DegreeBuilder().setDegreeNumber(Uint16.valueOf(3)).setCircuitPacks(values)
 260                 .setConnectionPorts(connectionPortsMap44).build();
 261
 262         // mock one srg with 2 unidirectional ports, reverse direction
 263         org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks srgCircuitPacks6 =
 264                 new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacksBuilder()
 265                 .withKey(new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206
 266                         .srg.CircuitPacksKey(Uint32.valueOf(6)))
 267                         .setCircuitPackName("c6").build();
 268         Map<
 269                 org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacksKey,
 270                 org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.srg.CircuitPacks> srgCircuitPacksMap6 =
 271                         new HashMap<>();
 272         srgCircuitPacksMap6.put(srgCircuitPacks6.key(), srgCircuitPacks6);
 273
 274         final SharedRiskGroup ordmSrgObject6 = new SharedRiskGroupBuilder().setSrgNumber(Uint16.valueOf(3))
 275                 .setCircuitPacks(srgCircuitPacksMap6).build();
 276
 277         // mock lldp configuration
 278         PortConfig portConfig =
 279                 new PortConfigBuilder().setIfName("i1").setAdminStatus(PortConfig.AdminStatus.Txandrx).build();
 280         Map<PortConfigKey, PortConfig> portConfigMap = new HashMap<>();
 281         portConfigMap.put(portConfig.key(), portConfig);
 282         Augmentation<Protocols> augmentation =
 283                 new Protocols1Builder().setLldp(new LldpBuilder().setPortConfig(portConfigMap).build()).build();
 284         Protocols protocols = new ProtocolsBuilder().addAugmentation(augmentation).build();
 285
 286         // mock responses for deviceTransactionManager calls
 287         InstanceIdentifier<Degree> deviceIID = InstanceIdentifier
 288             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 289             .child(Degree.class, new DegreeKey(Uint16.valueOf(1)))
 290             .build();
 291         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, deviceIID,
 292                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 293                         .thenReturn(Optional.of(ordmDegreeObject));
 294
 295         InstanceIdentifier<Degree> deviceIID3 = InstanceIdentifier
 296             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 297             .child(Degree.class, new DegreeKey(Uint16.valueOf(2)))
 298             .build();
 299         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, deviceIID3,
 300                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 301                         .thenReturn(Optional.of(ordmDegreeObject3));
 302
 303         InstanceIdentifier<Degree> deviceIID5 = InstanceIdentifier
 304             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 305             .child(Degree.class, new DegreeKey(Uint16.valueOf(3)))
 306             .build();
 307         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, deviceIID5,
 308                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 309                         .thenReturn(Optional.of(ordmDegreeObject5));
 310
 311         InstanceIdentifier<Protocols> protocoliid = InstanceIdentifier
 312             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 313             .child(Protocols.class)
 314             .build();
 315         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, protocoliid,
 316                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(protocols));
 317
 318         Interface interfaceObject = new InterfaceBuilder().withKey(new InterfaceKey("itf1"))
 319                 .setSupportingCircuitPackName("sc1").build();
 320         InstanceIdentifier<Interface> interfaceIID = InstanceIdentifier
 321             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 322             .child(Interface.class, new InterfaceKey(portConfig.getIfName()))
 323             .build();
 324         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, interfaceIID,
 325                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 326                         .thenReturn(Optional.of(interfaceObject));
 327
 328         InstanceIdentifier<Ports> portID = getChild("c1", "p1");
 329         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID,
 330                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports));
 331
 332         // mock 2 bidirectional port for SRG
 333         Ports ports1 = getPortsWithInterfaces(interfacesList, "p2");
 334         InstanceIdentifier<Ports> portID1 = getChild("c2", "p1");
 335         when(deviceTransactionManager.getDataFromDevice("node",
 336             LogicalDatastoreType.OPERATIONAL, portID1,
 337             Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 338             .thenReturn(Optional.of(ports1));
 339
 340         InstanceIdentifier<Ports> portID2 = getChild("c3", "p2");
 341         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID2,
 342                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports2));
 343
 344         InstanceIdentifier<Ports> portID3 = getChild("c3", "p3");
 345         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID3,
 346                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports3));
 347
 348         InstanceIdentifier<Ports> portID22 = getChild("c5", "p22");
 349         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID22,
 350                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports22));
 351
 352         InstanceIdentifier<Ports> portID33 = getChild("c5", "p33");
 353         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID33,
 354                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports33));
 355
 356         InstanceIdentifier<Ports> portID4 = getChild("c4", "p4");
 357         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID4,
 358                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports4));
 359
 360         InstanceIdentifier<Ports> portID5 = getChild("c4", "p5");
 361         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID5,
 362                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports5));
 363
 364         InstanceIdentifier<Ports> portID44 = getChild("c6", "p44");
 365         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID44,
 366                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports44));
 367
 368         InstanceIdentifier<Ports> portID55 = getChild("c6", "p55");
 369         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID55,
 370                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports55));
 371
 372         InstanceIdentifier<Info> infoIID = InstanceIdentifier
 373             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 374             .child(Info.class)
 375             .build();
 376         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, infoIID,
 377                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(info));
 378
 379         InstanceIdentifier<CircuitPacks> circuitPacksIID = InstanceIdentifier
 380             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 381             .child(CircuitPacks.class, new CircuitPacksKey("c1"))
 382             .build();
 383         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID,
 384                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 385                         .thenReturn(Optional.of(circuitPackObject));
 386
 387         InstanceIdentifier<CircuitPacks> circuitPacksIID2 = InstanceIdentifier
 388             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 389             .child(CircuitPacks.class, new CircuitPacksKey("c2"))
 390             .build();
 391         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID2,
 392                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 393                         .thenReturn(Optional.of(circuitPackObject2));
 394
 395         InstanceIdentifier<CircuitPacks> circuitPacksIID3 = InstanceIdentifier
 396             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 397             .child(CircuitPacks.class, new CircuitPacksKey("c3"))
 398             .build();
 399         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID3,
 400                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 401                         .thenReturn(Optional.of(circuitPackObject3));
 402
 403         InstanceIdentifier<CircuitPacks> circuitPacksIID4 = InstanceIdentifier
 404             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 405             .child(CircuitPacks.class, new CircuitPacksKey("c4"))
 406             .build();
 407         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID4,
 408                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 409                         .thenReturn(Optional.of(circuitPackObject4));
 410
 411         InstanceIdentifier<CircuitPacks> circuitPacksIID5 = InstanceIdentifier
 412             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 413             .child(CircuitPacks.class, new CircuitPacksKey("c5"))
 414             .build();
 415         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID5,
 416                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 417                         .thenReturn(Optional.of(circuitPackObject5));
 418
 419         InstanceIdentifier<CircuitPacks> circuitPacksIID6 = InstanceIdentifier
 420             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 421             .child(CircuitPacks.class, new CircuitPacksKey("c6"))
 422             .build();
 423         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID6,
 424                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 425                         .thenReturn(Optional.of(circuitPackObject6));
 426
 427         InstanceIdentifier<SharedRiskGroup> srgIID = InstanceIdentifier
 428             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 429             .child(SharedRiskGroup.class, new SharedRiskGroupKey(Uint16.valueOf(1)))
 430             .build();
 431         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, srgIID,
 432                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 433                         .thenReturn(Optional.of(ordmSrgObject));
 434
 435         InstanceIdentifier<SharedRiskGroup> srgIID4 = InstanceIdentifier
 436             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 437             .child(SharedRiskGroup.class, new SharedRiskGroupKey(Uint16.valueOf(2)))
 438             .build();
 439         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, srgIID4,
 440                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 441                         .thenReturn(Optional.of(ordmSrgObject4));
 442
 443         InstanceIdentifier<SharedRiskGroup> srgIID6 = InstanceIdentifier
 444             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 445             .child(SharedRiskGroup.class, new SharedRiskGroupKey(Uint16.valueOf(3)))
 446             .build();
 447         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, srgIID6,
 448                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 449                         .thenReturn(Optional.of(ordmSrgObject6));
 450
 451         // test createMappingData with a node with 3 dgree + 3 srg + bidirectional & unidirectional ports
 452         assertTrue("creating mappingdata for existed node returns true",
 453                 portMappingVersion121.createMappingData("node"));
 454
 455         // assert all portmappings have been created for the roadm node
 456         ReadTransaction rr = dataBroker.newReadOnlyTransaction();
 457         InstanceIdentifier<Network> mappingIID = InstanceIdentifier.create(Network.class);
 458         Network network = new NetworkBuilder().build();
 459         try {
 460             Optional<Network> optionalNetwork = rr.read(LogicalDatastoreType.CONFIGURATION, mappingIID).get();
 461             if (optionalNetwork.isPresent()) {
 462                 network = optionalNetwork.get();
 463             }
 464
 465         } catch (ExecutionException | InterruptedException e) {
 466             LOG.error("Failed to read mapping.", e);
 467             fail();
 468
 469         }
 470         List<String> testMappings = Arrays.asList("SRG2-PP1-RX", "SRG3-PP1-RX", "SRG1-PP1-TXRX", "SRG3-PP1-TX",
 471                 "DEG1-TTP-TXRX", "SRG2-PP1-TX", "DEG2-TTP-RX", "DEG2-TTP-TX", "DEG3-TTP-RX", "DEG3-TTP-TX");
 472         List<String> mappings = new ArrayList<>();
 473         List<Nodes> nodes = new ArrayList<>(network.nonnullNodes().values());
 474         List<Mapping> mappingValues = new ArrayList<>(nodes.get(0).nonnullMapping().values());
 475         for (int i = 0; i < testMappings.size(); i++) {
 476             mappings.add(mappingValues.get(i).getLogicalConnectionPoint());
 477         }
 478         Collections.sort(testMappings);
 479         Collections.sort(mappings);
 480         assertEquals("test mapping are equals to mapping", testMappings, mappings);
 481
 482         // test updateMapping
 483         assertTrue("update mapping for node returns true",
 484                 portMappingVersion121.updateMapping("node", mappingValues.get(0)));
 485
 486         // test createMapping for non-existent roadm node
 487         assertFalse("create non existed roadm node returns false", portMappingVersion121.createMappingData("node2"));
 488
 489         // test updateMapping for null roadm node
 490         assertFalse("updating null roadm node returns false",
 491                 portMappingVersion121.updateMapping(null, mappingValues.get(0)));
 492
 493     }
 494
 495     @Test
 496     public void createMappingDataTestXpdr() {
 497         // mock node info
 498         final Info info = getInfo();
 499
 500         // mock 1 bidirectional port for network
 501         Ports ports = new PortsBuilder().withKey(new PortsKey("p1")).setPortName("p1")
 502                 .setPortQual(Port.PortQual.XpdrNetwork)
 503                 .setPortDirection(Direction.Bidirectional).build();
 504         List<Ports> portsList = new ArrayList<>();
 505         portsList.add(ports);
 506
 507         // mock 1 bidirectional port for client
 508         Ports ports11 = new PortsBuilder().withKey(new PortsKey("p11")).setPortName("p11")
 509                 .setPortQual(Port.PortQual.XpdrClient)
 510                 .setPortDirection(Direction.Bidirectional).build();
 511         List<Ports> portsList11 = new ArrayList<>();
 512         portsList11.add(ports11);
 513
 514         // mock 2 unidirectional ports for network
 515         Ports ports2 = getPorts("p2", Port.PortQual.XpdrNetwork, "c3", "p3", Direction.Rx);
 516         Ports ports3 = getPorts("p3", Port.PortQual.XpdrNetwork, "c3", "p2", Direction.Tx);
 517         List<Ports> portsList2 = new ArrayList<>();
 518         portsList2.add(ports2);
 519         portsList2.add(ports3);
 520
 521         // mock 2 unidirectional ports for network, reverse direction
 522         Ports ports4 = getPorts("p4", Port.PortQual.XpdrNetwork, "c4", "p5", Direction.Tx);
 523         Ports ports5 = getPorts("p5", Port.PortQual.XpdrNetwork, "c4", "p4", Direction.Rx);
 524         List<Ports> portsList4 = new ArrayList<>();
 525         portsList4.add(ports4);
 526         portsList4.add(ports5);
 527
 528         // mock connection map
 529         Destination destination = new DestinationBuilder()
 530                 .setCircuitPackName("c2").setPortName("p11").build();
 531         List<Destination> destinationList = new ArrayList<>();
 532         destinationList.add(destination);
 533         ConnectionMap connectionMap = getConnectionMap(destinationList);
 534         Map<ConnectionMapKey, ConnectionMap> connectionMapMap = new HashMap<>();
 535         connectionMapMap.put(connectionMap.key(), connectionMap);
 536
 537         // mock reponses for deviceTransactionManager
 538         InstanceIdentifier<Ports> portID = getChild("c1", "p1");
 539         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID,
 540                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports));
 541
 542         InstanceIdentifier<Ports> portID11 = getChild("c2", "p11");
 543         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID11,
 544                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports11));
 545
 546         InstanceIdentifier<Ports> portID2 = getChild("c3", "p2");
 547         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID2,
 548                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports2));
 549
 550         InstanceIdentifier<Ports> portID3 = getChild("c3", "p3");
 551         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID3,
 552                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports3));
 553
 554         InstanceIdentifier<Ports> portID4 = getChild("c4", "p4");
 555         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID4,
 556                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports4));
 557
 558         InstanceIdentifier<Ports> portID5 = getChild("c4", "p5");
 559         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, portID5,
 560                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(ports5));
 561
 562         InstanceIdentifier<Info> infoIID = InstanceIdentifier
 563             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 564             .child(Info.class)
 565             .build();
 566         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, infoIID,
 567                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(info));
 568
 569         // mock 4 circuit packs
 570         CircuitPacks circuitPackObject = getCircuitPacks(portsList, "c1", "pc1");
 571         CircuitPacks circuitPackObject2 = getCircuitPacks(portsList11, "c2", "pc2");
 572         CircuitPacks circuitPackObject3 = getCircuitPacks(portsList2, "c3", "pc3");
 573         CircuitPacks circuitPackObject4 = getCircuitPacks(portsList4, "c4", "pc4");
 574
 575         InstanceIdentifier<CircuitPacks> circuitPacksIID = InstanceIdentifier
 576             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 577             .child(CircuitPacks.class, new CircuitPacksKey("c1"))
 578             .build();
 579         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID,
 580                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 581                         .thenReturn(Optional.of(circuitPackObject));
 582
 583         InstanceIdentifier<CircuitPacks> circuitPacksIID2 = InstanceIdentifier
 584             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 585             .child(CircuitPacks.class, new CircuitPacksKey("c2"))
 586             .build();
 587         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID2,
 588                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 589                         .thenReturn(Optional.of(circuitPackObject2));
 590
 591         InstanceIdentifier<CircuitPacks> circuitPacksIID3 = InstanceIdentifier
 592             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 593             .child(CircuitPacks.class, new CircuitPacksKey("c3"))
 594             .build();
 595         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID3,
 596                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 597                         .thenReturn(Optional.of(circuitPackObject3));
 598
 599         InstanceIdentifier<CircuitPacks> circuitPacksIID4 = InstanceIdentifier
 600             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 601             .child(CircuitPacks.class, new CircuitPacksKey("c4"))
 602             .build();
 603         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, circuitPacksIID4,
 604                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT))
 605                         .thenReturn(Optional.of(circuitPackObject4));
 606
 607         Map<CircuitPacksKey, CircuitPacks> circuitPacksMap = new HashMap<>();
 608         circuitPacksMap.put(circuitPackObject.key(), circuitPackObject);
 609         circuitPacksMap.put(circuitPackObject2.key(), circuitPackObject2);
 610         circuitPacksMap.put(circuitPackObject3.key(), circuitPackObject3);
 611         circuitPacksMap.put(circuitPackObject4.key(), circuitPackObject4);
 612
 613         OrgOpenroadmDevice deviceObject = new OrgOpenroadmDeviceBuilder().setCircuitPacks(circuitPacksMap)
 614                 .setConnectionMap(connectionMapMap).build();
 615         InstanceIdentifier<OrgOpenroadmDevice> deviceIID = InstanceIdentifier
 616             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 617             .build();
 618         when(deviceTransactionManager.getDataFromDevice("node", LogicalDatastoreType.OPERATIONAL, deviceIID,
 619                 Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT)).thenReturn(Optional.of(deviceObject));
 620
 621         // test createMappingData for xpdr node with 2 network + 1 client + unidirectional & bidirectional ports
 622         assertTrue("returns true when create mapping ", portMappingVersion121.createMappingData("node"));
 623
 624         // assert all portmappings have been created for the xpdr node
 625         ReadTransaction rr = dataBroker.newReadOnlyTransaction();
 626         InstanceIdentifier<Network> mappingIID = InstanceIdentifier.create(Network.class);
 627         Network network = new NetworkBuilder().build();
 628         try {
 629             Optional<Network> optionalNetwork = rr.read(LogicalDatastoreType.CONFIGURATION, mappingIID).get();
 630             if (optionalNetwork.isPresent()) {
 631                 network = optionalNetwork.get();
 632             }
 633
 634         } catch (ExecutionException | InterruptedException e) {
 635             LOG.error("Failed to read mapping.", e);
 636             fail();
 637         }
 638         List<String> testMappings = new ArrayList<>(List.of("XPDR1-CLIENT1", "XPDR1-NETWORK5", "XPDR1-NETWORK4",
 639             "XPDR1-NETWORK3", "XPDR1-NETWORK2", "XPDR1-NETWORK1"));
 640         List<String> mappings = new ArrayList<>();
 641         List<Nodes> nodes = new ArrayList<>(network.nonnullNodes().values());
 642         List<Mapping> mappingValues = new ArrayList<>(nodes.get(0).nonnullMapping().values());
 643         for (int i = 0; i < testMappings.size(); i++) {
 644             mappings.add(mappingValues.get(i).getLogicalConnectionPoint());
 645         }
 646         Collections.sort(testMappings);
 647         Collections.sort(mappings);
 648         assertEquals("test mapping are equals to mapping", testMappings, mappings);
 649     }
 650
 651     @NonNull
 652     private InstanceIdentifier<Ports> getChild(String c4, String p5) {
 653         return InstanceIdentifier
 654             .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class)
 655             .child(CircuitPacks.class, new CircuitPacksKey(c4))
 656             .child(Ports.class, new PortsKey(p5))
 657             .build();
 658     }
 659
 660     private ConnectionMap getConnectionMap(List<Destination> destinationList) {
 661         Map<DestinationKey, Destination> destinationMap = new HashMap<>();
 662         for (Destination destination : destinationList) {
 663             destinationMap.put(destination.key(), destination);
 664         }
 665         return new ConnectionMapBuilder().setConnectionMapNumber(Uint32.valueOf(1))
 666                 .setSource(new SourceBuilder().setCircuitPackName("c1").setPortName("p1").build())
 667                 .setDestination(destinationMap).build();
 668     }
 669
 670     private Info getInfo() {
 671         return new InfoBuilder().setNodeNumber(Uint32.valueOf(1)).setClli("clli").setNodeType(NodeTypes.Xpdr)
 672                 .setModel("model").setVendor("vendor").setIpAddress(new IpAddress(new Ipv4Address("10.1.1.1")))
 673                 .setMaxDegrees(Uint16.valueOf(2)).setMaxSrgs(Uint16.valueOf(2)).setNodeId("node").build();
 674     }
 675
 676     private Ports getPorts(String p2, Port.PortQual roadmExternal, String c3, String p3, Direction rx) {
 677         return new PortsBuilder().setPortName(p2).setPortQual(roadmExternal)
 678                 .setPartnerPort(new PartnerPortBuilder().setCircuitPackName(c3).setPortName(p3).build())
 679                 .setPortDirection(rx).build();
 680     }
 681
 682     private ConnectionPorts getConnectionPorts(String c1, String p1) {
 683         return new ConnectionPortsBuilder().setIndex(Uint32.valueOf(ran.nextInt(Integer.MAX_VALUE)))
 684                 .setCircuitPackName(c1).setPortName(p1).build();
 685     }
 686
 687     private CircuitPacks getCircuitPacks(List<Ports> portsList, String c1, String pc1) {
 688         Map<PortsKey, Ports> portsMap = new HashMap<>();
 689         for (Ports ports : portsList) {
 690             portsMap.put(ports.key(), ports);
 691         }
 692         return new CircuitPacksBuilder().setCircuitPackName(c1)
 693                 .setParentCircuitPack(new ParentCircuitPackBuilder().setCircuitPackName(pc1).build()).setPorts(portsMap)
 694                 .build();
 695     }
 696
 697     private Ports getPortsWithInterfaces(List<Interfaces> interfacesList, String p1) {
 698         return new PortsBuilder().setPortName(p1).setPortQual(Port.PortQual.RoadmExternal)
 699                 .setPortDirection(Direction.Bidirectional).setInterfaces(interfacesList).build();
 700     }
 701
 702     private Info getInfo2() {
 703         return new InfoBuilder().setNodeNumber(Uint32.valueOf(1)).setClli("clli").setNodeType(NodeTypes.Rdm)
 704                 .setModel("model").setVendor("vendor").setIpAddress(new IpAddress(new Ipv4Address("10.1.1.1")))
 705                 .setMaxDegrees(Uint16.valueOf(3)).setMaxSrgs(Uint16.valueOf(3)).build();
 706     }
 707
 708     private Interfaces getInterfaces(String i1) {
 709         return new InterfacesBuilder().setInterfaceName(i1).build();
 710     }
 711
 712 }