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