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