Unification iNodeEdgePoint_N & NodeEdgePoint_N

- T0 Full Multilayer topo and T0 Multilayer topo have the same
  name and uuid for the NEP in the ODU layer that belongs to
  the DSR/ODU TAPI node
- Name of NEPs in T0 MultiLayer updated to be built the same
  way as in T0 Full MultiLayer

JIRA: TRNSPRTPCE-551
Signed-off-by: errea <errea@eurecom.fr>
Change-Id: I48d218bcc210650a794ecb4cb3a6dcf33b5cc04f

diff --git a/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopo.java b/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopo.java
index ad6106b07a037b7132e54e98149aa6e8bfae7ca6..79b997d2f58a1f73eb8311f3f9efda33c349feae 100644 (file)
--- a/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopo.java
+++ b/tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopo.java
@@ -122,13 +122,13 @@ public class ConvertORTopoToTapiTopo {
         this.ietfNodeType = ietfNode.augmentation(
             org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1.class).getNodeType();
         this.ietfNodeAdminState = ietfNode.augmentation(
-            org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1.class)
+                org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1.class)
             .getAdministrativeState();
         this.ietfNodeOperState = ietfNode.augmentation(
-            org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1.class)
+                org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1.class)
             .getOperationalState();
         this.oorNetworkPortList = ietfNode.augmentation(
-            org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class)
+                org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1.class)
             .getTerminationPoint().values().stream()
             .filter(tp -> tp.augmentation(TerminationPoint1.class).getTpType().getIntValue()
                 == OpenroadmTpType.XPONDERNETWORK.getIntValue()
@@ -165,7 +165,8 @@ public class ConvertORTopoToTapiTopo {
         Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", this.ietfNodeId,
             TapiStringConstants.DSR)).getBytes(Charset.forName("UTF-8"))).toString());
         this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.DSR), nodeUuid);
-        Name nameDsr = new NameBuilder().setValueName("dsr/odu node name").setValue(this.ietfNodeId).build();
+        Name nameDsr = new NameBuilder().setValueName("dsr/odu node name")
+            .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.DSR)).build();
         List<LayerProtocolName> dsrLayerProtocols = Arrays.asList(LayerProtocolName.DSR, LayerProtocolName.ODU);
         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology
             .Node dsrNode = createTapiNode(Map.of(nameDsr.key(), nameDsr), dsrLayerProtocols);
@@ -176,7 +177,8 @@ public class ConvertORTopoToTapiTopo {
         nodeUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", this.ietfNodeId, TapiStringConstants.OTSI))
             .getBytes(Charset.forName("UTF-8"))).toString());
         this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.OTSI), nodeUuid);
-        Name nameOtsi =  new NameBuilder().setValueName("otsi node name").setValue(this.ietfNodeId).build();
+        Name nameOtsi =  new NameBuilder().setValueName("otsi node name")
+            .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.OTSI)).build();
         List<LayerProtocolName> otsiLayerProtocols = Arrays.asList(LayerProtocolName.PHOTONICMEDIA);
         org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology
             .Node otsiNode = createTapiNode(Map.of(nameOtsi.key(), nameOtsi), otsiLayerProtocols);
@@ -311,14 +313,14 @@ public class ConvertORTopoToTapiTopo {
             prunedTapiPhotonicNodes = new ArrayList<>();
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiPhotonicNodes
             = this.tapiNodes.values().stream()
-                .filter(n -> LayerProtocolName.PHOTONICMEDIA.equals(n.getLayerProtocolName().get(0)))
-                .collect(Collectors.toList());
+            .filter(n -> LayerProtocolName.PHOTONICMEDIA.equals(n.getLayerProtocolName().get(0)))
+            .collect(Collectors.toList());
         for (org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node
-                : tapiPhotonicNodes) {
+            : tapiPhotonicNodes) {
             Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepM = new HashMap<>();
             for (Map.Entry<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> entry : node.getOwnedNodeEdgePoint().entrySet()) {
                 if (entry.getValue().getName().values().stream()
-                        .filter(name -> name.getValueName().startsWith("eNodeEdgePoint")).count() > 0) {
+                    .filter(name -> name.getValueName().startsWith("eNodeEdgePoint")).count() > 0) {
                     onepM.put(entry.getKey(), entry.getValue());
                 }
             }
@@ -330,7 +332,7 @@ public class ConvertORTopoToTapiTopo {
     }
 
     private Map<String, String> convertListNodeWithListNepToMapForUuidAndName(
-            List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> nodes) {
+        List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> nodes) {
         Map<String, String> uuidNameMap = new HashMap<>();
         for (org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node : nodes) {
             for (OwnedNodeEdgePoint nep : node.nonnullOwnedNodeEdgePoint().values()) {
@@ -378,20 +380,22 @@ public class ConvertORTopoToTapiTopo {
     }
 
     private Uuid getNodeUuid4Photonic(Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl,
-            Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList, Map<RuleKey, Rule> ruleList) {
+                                      Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList,
+                                      Map<RuleKey, Rule> ruleList) {
         Uuid nodeUuid;
         nodeUuid = this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.OTSI));
         // iNep creation on otsi node
         for (int i = 0; i < oorNetworkPortList.size(); i++) {
             Uuid nepUuid1 = new Uuid(UUID.nameUUIDFromBytes(
-                (String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI,
-                    oorNetworkPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8")))
+                    (String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI,
+                        oorNetworkPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8")))
                 .toString());
             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI,
                 oorNetworkPortList.get(i).getTpId().getValue()), nepUuid1);
             Name onedName = new NameBuilder()
                 .setValueName("iNodeEdgePoint")
-                .setValue(oorNetworkPortList.get(i).getTpId().getValue())
+                .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.I_OTSI,
+                    oorNetworkPortList.get(i).getTpId().getValue()))
                 .build();
 
             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
@@ -402,14 +406,15 @@ public class ConvertORTopoToTapiTopo {
         // eNep creation on otsi node
         for (int i = 0; i < oorNetworkPortList.size(); i++) {
             Uuid nepUuid2 = new Uuid(UUID.nameUUIDFromBytes(
-                (String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI,
-                    oorNetworkPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8")))
+                    (String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI,
+                        oorNetworkPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8")))
                 .toString());
             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI,
                 oorNetworkPortList.get(i).getTpId().getValue()), nepUuid2);
             Name onedName = new NameBuilder()
                 .setValueName("eNodeEdgePoint")
-                .setValue(oorNetworkPortList.get(i).getTpId().getValue())
+                .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.E_OTSI,
+                    oorNetworkPortList.get(i).getTpId().getValue()))
                 .build();
 
             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
@@ -456,7 +461,7 @@ public class ConvertORTopoToTapiTopo {
     }
 
     private Uuid getNodeUuid4Dsr(Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl,
-            Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList, Map<RuleKey, Rule> ruleList) {
+                                 Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList, Map<RuleKey, Rule> ruleList) {
         Uuid nodeUuid;
         nodeUuid = this.uuidMap.get(String.join("+", this.ietfNodeId, TapiStringConstants.DSR));
         // client nep creation on DSR/ODU node
@@ -466,7 +471,8 @@ public class ConvertORTopoToTapiTopo {
                     oorClientPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8"))).toString());
             this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
                 oorClientPortList.get(i).getTpId().getValue()), nepUuid);
-            NameBuilder nameBldr = new NameBuilder().setValue(oorClientPortList.get(i).getTpId().getValue());
+            NameBuilder nameBldr = new NameBuilder().setValue(String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
+                oorClientPortList.get(i).getTpId().getValue()));
             Name name;
             if (OpenroadmNodeType.TPDR.equals(this.ietfNodeType)) {
                 name = nameBldr.setValueName("100G-tpdr").build();
@@ -482,18 +488,19 @@ public class ConvertORTopoToTapiTopo {
         // network nep creation on DSR/ODU node
         for (int i = 0; i < oorNetworkPortList.size(); i++) {
             Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(
-                (String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
+                (String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU,
                     oorNetworkPortList.get(i).getTpId().getValue())).getBytes(Charset.forName("UTF-8"))).toString());
-            this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
+            this.uuidMap.put(String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU,
                 oorNetworkPortList.get(i).getTpId().getValue()), nepUuid);
             Name onedName = new NameBuilder()
-                .setValueName("NodeEdgePoint_N")
-                .setValue(oorNetworkPortList.get(i).getTpId().getValue())
+                .setValueName("iNodeEdgePoint_N")
+                .setValue(String.join("+", this.ietfNodeId, TapiStringConstants.I_ODU,
+                    oorNetworkPortList.get(i).getTpId().getValue()))
                 .build();
 
             OwnedNodeEdgePoint onep = createNep(oorNetworkPortList.get(i), Map.of(onedName.key(), onedName),
                 LayerProtocolName.ODU, LayerProtocolName.DSR, true, String.join("+", this.ietfNodeId,
-                    TapiStringConstants.DSR));
+                    TapiStringConstants.I_ODU));
             onepl.put(onep.key(), onep);
         }
         // create NodeRuleGroup
@@ -504,8 +511,10 @@ public class ConvertORTopoToTapiTopo {
                 nepList = new HashMap<>();
             for (TpId tp : nbl.getTpList()) {
                 if (this.uuidMap.containsKey(String.join("+", this.ietfNodeId, TapiStringConstants.DSR,
-                    tp.getValue()))) {
-
+                        tp.getValue())) || this.uuidMap.containsKey(String.join(
+                    "+", this.ietfNodeId, TapiStringConstants.I_ODU, tp.getValue()))) {
+                    String qual = tp.getValue().contains("CLIENT") ? TapiStringConstants.DSR
+                        : TapiStringConstants.I_ODU;
                     org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePoint
                         nep = new org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group
                         .NodeEdgePointBuilder()
@@ -513,7 +522,7 @@ public class ConvertORTopoToTapiTopo {
                         .setNodeUuid(this.uuidMap.get(String.join("+", this.ietfNodeId,
                             TapiStringConstants.DSR)))
                         .setNodeEdgePointUuid(this.uuidMap.get(String.join("+", this.ietfNodeId,
-                            TapiStringConstants.DSR, tp.getValue())))
+                            qual, tp.getValue())))
                         .build();
                     nepList.put(nep.key(), nep);
                 }
@@ -532,7 +541,8 @@ public class ConvertORTopoToTapiTopo {
     }
 
     private OwnedNodeEdgePoint createNep(TerminationPoint oorTp, Map<NameKey, Name> nepNames,
-            LayerProtocolName nepProtocol, LayerProtocolName nodeProtocol, boolean withSip, String keyword) {
+                                         LayerProtocolName nepProtocol, LayerProtocolName nodeProtocol,
+                                         boolean withSip, String keyword) {
         String key = String.join("+", keyword, oorTp.getTpId().getValue());
         AdministrativeState adminState = (oorTp.augmentation(TerminationPoint1.class).getAdministrativeState() != null)
             ? this.tapiLink.setTapiAdminState(oorTp.augmentation(TerminationPoint1.class).getAdministrativeState()
@@ -585,7 +595,7 @@ public class ConvertORTopoToTapiTopo {
     }
 
     private Map<NodeRuleGroupKey, NodeRuleGroup> createNodeRuleGroupForRdmNode(Uuid nodeUuid,
-            Collection<OwnedNodeEdgePoint> onepl) {
+                                                                               Collection<OwnedNodeEdgePoint> onepl) {
         Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePointKey,
             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.rule.group.NodeEdgePoint>
             nepMap = new HashMap<>();
@@ -618,7 +628,7 @@ public class ConvertORTopoToTapiTopo {
     }
 
     private Map<MappedServiceInterfacePointKey, MappedServiceInterfacePoint> createSIP(int nb, TerminationPoint tp,
-            String nodeId) {
+                                                                                       String nodeId) {
         Map<MappedServiceInterfacePointKey, MappedServiceInterfacePoint> msipl = new HashMap<>();
         for (int i = 0; i < nb; i++) {
             MappedServiceInterfacePoint msip = new MappedServiceInterfacePointBuilder()
@@ -630,12 +640,12 @@ public class ConvertORTopoToTapiTopo {
         return msipl;
     }
 
-    private List<Class<? extends LAYERPROTOCOLQUALIFIER>> createSupportedCepLayerProtocolQualifier(TerminationPoint tp,
-            LayerProtocolName lpn) {
+    private List<Class<? extends LAYERPROTOCOLQUALIFIER>>
+            createSupportedCepLayerProtocolQualifier(TerminationPoint tp, LayerProtocolName lpn) {
         Set<Class<? extends LAYERPROTOCOLQUALIFIER>> sclpqSet = new HashSet<>();
         List<SupportedInterfaceCapability> sicList = new ArrayList<>(
             tp.augmentation(org.opendaylight.yang.gen.v1.http
-                .org.openroadm.otn.network.topology.rev200529.TerminationPoint1.class).getTpSupportedInterfaces()
+                    .org.openroadm.otn.network.topology.rev200529.TerminationPoint1.class).getTpSupportedInterfaces()
                 .getSupportedInterfaceCapability().values());
         for (SupportedInterfaceCapability sic : sicList) {
             switch (lpn.getName()) {
@@ -687,7 +697,7 @@ public class ConvertORTopoToTapiTopo {
         for (TerminationPoint tp : this.oorNetworkPortList) {
             Link transiLink = tapiLink.createTapiLink(this.ietfNodeId, tp.getTpId().getValue(), this.ietfNodeId,
                 tp.getTpId().getValue(), TapiStringConstants.TRANSITIONAL_LINK, TapiStringConstants.DSR,
-                TapiStringConstants.OTSI, TapiStringConstants.DSR, TapiStringConstants.I_OTSI,
+                TapiStringConstants.OTSI, TapiStringConstants.I_ODU, TapiStringConstants.I_OTSI,
                 "inService", "inService", Arrays.asList(LayerProtocolName.ODU,
                     LayerProtocolName.PHOTONICMEDIA),
                 Arrays.asList(LayerProtocolName.ODU.getName(), LayerProtocolName.PHOTONICMEDIA.getName()),
@@ -725,7 +735,7 @@ public class ConvertORTopoToTapiTopo {
             Link omsLink = new LinkBuilder()
                 .setUuid(new Uuid(
                     UUID.nameUUIDFromBytes((String.join(" and ", photonicEntry.getValue(), rdmEntry.getValue()))
-                        .getBytes(Charset.forName("UTF-8")))
+                            .getBytes(Charset.forName("UTF-8")))
                         .toString()))
                 .setName(Map.of(linkName.key(), linkName))
                 .setLayerProtocolName(List.of(LayerProtocolName.PHOTONICMEDIA))

diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopoTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopoTest.java
index 2139135d6ada1ab8294636c39ad0a0dce7856eb2..961bd593b68b3e66456475db74f653f3eb74312f 100644 (file)
--- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopoTest.java
+++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopoTest.java
@@ -115,11 +115,11 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     @BeforeClass
     public static void setUp() throws InterruptedException, ExecutionException {
         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
-                TapiTopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II);
+            TapiTopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II);
         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
-                TapiTopologyDataUtils.OTN_TOPOLOGY_FILE, InstanceIdentifiers.OTN_NETWORK_II);
+            TapiTopologyDataUtils.OTN_TOPOLOGY_FILE, InstanceIdentifiers.OTN_NETWORK_II);
         TopologyDataUtils.writePortmappingFromFileToDatastore(getDataStoreContextUtil(),
-                TapiTopologyDataUtils.PORTMAPPING_FILE);
+            TapiTopologyDataUtils.PORTMAPPING_FILE);
 
         KeyedInstanceIdentifier<Node, NodeKey> muxAIID = InstanceIdentifier.create(Networks.class)
             .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network
@@ -186,8 +186,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
             .getTapiNodes().get(new
                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(dsrNodeUuid));
         Uuid networkNepUuid = new Uuid(
-            UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+DSR+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-            .toString());
+            UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
+                .toString());
         OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid));
         assertNull("Administrative State should not be present", nepN.getAdministrativeState());
         assertNull("Operational State should not be present", nepN.getOperationalState());
@@ -199,10 +199,10 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(otsiNodeUuid));
         Uuid enepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-            .toString());
+                .toString());
         Uuid inepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-            .toString());
+                .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));
         assertNull("Administrative State should not be present", enep.getAdministrativeState());
         assertNull("Operational State should not be present", enep.getOperationalState());
@@ -231,8 +231,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
             .getTapiNodes().get(new
                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(dsrNodeUuid));
         Uuid networkNepUuid = new Uuid(
-            UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+DSR+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-            .toString());
+            UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
+                .toString());
         OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid));
         assertEquals("Administrative State should be Locked",
             AdministrativeState.LOCKED, nepN.getAdministrativeState());
@@ -246,10 +246,10 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(otsiNodeUuid));
         Uuid enepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-            .toString());
+                .toString());
         Uuid inepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-            .toString());
+                .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));
         assertEquals("Administrative State should be Locked",
             AdministrativeState.LOCKED, enep.getAdministrativeState());
@@ -282,8 +282,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
             .getTapiNodes().get(new
                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(dsrNodeUuid));
         Uuid networkNepUuid = new Uuid(
-            UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+DSR+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-            .toString());
+            UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
+                .toString());
         OwnedNodeEdgePoint nepN = dsrNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(networkNepUuid));
         assertEquals("Administrative State should be Locked",
             AdministrativeState.LOCKED, nepN.getAdministrativeState());
@@ -297,10 +297,10 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey(otsiNodeUuid));
         Uuid enepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-            .toString());
+                .toString());
         Uuid inepUuid = new Uuid(
             UUID.nameUUIDFromBytes(("XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-            .toString());
+                .toString());
         OwnedNodeEdgePoint enep = otsiNode.nonnullOwnedNodeEdgePoint().get(new OwnedNodeEdgePointKey(enepUuid));
         assertEquals("Administrative State should be Locked",
             AdministrativeState.LOCKED, enep.getAdministrativeState());
@@ -528,16 +528,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
 
         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());
-        checkDsrNode(tapiNodes.get(1), dsrNodeUuid, "tpdr", "XPDR-A1-XPDR1");
+        checkDsrNode(tapiNodes.get(1), dsrNodeUuid, "tpdr", "XPDR-A1-XPDR1+DSR");
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("XPDR-A1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());
-        checkOtsiNode(tapiNodes.get(0), otsiNodeUuid, "tpdr", "XPDR-A1-XPDR1");
+        checkOtsiNode(tapiNodes.get(0), otsiNodeUuid, "tpdr", "XPDR-A1-XPDR1+OTSi");
 
         List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
             .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
             .collect(Collectors.toList());
-        checkTransitionalLink(tapiLinks.get(0), dsrNodeUuid, otsiNodeUuid,
-            "XPDR-A1-XPDR1+DSR+XPDR1-NETWORK1", "XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1", "XPDR-A1-XPDR1");
+        checkTransitionalLink(tapiLinks.get(1), dsrNodeUuid, otsiNodeUuid,
+            "XPDR-A1-XPDR1+iODU+XPDR1-NETWORK1", "XPDR-A1-XPDR1+iOTSi+XPDR1-NETWORK1", "XPDR-A1-XPDR1");
     }
 
     @Test
@@ -559,16 +559,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         assertEquals("Link list size should be 1", 1, tapiFactory.getTapiLinks().size());
         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());
-        checkDsrNode(tapiNodes.get(0), dsrNodeUuid, "mux", "SPDR-SA1-XPDR1");
+        checkDsrNode(tapiNodes.get(0), dsrNodeUuid, "mux", "SPDR-SA1-XPDR1+DSR");
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());
-        checkOtsiNode(tapiNodes.get(1), otsiNodeUuid, "mux", "SPDR-SA1-XPDR1");
+        checkOtsiNode(tapiNodes.get(1), otsiNodeUuid, "mux", "SPDR-SA1-XPDR1+OTSi");
 
         List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
             .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
             .collect(Collectors.toList());
         checkTransitionalLink(tapiLinks.get(0), dsrNodeUuid, otsiNodeUuid,
-            "SPDR-SA1-XPDR1+DSR+XPDR1-NETWORK1", "SPDR-SA1-XPDR1+iOTSi+XPDR1-NETWORK1", "SPDR-SA1-XPDR1");
+            "SPDR-SA1-XPDR1+iODU+XPDR1-NETWORK1", "SPDR-SA1-XPDR1+iOTSi+XPDR1-NETWORK1", "SPDR-SA1-XPDR1");
     }
 
     @Test
@@ -591,16 +591,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
 
         Uuid dsrNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR2+DSR".getBytes(Charset.forName("UTF-8")))
             .toString());
-        checkDsrNode(tapiNodes.get(0), dsrNodeUuid, "switch", "SPDR-SA1-XPDR2");
+        checkDsrNode(tapiNodes.get(0), dsrNodeUuid, "switch", "SPDR-SA1-XPDR2+DSR");
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR2+OTSi".getBytes(Charset.forName("UTF-8")))
             .toString());
-        checkOtsiNode(tapiNodes.get(1), otsiNodeUuid, "switch", "SPDR-SA1-XPDR2");
+        checkOtsiNode(tapiNodes.get(1), otsiNodeUuid, "switch", "SPDR-SA1-XPDR2+OTSi");
 
         List<Link> tapiLinks = tapiFactory.getTapiLinks().values().stream()
             .sorted((l1, l2) -> l1.getUuid().getValue().compareTo(l2.getUuid().getValue()))
             .collect(Collectors.toList());
-        checkTransitionalLink(tapiLinks.get(3), dsrNodeUuid, otsiNodeUuid,
-            "SPDR-SA1-XPDR2+DSR+XPDR2-NETWORK4", "SPDR-SA1-XPDR2+iOTSi+XPDR2-NETWORK4", "SPDR-SA1-XPDR2");
+        checkTransitionalLink(tapiLinks.get(2), dsrNodeUuid, otsiNodeUuid,
+            "SPDR-SA1-XPDR2+iODU+XPDR2-NETWORK4", "SPDR-SA1-XPDR2+iOTSi+XPDR2-NETWORK4", "SPDR-SA1-XPDR2");
     }
 
     @Test
@@ -685,8 +685,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         assertEquals("Link list size should be 2", 2, tapiFactory.getTapiLinks().size());
         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> tapiNodes
             = tapiFactory.getTapiNodes().values().stream()
-                .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
-                .collect(Collectors.toList());
+            .sorted((n1, n2) -> n1.getUuid().getValue().compareTo(n2.getUuid().getValue()))
+            .collect(Collectors.toList());
         Uuid otsiNodeUuid = new Uuid(UUID.nameUUIDFromBytes("ROADM-infra".getBytes(Charset.forName("UTF-8")))
             .toString());
         checkOtsiNode(tapiNodes.get(2), otsiNodeUuid, "infra", "ROADM-infra");
@@ -703,14 +703,15 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         Uuid tp2Uuid = new Uuid(UUID.nameUUIDFromBytes(("roadm node+nep+1")
             .getBytes(Charset.forName("UTF-8"))).toString());
         Uuid linkUuid =
-            new Uuid(UUID.nameUUIDFromBytes("SPDR-SA1-XPDR1--XPDR1-NETWORK1 and ROADM-infra--NodeEdgePoint_1"
-                .getBytes(Charset.forName("UTF-8"))).toString());
-        checkOmsLink(links.get(0), node1Uuid, node2Uuid, tp1Uuid, tp2Uuid, linkUuid,
-            "SPDR-SA1-XPDR1--XPDR1-NETWORK1 and ROADM-infra--NodeEdgePoint_1");
+            new Uuid(UUID.nameUUIDFromBytes(
+                "SPDR-SA1-XPDR1+OTSi--SPDR-SA1-XPDR1+eOTSi+XPDR1-NETWORK1 and ROADM-infra--NodeEdgePoint_1"
+                    .getBytes(Charset.forName("UTF-8"))).toString());
+        checkOmsLink(links.get(1), node1Uuid, node2Uuid, tp1Uuid, tp2Uuid, linkUuid,
+            "SPDR-SA1-XPDR1+OTSi--SPDR-SA1-XPDR1+eOTSi+XPDR1-NETWORK1 and ROADM-infra--NodeEdgePoint_1");
     }
 
     private void checkDsrNode(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node,
-        Uuid nodeUuid, String dsrNodeType, String nodeId) {
+                              Uuid nodeUuid, String dsrNodeType, String nodeId) {
         assertEquals("incorrect node uuid", nodeUuid, node.getUuid());
         assertEquals("incorrect node name", nodeId, node.getName().get(new NameKey("dsr/odu node name")).getValue());
         assertEquals("administrative state should be UNLOCKED",
@@ -718,13 +719,13 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState());
         assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState());
         assertEquals("value-name should be 'dsr/odu node name'",
-             "dsr/odu node name", node.nonnullName().values().stream().findFirst().get().getValueName());
+            "dsr/odu node name", node.nonnullName().values().stream().findFirst().get().getValueName());
         assertEquals("dsr node should manage 2 protocol layers : dsr and odu",
             2, node.getLayerProtocolName().size());
         assertThat("dsr node should manage 2 protocol layers : dsr and odu",
             node.getLayerProtocolName(), hasItems(LayerProtocolName.DSR, LayerProtocolName.ODU));
         List<OwnedNodeEdgePoint> nepsN = node.nonnullOwnedNodeEdgePoint().values().stream()
-            .filter(n -> n.getName().containsKey(new NameKey("NodeEdgePoint_N")))
+            .filter(n -> n.getName().containsKey(new NameKey("iNodeEdgePoint_N")))
             .sorted((nep1, nep2) -> nep1.getUuid().getValue().compareTo(nep2.getUuid().getValue()))
             .collect(Collectors.toList());
         List<OwnedNodeEdgePoint> nepsC;
@@ -738,16 +739,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
                 assertEquals("Switch-DSR node should have 4 NEPs client", 4, nepsC.size());
                 OwnedNodeEdgePoint nep1 = nepsC.get(2);
                 Uuid client4NepUuid = new Uuid(
-                        UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR2-CLIENT4").getBytes(Charset.forName("UTF-8")))
-                        .toString());
+                    UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+DSR+XPDR2-CLIENT4")
+                        .getBytes(Charset.forName("UTF-8"))).toString());
                 checkNepClient100GSwitch(nep1, client4NepUuid, "XPDR2-CLIENT4", "NodeEdgePoint_C",
                     otnSwitch.getNodeId().getValue(), TapiStringConstants.DSR);
-                OwnedNodeEdgePoint nep2 = nepsN.get(1);
+                OwnedNodeEdgePoint nep2 = nepsN.get(3);
                 Uuid networkNepUuid = new Uuid(
-                        UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR2-NETWORK1").getBytes(Charset.forName("UTF-8")))
-                        .toString());
-                checkNepNetworkODU4(nep2, networkNepUuid, "XPDR2-NETWORK1", "NodeEdgePoint_N",
-                    otnSwitch.getNodeId().getValue(), TapiStringConstants.DSR);
+                    UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+iODU+XPDR2-NETWORK1")
+                        .getBytes(Charset.forName("UTF-8"))).toString());
+                checkNepNetworkODU4(nep2, networkNepUuid, "XPDR2-NETWORK1", "iNodeEdgePoint_N",
+                    otnSwitch.getNodeId().getValue(), TapiStringConstants.I_ODU);
                 List<NodeRuleGroup> nrgList = node.nonnullNodeRuleGroup().values().stream()
                     .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
                     .collect(Collectors.toList());
@@ -762,17 +763,17 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
                 assertEquals("Mux-DSR node should have 4 NEPs client", 4, nepsC.size());
                 OwnedNodeEdgePoint nep3 = nepsC.get(2);
                 Uuid client3NepUuid = new Uuid(
-                        UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-CLIENT3").getBytes(Charset.forName("UTF-8")))
-                        .toString());
+                    UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+DSR+XPDR1-CLIENT3")
+                        .getBytes(Charset.forName("UTF-8"))).toString());
                 checkNepClient10G(nep3, client3NepUuid, "XPDR1-CLIENT3", "NodeEdgePoint_C",
                     otnMuxA.getNodeId().getValue(), TapiStringConstants.DSR);
 
                 OwnedNodeEdgePoint nep4 = nepsN.get(0);
                 Uuid networkNepUuid2 = new Uuid(
-                        UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-                        .toString());
-                checkNepNetworkODU4(nep4, networkNepUuid2, "XPDR1-NETWORK1", "NodeEdgePoint_N",
-                    otnMuxA.getNodeId().getValue(), TapiStringConstants.DSR);
+                    UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+iODU+XPDR1-NETWORK1")
+                        .getBytes(Charset.forName("UTF-8"))).toString());
+                checkNepNetworkODU4(nep4, networkNepUuid2, "XPDR1-NETWORK1", "iNodeEdgePoint_N",
+                    otnMuxA.getNodeId().getValue(), TapiStringConstants.I_ODU);
                 List<NodeRuleGroup> nrgList2 = node.nonnullNodeRuleGroup().values().stream()
                     .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
                     .collect(Collectors.toList());
@@ -787,17 +788,17 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
                 assertEquals("Tpdr-DSR node should have 2 NEPs client", 2, nepsC.size());
                 OwnedNodeEdgePoint nep5 = nepsC.get(0);
                 Uuid client1NepUuid = new Uuid(
-                        UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-CLIENT1").getBytes(Charset.forName("UTF-8")))
-                        .toString());
+                    UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+DSR+XPDR1-CLIENT1")
+                        .getBytes(Charset.forName("UTF-8"))).toString());
                 checkNepClient100GTpdr(nep5, client1NepUuid, "XPDR1-CLIENT1", "100G-tpdr",
                     tpdr100G.getNodeId().getValue(), TapiStringConstants.DSR);
 
-                OwnedNodeEdgePoint nep6 = nepsN.get(0);
+                OwnedNodeEdgePoint nep6 = nepsN.get(1);
                 Uuid networkNepUuid3 = new Uuid(
-                        UUID.nameUUIDFromBytes((nodeId + "+DSR+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-                        .toString());
-                checkNepNetworkODU4(nep6, networkNepUuid3, "XPDR1-NETWORK1", "NodeEdgePoint_N",
-                    tpdr100G.getNodeId().getValue(), TapiStringConstants.DSR);
+                    UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+iODU+XPDR1-NETWORK1")
+                        .getBytes(Charset.forName("UTF-8"))).toString());
+                checkNepNetworkODU4(nep6, networkNepUuid3, "XPDR1-NETWORK1", "iNodeEdgePoint_N",
+                    tpdr100G.getNodeId().getValue(), TapiStringConstants.I_ODU);
                 List<NodeRuleGroup> nrgList3 = node.nonnullNodeRuleGroup().values().stream()
                     .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
                     .collect(Collectors.toList());
@@ -810,7 +811,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     private void checkOtsiNode(
-            org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node,
+        org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node node,
         Uuid nodeUuid, String otsiNodeType, String nodeId) {
         assertEquals("incorrect node uuid", nodeUuid, node.getUuid());
         assertEquals("incorrect node name", nodeId, node.getName().get(new NameKey("otsi node name")).getValue());
@@ -819,7 +820,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         assertEquals("life-cycle state should be INSTALLED", LifecycleState.INSTALLED, node.getLifecycleState());
         assertEquals("operational state should be ENABLED", OperationalState.ENABLED, node.getOperationalState());
         assertEquals("value-name should be 'dsr/odu node name'",
-             "otsi node name", node.nonnullName().values().stream().findFirst().get().getValueName());
+            "otsi node name", node.nonnullName().values().stream().findFirst().get().getValueName());
         assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA",
             1, node.getLayerProtocolName().size());
         assertEquals("otsi node should manage a single protocol layer : PHOTONIC_MEDIA",
@@ -838,16 +839,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
                 assertEquals("Switch-OTSi node should have 4 iNEPs", 4, nepsI.size());
                 OwnedNodeEdgePoint nep1 = nepsI.get(1);
                 Uuid inepUuid = new Uuid(
-                        UUID.nameUUIDFromBytes((nodeId + "+iOTSi+XPDR2-NETWORK2").getBytes(Charset.forName("UTF-8")))
-                        .toString());
-                checkNepOtsiNode(nep1, inepUuid, "XPDR2-NETWORK2", "iNodeEdgePoint", otnSwitch.getNodeId().getValue(),
-                    TapiStringConstants.I_OTSI);
+                    UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+iOTSi+XPDR2-NETWORK2")
+                        .getBytes(Charset.forName("UTF-8"))).toString());
+                checkNepOtsiNode(nep1, inepUuid, "XPDR2-NETWORK2", "iNodeEdgePoint",
+                    otnSwitch.getNodeId().getValue(), TapiStringConstants.I_OTSI);
                 OwnedNodeEdgePoint nep2 = nepsE.get(0);
                 Uuid enepUuid = new Uuid(
-                        UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR2-NETWORK2").getBytes(Charset.forName("UTF-8")))
-                        .toString());
-                checkNepOtsiNode(nep2, enepUuid, "XPDR2-NETWORK2", "eNodeEdgePoint", otnSwitch.getNodeId().getValue(),
-                    TapiStringConstants.E_OTSI);
+                    UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+eOTSi+XPDR2-NETWORK2")
+                        .getBytes(Charset.forName("UTF-8"))).toString());
+                checkNepOtsiNode(nep2, enepUuid, "XPDR2-NETWORK2", "eNodeEdgePoint",
+                    otnSwitch.getNodeId().getValue(), TapiStringConstants.E_OTSI);
                 List<NodeRuleGroup> nrgList = node.nonnullNodeRuleGroup().values().stream()
                     .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
                     .collect(Collectors.toList());
@@ -858,16 +859,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
                 assertEquals("Mux-OTSi node should have 1 iNEPs", 1, nepsI.size());
                 OwnedNodeEdgePoint nep3 = nepsE.get(0);
                 Uuid enepUuid2 = new Uuid(
-                        UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-                        .toString());
-                checkNepOtsiNode(nep3, enepUuid2, "XPDR1-NETWORK1", "eNodeEdgePoint", otnMuxA.getNodeId().getValue(),
-                    TapiStringConstants.E_OTSI);
+                    UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+eOTSi+XPDR1-NETWORK1")
+                        .getBytes(Charset.forName("UTF-8"))).toString());
+                checkNepOtsiNode(nep3, enepUuid2, "XPDR1-NETWORK1", "eNodeEdgePoint",
+                    otnMuxA.getNodeId().getValue(), TapiStringConstants.E_OTSI);
                 OwnedNodeEdgePoint nep4 = nepsI.get(0);
                 Uuid inepUuid2 = new Uuid(
-                        UUID.nameUUIDFromBytes((nodeId + "+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-                        .toString());
-                checkNepOtsiNode(nep4, inepUuid2, "XPDR1-NETWORK1", "iNodeEdgePoint", otnMuxA.getNodeId().getValue(),
-                    TapiStringConstants.I_OTSI);
+                    UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+iOTSi+XPDR1-NETWORK1")
+                        .getBytes(Charset.forName("UTF-8"))).toString());
+                checkNepOtsiNode(nep4, inepUuid2, "XPDR1-NETWORK1", "iNodeEdgePoint",
+                    otnMuxA.getNodeId().getValue(), TapiStringConstants.I_OTSI);
                 List<NodeRuleGroup> nrgList2 = node.nonnullNodeRuleGroup().values().stream()
                     .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
                     .collect(Collectors.toList());
@@ -878,16 +879,16 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
                 assertEquals("Tpdr-OTSi node should have 2 iNEPs", 2, nepsI.size());
                 OwnedNodeEdgePoint nep5 = nepsE.get(0);
                 Uuid enepUuid3 = new Uuid(
-                        UUID.nameUUIDFromBytes((nodeId + "+eOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-                        .toString());
-                checkNepOtsiNode(nep5, enepUuid3, "XPDR1-NETWORK1", "eNodeEdgePoint", tpdr100G.getNodeId().getValue(),
-                    TapiStringConstants.E_OTSI);
+                    UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+eOTSi+XPDR1-NETWORK1")
+                        .getBytes(Charset.forName("UTF-8"))).toString());
+                checkNepOtsiNode(nep5, enepUuid3, "XPDR1-NETWORK1", "eNodeEdgePoint",
+                    tpdr100G.getNodeId().getValue(), TapiStringConstants.E_OTSI);
                 OwnedNodeEdgePoint nep6 = nepsI.get(0);
                 Uuid inepUuid3 = new Uuid(
-                        UUID.nameUUIDFromBytes((nodeId + "+iOTSi+XPDR1-NETWORK1").getBytes(Charset.forName("UTF-8")))
-                        .toString());
-                checkNepOtsiNode(nep6, inepUuid3, "XPDR1-NETWORK1", "iNodeEdgePoint", tpdr100G.getNodeId().getValue(),
-                    TapiStringConstants.I_OTSI);
+                    UUID.nameUUIDFromBytes((nodeId.split("\\+")[0] + "+iOTSi+XPDR1-NETWORK1")
+                        .getBytes(Charset.forName("UTF-8"))).toString());
+                checkNepOtsiNode(nep6, inepUuid3, "XPDR1-NETWORK1", "iNodeEdgePoint",
+                    tpdr100G.getNodeId().getValue(), TapiStringConstants.I_OTSI);
                 List<NodeRuleGroup> nrgList3 = node.nonnullNodeRuleGroup().values().stream()
                     .sorted((nrg1, nrg2) -> nrg1.getUuid().getValue().compareTo(nrg2.getUuid().getValue()))
                     .collect(Collectors.toList());
@@ -914,12 +915,12 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     private void checkNepClient10G(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
-            String nodeId, String extension) {
+                                   String nodeId, String extension) {
         assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         Name name = nameList.get(0);
         assertEquals("value of client nep should be '" + portName + "'",
-            portName, name.getValue());
+            String.join("+", nodeId, extension, portName), name.getValue());
         assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'",
             nepName, name.getValueName());
         assertEquals("Client nep should support 3 kind of cep",
@@ -933,12 +934,12 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     private void checkNepNetworkODU4(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
-            String nodeId, String extension) {
+                                     String nodeId, String extension) {
         assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         Name name = nameList.get(0);
         assertEquals("value of network nep should be '" + portName + "'",
-            portName, name.getValue());
+            String.join("+", nodeId, extension, portName), name.getValue());
         assertEquals("value-name of network nep for '" + portName + "' should be '" + nepName + "'",
             nepName, name.getValueName());
         assertEquals("Network nep should support 1 kind of cep",
@@ -952,7 +953,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     private void checkNodeRuleGroupForTpdrDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
-        Uuid nodeUuid) {
+                                              Uuid nodeUuid) {
         assertEquals("transponder DSR should contain 2 node rule group", 2, nrgList.size());
         for (NodeRuleGroup nodeRuleGroup : nrgList) {
             assertEquals("each node-rule-group should contain 2 NEP for transponder DSR",
@@ -980,7 +981,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     private void checkNodeRuleGroupForMuxDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
-        Uuid nodeUuid) {
+                                             Uuid nodeUuid) {
         assertEquals("muxponder DSR should contain 4 node rule group", 4, nrgList.size());
         for (NodeRuleGroup nodeRuleGroup : nrgList) {
             assertEquals("each node-rule-group should contain 2 NEP for muxponder DSR",
@@ -1008,17 +1009,17 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     private void checkNodeRuleGroupForSwitchDSR(List<NodeRuleGroup> nrgList, Uuid clientNepUuid, Uuid networkNepUuid,
-        Uuid nodeUuid) {
+                                                Uuid nodeUuid) {
         assertEquals("Switch-DSR should contain a single node rule group", 1, nrgList.size());
         assertEquals("Switch-DSR node-rule-group should contain 8 NEP", 8, nrgList.get(0).getNodeEdgePoint().size());
         List<NodeEdgePoint> nrg = nrgList.get(0).nonnullNodeEdgePoint().values().stream()
             .sorted((nrg1, nrg2) -> nrg1.getNodeEdgePointUuid().getValue()
                 .compareTo(nrg2.getNodeEdgePointUuid().getValue()))
             .collect(Collectors.toList());
-        assertEquals("in the sorted node-rule-group, nep number 2 should be XPDR2-NETWORK1",
-            networkNepUuid, nrg.get(4).getNodeEdgePointUuid());
+        assertEquals("in the sorted node-rule-group, nep number 7 should be XPDR2-NETWORK1",
+            networkNepUuid, nrg.get(6).getNodeEdgePointUuid());
         assertEquals("in the sorted node-rule-group, nep number 6 should be XPDR2-CLIENT4",
-            clientNepUuid, nrg.get(3).getNodeEdgePointUuid());
+            clientNepUuid, nrg.get(5).getNodeEdgePointUuid());
         assertEquals("any item of the node-rule-group should have the same nodeUuid",
             nodeUuid, nrg.get(4).getNodeUuid());
         assertEquals("any item of the node-rule-group should have the same nodeUuid",
@@ -1054,7 +1055,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     private void checkNodeRuleGroupForTpdrOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
-        Uuid nodeUuid) {
+                                               Uuid nodeUuid) {
         assertEquals("Tpdr-OTSi should contain two node rule groups", 2, nrgList.size());
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
         assertEquals("Tpdr-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size());
@@ -1079,7 +1080,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     private void checkNodeRuleGroupForMuxOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
-        Uuid nodeUuid) {
+                                              Uuid nodeUuid) {
         assertEquals("Mux-OTSi should contain a single node rule group", 1, nrgList.size());
         List<NodeEdgePoint> nodeEdgePointList = new ArrayList<>(nrgList.get(0).getNodeEdgePoint().values());
         assertEquals("Mux-OTSi node-rule-group should contain 2 NEP", 2, nodeEdgePointList.size());
@@ -1104,7 +1105,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     private void checkNodeRuleGroupForSwitchOTSi(List<NodeRuleGroup> nrgList, Uuid enepUuid, Uuid inepUuid,
-        Uuid nodeUuid) {
+                                                 Uuid nodeUuid) {
         assertEquals("Switch-OTSi should contain 4 node rule group", 4, nrgList.size());
         for (NodeRuleGroup nodeRuleGroup : nrgList) {
             assertEquals("each node-rule-group should contain 2 NEP for Switch-OTSi",
@@ -1133,11 +1134,11 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     private void checkNepClient100GSwitch(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
-            String nodeId, String extension) {
+                                          String nodeId, String extension) {
         assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         assertEquals("value of client nep should be '" + portName + "'",
-            portName, nameList.get(0).getValue());
+            String.join("+", nodeId, extension, portName), nameList.get(0).getValue());
         assertEquals("value-name of client nep for '" + portName + "' should be '" + nepName + "'",
             nepName, nameList.get(0).getValueName());
         assertEquals("Client nep should support 2 kind of cep",
@@ -1151,11 +1152,11 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     private void checkNepClient100GTpdr(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
-            String nodeId, String extension) {
+                                        String nodeId, String extension) {
         assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         assertEquals("value of client nep should be '" + portName + "'",
-            portName, nameList.get(0).getValue());
+            String.join("+", nodeId, extension, portName), nameList.get(0).getValue());
         assertEquals("value-name of client nep for '" + portName + "' should be 100G-tpdr'",
             nepName, nameList.get(0).getValueName());
         assertEquals("Client nep should support 1 kind of cep",
@@ -1169,11 +1170,11 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     private void checkNepOtsiNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName,
-            String nodeId, String extension) {
+                                  String nodeId, String extension) {
         assertEquals("bad uuid for " + portName, nepUuid, nep.getUuid());
         List<Name> nameList = new ArrayList<>(nep.nonnullName().values());
         assertEquals("value of OTSi nep should be '" + portName + "'",
-            portName, nameList.get(0).getValue());
+            String.join("+", nodeId, extension, portName), nameList.get(0).getValue());
         assertEquals("value-name of OTSi nep should be '" + nepName + "'",
             nepName, nameList.get(0).getValueName());
         assertEquals("OTSi nep should support 2 kind of cep",
@@ -1192,8 +1193,8 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         Uuid sipUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "SIP", nodeId, extension, portName))
             .getBytes(Charset.forName("UTF-8"))).toString());
         assertEquals("service-interface-point-uuid of network nep for '" + portName + "' should be '"
-            + String.join("+", "SIP", nodeId, portName) + "'", sipUuid, nep.getMappedServiceInterfacePoint()
-                .get(new MappedServiceInterfacePointKey(sipUuid)).getServiceInterfacePointUuid());
+            + String.join("+", "SIP", portName) + "'", sipUuid, nep.getMappedServiceInterfacePoint()
+            .get(new MappedServiceInterfacePointKey(sipUuid)).getServiceInterfacePointUuid());
     }
 
     private void checkNepOtsiRdmNode(OwnedNodeEdgePoint nep, Uuid nepUuid, String portName, String nepName) {
@@ -1323,7 +1324,7 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     }
 
     private void checkOmsLink(Link link, Uuid node1Uuid, Uuid node2Uuid, Uuid tp1Uuid, Uuid tp2Uuid, Uuid linkUuid,
-        String linkName) {
+                              String linkName) {
         assertEquals("bad name for the link", linkName, link.getName().get(new NameKey("OMS link name")).getValue());
         assertEquals("bad uuid for link", linkUuid, link.getUuid());
         assertEquals("oms link should be between 2 nodes of protocol layers PHOTONIC_MEDIA",
@@ -1354,10 +1355,10 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
     private Node changeTerminationPointState(Node initialNode, String tpid, AdminStates admin, State oper) {
         org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder tpdr1Bldr
             = new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1Builder(
-                initialNode.augmentation(Node1.class));
+            initialNode.augmentation(Node1.class));
         Map<TerminationPointKey, TerminationPoint> tps = new HashMap<>(tpdr1Bldr.getTerminationPoint());
         TerminationPointBuilder tpBldr = new TerminationPointBuilder(
-                tps.get(new TerminationPointKey(new TpId(tpid))));
+            tps.get(new TerminationPointKey(new TpId(tpid))));
         TerminationPoint1Builder tp1Bldr = new TerminationPoint1Builder(tpBldr.augmentation(TerminationPoint1.class));
         tp1Bldr.setAdministrativeState(admin)
             .setOperationalState(oper);
@@ -1382,4 +1383,4 @@ public class ConvertORTopoToTapiTopoTest extends AbstractTest {
         linkBldr.addAugmentation(link1Bldr.build());
         return linkBldr.build();
     }
-}
+}
\ No newline at end of file

diff --git a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java
index 9f9c0e2c787e3423abf550dc0a46980e9486cb3e..47e64ec0adafb13909d4e41cac4633b194438b83 100644 (file)
--- a/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java
+++ b/tapi/src/test/java/org/opendaylight/transportpce/tapi/topology/TapiTopologyImplTest.java
@@ -98,15 +98,15 @@ public class TapiTopologyImplTest extends AbstractTest {
         executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(NUM_THREADS));
         endSignal = new CountDownLatch(1);
         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
-                TapiTopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II);
+            TapiTopologyDataUtils.OPENROADM_TOPOLOGY_FILE, InstanceIdentifiers.OVERLAY_NETWORK_II);
         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
-                TapiTopologyDataUtils.OPENROADM_NETWORK_FILE, InstanceIdentifiers.UNDERLAY_NETWORK_II);
+            TapiTopologyDataUtils.OPENROADM_NETWORK_FILE, InstanceIdentifiers.UNDERLAY_NETWORK_II);
         TopologyDataUtils.writeTopologyFromFileToDatastore(getDataStoreContextUtil(),
-                TapiTopologyDataUtils.OTN_TOPOLOGY_FILE, InstanceIdentifiers.OTN_NETWORK_II);
+            TapiTopologyDataUtils.OTN_TOPOLOGY_FILE, InstanceIdentifiers.OTN_NETWORK_II);
         TopologyDataUtils.writePortmappingFromFileToDatastore(getDataStoreContextUtil(),
-                TapiTopologyDataUtils.PORTMAPPING_FILE);
+            TapiTopologyDataUtils.PORTMAPPING_FILE);
         networkTransactionService = new NetworkTransactionImpl(
-                new RequestProcessor(getDataStoreContextUtil().getDataBroker()));
+            new RequestProcessor(getDataStoreContextUtil().getDataBroker()));
         tapiLink = new TapiLink(networkTransactionService);
         serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(getDataStoreContextUtil().getDataBroker());
         tapiContext = new TapiContext(networkTransactionService);
@@ -114,7 +114,7 @@ public class TapiTopologyImplTest extends AbstractTest {
             tapiLink);
         connectivityUtils = new ConnectivityUtils(serviceDataStoreOperations, new HashMap<>(), tapiContext);
         tapiInitialORMapping = new TapiInitialORMapping(topologyUtils, connectivityUtils,
-                tapiContext, serviceDataStoreOperations);
+            tapiContext, serviceDataStoreOperations);
         tapiInitialORMapping.performTopoInitialMapping();
         LOG.info("setup done");
     }
@@ -186,37 +186,37 @@ public class TapiTopologyImplTest extends AbstractTest {
         assertEquals("Node list size should be 13", 13, topology.getNode().size());
         long nb1 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
-            .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1"))
+            .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("XPDR-A1-XPDR1+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("100G-tpdr"))))
             .count();
         assertEquals("XPDR-A1-XPDR1 should only have one client nep", 1, nb1);
         long nb2 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
-            .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1"))
+            .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C"))))
             .count();
         assertEquals("SPDR-SA1-XPDR1 (mux) should have 4 client neps", 4, nb2);
         long nb3 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
-            .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1"))
+            .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR1+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
-                .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_N"))))
+                .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
             .count();
         assertEquals("SPDR-SA1-XPDR1 (mux) should have a single network nep", 1, nb3);
         long nb4 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
-            .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2"))
+            .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
                 .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_C"))))
             .count();
         assertEquals("SPDR-SA1-XPDR2 (switch) should have 4 client neps", 4, nb4);
         long nb5 = topology.getNode().values().stream()
             .filter(node -> node.getLayerProtocolName().contains(LayerProtocolName.DSR))
-            .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2"))
+            .filter(node -> node.getName().values().stream().findFirst().get().getValue().equals("SPDR-SA1-XPDR2+DSR"))
             .flatMap(node -> node.getOwnedNodeEdgePoint().values().stream()
-                .filter(nep -> nep.getName().containsKey(new NameKey("NodeEdgePoint_N"))))
+                .filter(nep -> nep.getName().containsKey(new NameKey("iNodeEdgePoint_N"))))
             .count();
         assertEquals("SPDR-SA1-XPDR2 (switch) should have 2 network neps", 2, nb5);
         assertEquals("Link list size should be 18", 18, topology.getLink().size());
@@ -559,7 +559,7 @@ public class TapiTopologyImplTest extends AbstractTest {
                 RpcResult<GetNodeEdgePointDetailsOutput> rpcResult2 = result2.get();
                 org.opendaylight.yang.gen.v1
                     .urn.onf.otcc.yang.tapi.topology.rev181210.get.node.edge.point.details.output.NodeEdgePoint
-                        onep1 = rpcResult2.getResult().getNodeEdgePoint();
+                    onep1 = rpcResult2.getResult().getNodeEdgePoint();
                 assertNotNull("Node Edge Point should not be null", onep1);
             }
         }
@@ -633,7 +633,7 @@ public class TapiTopologyImplTest extends AbstractTest {
             RpcResult<GetServiceInterfacePointDetailsOutput> rpcResult1 = result1.get();
             org.opendaylight.yang.gen.v1
                 .urn.onf.otcc.yang.tapi.common.rev181210.get.service._interface.point.details.output.Sip sip1
-                    = rpcResult1.getResult().getSip();
+                = rpcResult1.getResult().getSip();
             assertNotNull("Sip should not be null", sip1);
         }
     }

diff --git a/tests/transportpce_tests/2.2.1/test10_tapi.py b/tests/transportpce_tests/2.2.1/test10_tapi.py
index f0a429fcbb4222fbfd928365010cf99d13b16068..abe1335703cc9f2e1450ea34174536474f3b1edb 100644 (file)
--- a/tests/transportpce_tests/2.2.1/test10_tapi.py
+++ b/tests/transportpce_tests/2.2.1/test10_tapi.py
@@ -327,9 +327,9 @@ class TransportTapitesting(unittest.TestCase):
         res = response.json()
         self.assertEqual(1, len(res["output"]["topology"]["node"][0]["owned-node-edge-point"]),
                          'Node should contain 1 owned-node-edge-points')
-        self.assertEqual("XPDR1-CLIENT1",
+        self.assertEqual("XPDR-A1-XPDR1+DSR+XPDR1-CLIENT1",
                          res["output"]["topology"]["node"][0]["owned-node-edge-point"][0]["name"][0]["value"],
-                         'name of owned-node-edge-points should be XPDR1-CLIENT1')
+                         'name of owned-node-edge-points should be XPDR-A1-XPDR1+DSR+XPDR1-CLIENT1')
 
     def test_14_check_tapi_topology_T0(self):
         url = "{}/operations/tapi-topology:get-topology-details"
@@ -389,12 +389,12 @@ class TransportTapitesting(unittest.TestCase):
         res = response.json()
         self.assertEqual(2, len(res["output"]["topology"]["node"][0]["owned-node-edge-point"]),
                          'Node should contain 2 owned-node-edge-points')
-        self.assertEqual("XPDR1-CLIENT1",
+        self.assertEqual("XPDR-C1-XPDR1+DSR+XPDR1-CLIENT1",
                          res["output"]["topology"]["node"][0]["owned-node-edge-point"][0]["name"][0]["value"],
-                         'name of owned-node-edge-points should be XPDR1-CLIENT1')
-        self.assertEqual("XPDR1-CLIENT1",
+                         'name of owned-node-edge-points should be XPDR-C1-XPDR1+DSR+XPDR1-CLIENT1')
+        self.assertEqual("XPDR-A1-XPDR1+DSR+XPDR1-CLIENT1",
                          res["output"]["topology"]["node"][0]["owned-node-edge-point"][1]["name"][0]["value"],
-                         'name of owned-node-edge-points should be XPDR1-CLIENT1')
+                         'name of owned-node-edge-points should be XPDR-A1-XPDR1+DSR+XPDR1-CLIENT1')
 
     def test_19_check_tapi_topology_T0(self):
         url = "{}/operations/tapi-topology:get-topology-details"