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