Rationalize OpenRoadmInterface221

- Introduce payloadType for ODU interface creation
- Remove useless older methods
- Adapt fonctional tests
- Fix bug in renderer

JIRA: TRNSPRTPCE-544
Signed-off-by: Gilles Thouenon <gilles.thouenon@orange.com>
Change-Id: Iaed962eb90e356e7baa123941bdf3ff0a7444ceb

diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface221.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface221.java
index b23e85d5831fe0b909a6147c8180c7c0842a6832..488ccd121b0503fb050d0df35e99b4d223701d96 100644 (file)
--- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface221.java
+++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface221.java
@@ -246,7 +246,7 @@ public class OpenRoadmInterface221 {
     }
 
     public String createOpenRoadmOdu4HOInterface(String nodeId, String logicalConnPoint, boolean isCTP,
-            AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ, String payload) throws OpenRoadmInterfaceException {
+            AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ, String payloadType) throws OpenRoadmInterfaceException {
         Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint);
         if (mapping == null) {
             throw new OpenRoadmInterfaceException(
@@ -271,8 +271,8 @@ public class OpenRoadmInterface221 {
             oduFunction = ODUTTP.class;
             monitoringMode = MonitoringMode.Terminated;
             opu = new OpuBuilder()
-                .setPayloadType(PayloadTypeDef.getDefaultInstance(payload))
-                .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payload))
+                .setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
+                .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
                 .build();
         }
         OduBuilder oduIfBuilder = new OduBuilder()

diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java
index 3ce4156e5608c7abc105b757ebcb75858933a3b0..5d20f4a718ba08b0211d4da6ae1310a8da7c912f 100644 (file)
--- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java
+++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterface710.java
@@ -20,6 +20,8 @@ import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
 import org.opendaylight.transportpce.common.mapping.PortMapping;
 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
 import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.az.api.info.AEndApiInfo;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev211004.az.api.info.ZEndApiInfo;
 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210927.mapping.Mapping;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.attributes.rev200327.TrailTraceOther.TimDetectMode;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.attributes.rev200327.parent.odu.allocation.ParentOduAllocationBuilder;
@@ -203,10 +205,10 @@ public class OpenRoadmInterface710 {
     }
 
     public String createOpenRoadmOtucnInterface(String nodeId, String logicalConnPoint,
-            String supportingOtsiGroupInterface)
+            String supportingOtsiGroupInterface, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ)
             throws OpenRoadmInterfaceException {
-        Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
-        if (portMap == null) {
+        Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint);
+        if (mapping == null) {
             throw new OpenRoadmInterfaceException(
                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
                     nodeId, logicalConnPoint));
@@ -222,69 +224,21 @@ public class OpenRoadmInterface710 {
             .setDegmIntervals(Uint8.valueOf(2))
             .setDegthrPercentage(Uint16.valueOf(100))
             .setMaintLoopback(maintLoopbackBuilder.build());
-
-        InterfaceBuilder otuInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOtu.class,
-            logicalConnPoint + "-OTUC4");
-
-        // Create a list
-        List<String> listSupportingOtsiGroupInterface = new ArrayList<>();
-        listSupportingOtsiGroupInterface.add(supportingOtsiGroupInterface);
-
-        otuInterfaceBuilder.setSupportingInterfaceList(listSupportingOtsiGroupInterface);
-        org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder otuIf1Builder =
-            new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev200529.Interface1Builder();
-
-        otuInterfaceBuilder.addAugmentation(otuIf1Builder.setOtu(otuBuilder.build()).build());
-
-        // Post interface on the device
-        openRoadmInterfaces.postInterface(nodeId, otuInterfaceBuilder);
-
-        // Post the equipment-state change on the device circuit-pack if xpdr node
-        if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
-            this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
-        }
-
-        return otuInterfaceBuilder.getName();
-
-    }
-
-    // Adding method to have SAPI/DAPI information for the OTUCn
-    public String createOpenRoadmOtucnInterface(String anodeId, String alogicalConnPoint,
-            String supportingOtsiGroupInterface, String znodeId, String zlogicalConnPoint)
-            throws OpenRoadmInterfaceException {
-        Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
-        Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
-        if (portMapA == null) {
-            throw new OpenRoadmInterfaceException(
-                String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
-                    anodeId, alogicalConnPoint));
+        if (apiInfoA != null) {
+            otuBuilder.setTxSapi(apiInfoA.getSapi())
+                .setTxDapi(apiInfoA.getDapi())
+                .setExpectedSapi(apiInfoA.getExpectedSapi())
+                .setExpectedDapi(apiInfoA.getExpectedDapi());
         }
-        // On the Zside
-        if (portMapZ == null) {
-            throw new OpenRoadmInterfaceException(
-                String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
-                    znodeId, zlogicalConnPoint));
-
+        if (apiInfoZ != null) {
+            otuBuilder.setTxSapi(apiInfoZ.getSapi())
+                .setTxDapi(apiInfoZ.getDapi())
+                .setExpectedSapi(apiInfoZ.getExpectedSapi())
+                .setExpectedDapi(apiInfoZ.getExpectedDapi());
         }
-        // Create an OTUCn object
-        MaintLoopbackBuilder maintLoopbackBuilder = new MaintLoopbackBuilder();
-        maintLoopbackBuilder.setEnabled(false);
-        OtuBuilder otuBuilder = new OtuBuilder()
-            .setRate(OTUCn.class)
-            .setOtucnNRate(Uint16.valueOf(4))
-            .setTimActEnabled(false)
-            .setTimDetectMode(TimDetectMode.Disabled)
-            .setDegmIntervals(Uint8.valueOf(2))
-            .setDegthrPercentage(Uint16.valueOf(100))
-            .setMaintLoopback(maintLoopbackBuilder.build())
-            .setTxSapi(portMapA.getLcpHashVal())
-            .setTxDapi(portMapZ.getLcpHashVal())
-            // setting expected SAPI and DAPI values
-            .setExpectedDapi(portMapA.getLcpHashVal())
-            .setExpectedSapi(portMapZ.getLcpHashVal());
 
-        InterfaceBuilder otuInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOtu.class,
-            alogicalConnPoint + "-OTUC4");
+        InterfaceBuilder otuInterfaceBuilder = createGenericInterfaceBuilder(mapping, OtnOtu.class,
+            logicalConnPoint + "-OTUC4");
 
         // Create a list
         List<String> listSupportingOtsiGroupInterface = new ArrayList<>();
@@ -297,22 +251,19 @@ public class OpenRoadmInterface710 {
         otuInterfaceBuilder.addAugmentation(otuIf1Builder.setOtu(otuBuilder.build()).build());
 
         // Post interface on the device
-        openRoadmInterfaces.postInterface(anodeId, otuInterfaceBuilder);
-
+        openRoadmInterfaces.postInterface(nodeId, otuInterfaceBuilder);
         // Post the equipment-state change on the device circuit-pack if xpdr node
-        if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
-            this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true);
+        if (mapping.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
+            this.openRoadmInterfaces.postEquipmentState(nodeId, mapping.getSupportingCircuitPackName(), true);
         }
-
+        this.portMapping.updateMapping(nodeId, mapping);
         return otuInterfaceBuilder.getName();
-
     }
 
-    public String createOpenRoadmOducnInterface(String nodeId, String logicalConnPoint,
-            String supportingOtucn)
+    public String createOpenRoadmOducnInterface(String nodeId, String logicalConnPoint)
             throws OpenRoadmInterfaceException {
-        Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
-        if (portMap == null) {
+        Mapping mapping = portMapping.getMapping(nodeId, logicalConnPoint);
+        if (mapping == null) {
             throw new OpenRoadmInterfaceException(
                 String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
                     nodeId, logicalConnPoint));
@@ -342,12 +293,14 @@ public class OpenRoadmInterface710 {
             .setOpu(opuBuilder.build())
             .setMaintTestsignal(maintTestsignal.build());
 
-        InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class,
-            logicalConnPoint + ODUC4);
+        InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(mapping, OtnOdu.class,
+            logicalConnPoint + "-ODUC4");
 
         // Create a list
         List<String> listSupportingOtucnInterface = new ArrayList<>();
-        listSupportingOtucnInterface.add(supportingOtucn);
+        if (mapping.getSupportingOtuc4() != null) {
+            listSupportingOtucnInterface.add(mapping.getSupportingOtuc4());
+        }
 
         oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder =
@@ -359,8 +312,8 @@ public class OpenRoadmInterface710 {
         openRoadmInterfaces.postInterface(nodeId, oduInterfaceBuilder);
 
         // Post the equipment-state change on the device circuit-pack if xpdr node
-        if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
-            this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
+        if (mapping.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
+            this.openRoadmInterfaces.postEquipmentState(nodeId, mapping.getSupportingCircuitPackName(), true);
         }
 
         return oduInterfaceBuilder.getName();

diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterfaceFactory.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterfaceFactory.java
index b62ee33fddc9e0e0d366bc2e4d8c4d19c802f005..91e22ac37ff10f77eb247ec17cb995bad3aea3c0 100644 (file)
--- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterfaceFactory.java
+++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmInterfaceFactory.java
@@ -107,67 +107,6 @@ public class OpenRoadmInterfaceFactory {
         }
     }
 
-    /**
-     * This methods creates an ODU interface on the given termination point.
-     *
-     * @param nodeId                 node ID
-     * @param logicalConnPoint       logical connection point
-     * @param supportingOtuInterface supporting OTU interface
-     * @return Name of the interface if successful, otherwise return null.
-     * @throws OpenRoadmInterfaceException OpenRoadm interface exception
-     */
-
-    public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
-            throws OpenRoadmInterfaceException {
-        switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
-            case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
-                return openRoadmInterface121.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint);
-            case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
-                return openRoadmInterface221.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint,
-                        supportingOtuInterface);
-            case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
-                // Here ODUCn and ODUflex are combined
-                String interfaceNameOduc4 = openRoadmInterface710.createOpenRoadmOducnInterface(nodeId,
-                    logicalConnPoint, supportingOtuInterface);
-                return openRoadmInterface710.createOpenRoadmOduflexInterface(nodeId, logicalConnPoint,
-                    interfaceNameOduc4);
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * This methods creates an ODU interface on the given termination point.
-     *
-     * @param anodeId                 node ID for A side
-     * @param alogicalConnPoint       logical connection point for A side
-     * @param asupportingOtuInterface supporting OTU interface
-     * @param znodeId                 node ID for Z side
-     * @param zlogicalConnPoint       logical connection point for Z side
-     * @return Name of the interface if successful, otherwise return null.
-     * @throws OpenRoadmInterfaceException OpenRoadm interface exception
-     */
-
-    public String createOpenRoadmOdu4Interface(String anodeId, String alogicalConnPoint, String asupportingOtuInterface,
-            String znodeId, String zlogicalConnPoint)
-            throws OpenRoadmInterfaceException {
-        switch (mappingUtils.getOpenRoadmVersion(anodeId)) {
-            case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
-                return openRoadmInterface121.createOpenRoadmOdu4Interface(anodeId, alogicalConnPoint);
-            case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
-                return openRoadmInterface221.createOpenRoadmOdu4Interface(anodeId, alogicalConnPoint,
-                    asupportingOtuInterface, znodeId, zlogicalConnPoint);
-            case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
-                // Here ODUCn and ODUflex are combined
-                String interfaceNameOduc4 = openRoadmInterface710.createOpenRoadmOducnInterface(anodeId,
-                    alogicalConnPoint, asupportingOtuInterface, znodeId, zlogicalConnPoint);
-                return openRoadmInterface710.createOpenRoadmOduflexInterface(anodeId, alogicalConnPoint,
-                    interfaceNameOduc4, znodeId, zlogicalConnPoint);
-            default:
-                return null;
-        }
-    }
-
     /**
      * This methods creates an ODU interface on the given termination point.
      *
@@ -176,19 +115,23 @@ public class OpenRoadmInterfaceFactory {
      * @param isCTP                  to distinguish with a TTP odu interface
      * @param apiInfoA               sapi and dapi for A end of the service
      * @param apiInfoZ               sapi and dapi for Z end of the service
-     * @param payload                payload type of the OPU container
+     * @param payloadType            payload type of the opu when terminated
      * @return Name of the interface if successful, otherwise return null.
      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
      */
 
     public String createOpenRoadmOdu4HOInterface(String nodeId, String logicalConnPoint, boolean isCTP,
-            AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ, String payload) throws OpenRoadmInterfaceException {
+            AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ, String payloadType)
+            throws OpenRoadmInterfaceException {
+
         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
                 return openRoadmInterface121.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint);
             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
                 return openRoadmInterface221.createOpenRoadmOdu4HOInterface(nodeId, logicalConnPoint, isCTP,
-                    apiInfoA, apiInfoZ, payload);
+                    apiInfoA, apiInfoZ, payloadType);
+            case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
+                return openRoadmInterface710.createOpenRoadmOducnInterface(nodeId, logicalConnPoint);
             default:
                 return null;
         }
@@ -202,11 +145,14 @@ public class OpenRoadmInterfaceFactory {
      * @param supportOchInterface supporting OCH interface
      * @param apiInfoA            sapi and dapi for A end of the service
      * @param apiInfoZ            sapi and dapi for Z end of the service
+     * @return Name of the interface if successful, otherwise return null.
      * @throws OpenRoadmInterfaceException OpenRoadm interface exception
      */
 
     public String createOpenRoadmOtu4Interface(String nodeId, String logicalConnPoint, String supportOchInterface,
-            AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ) throws OpenRoadmInterfaceException {
+            AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ)
+            throws OpenRoadmInterfaceException {
+
         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
                 return openRoadmInterface121
@@ -216,7 +162,7 @@ public class OpenRoadmInterfaceFactory {
                     apiInfoA, apiInfoZ);
             case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
                 return openRoadmInterface710.createOpenRoadmOtucnInterface(nodeId, logicalConnPoint,
-                    supportOchInterface);
+                    supportOchInterface, apiInfoA, apiInfoZ);
             default:
                 return null;
         }
@@ -274,8 +220,9 @@ public class OpenRoadmInterfaceFactory {
         }
     }
 
-    public String createOpenRoadmEth1GInterface(String nodeId,
-            String logicalConnPoint) throws OpenRoadmInterfaceException {
+    public String createOpenRoadmEth1GInterface(String nodeId,String logicalConnPoint)
+            throws OpenRoadmInterfaceException {
+
         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
@@ -287,8 +234,9 @@ public class OpenRoadmInterfaceFactory {
         }
     }
 
-    public String createOpenRoadmEth10GInterface(String nodeId,
-            String logicalConnPoint) throws OpenRoadmInterfaceException {
+    public String createOpenRoadmEth10GInterface(String nodeId, String logicalConnPoint)
+            throws OpenRoadmInterfaceException {
+
         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
@@ -298,11 +246,10 @@ public class OpenRoadmInterfaceFactory {
             default:
                 return null;
         }
-
     }
 
-    public String createOpenRoadmEth100GInterface(String nodeId,
-            String logicalConnPoint) throws OpenRoadmInterfaceException {
+    public String createOpenRoadmEth100GInterface(String nodeId, String logicalConnPoint)
+            throws OpenRoadmInterfaceException {
 
         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
@@ -316,53 +263,56 @@ public class OpenRoadmInterfaceFactory {
             default:
                 return null;
         }
-
     }
 
     public String createOpenRoadmOdu0Interface(String nodeId, String logicalConnPoint, String servicename,
-            String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlot)
+            boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ,
+            String payLoadType)
             throws OpenRoadmInterfaceException {
+
         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
                 return null;
             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
-                return openRoadmOtnInterface221.createOpenRoadmOdu0Interface(
-                    nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlot);
+                return openRoadmOtnInterface221.createOpenRoadmOdu0Interface(nodeId, logicalConnPoint, servicename,
+                    isCTP, tribPortNumber, tribSlotIndex, apiInfoA, apiInfoZ, payLoadType);
             default:
                 return null;
         }
     }
 
     public String createOpenRoadmOdu2Interface(String nodeId, String logicalConnPoint, String servicename,
-            String payLoad, boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
+            boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ,
+            String payLoadType)
             throws OpenRoadmInterfaceException {
         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
                 return null;
             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
-                return openRoadmOtnInterface221.createOpenRoadmOdu2Interface(
-                    nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex);
+                return openRoadmOtnInterface221.createOpenRoadmOdu2Interface(nodeId, logicalConnPoint, servicename,
+                    isCTP, tribPortNumber, tribSlotIndex, apiInfoA, apiInfoZ, payLoadType);
             default:
                 return null;
         }
     }
 
     public String createOpenRoadmOdu2eInterface(String nodeId, String logicalConnPoint, String servicename,
-            boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ)
+            boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ,
+            String payLoadType)
             throws OpenRoadmInterfaceException {
+
         switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
             case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
                 LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
                 return null;
             case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
                 return openRoadmOtnInterface221.createOpenRoadmOdu2eInterface(nodeId, logicalConnPoint, servicename,
-                    isCTP, tribPortNumber, tribSlotIndex, apiInfoA, apiInfoZ);
+                    isCTP, tribPortNumber, tribSlotIndex, apiInfoA, apiInfoZ, payLoadType);
             default:
                 return null;
         }
-
     }
 
     public String createOpenRoadmOtnOdu4LoInterface(String nodeId, String logicalConnPoint,
@@ -385,16 +335,6 @@ public class OpenRoadmInterfaceFactory {
         }
     }
 
-    public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
-            throws OpenRoadmInterfaceException {
-        switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
-            case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
-                return openRoadmInterface221
-                        .createOpenRoadmOtnOdu4Interface(nodeId, logicalConnPoint, supportingOtuInterface);
-            default:
-                return null;
-        }
-    }
 
     public String createOpenRoadmOtnOdu4Interface(String anodeId, String alogicalConnPoint,
             String asupportingOtuInterface, String znodeId, String zlogicalConnPoint)

diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmOtnInterface221.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmOtnInterface221.java
index 53e4ad61e2cac58130e648849dadf6cfbec13954..5e7bc409c30824b99117f5a1dc596b609fb817f9 100644 (file)
--- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmOtnInterface221.java
+++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/openroadminterface/OpenRoadmOtnInterface221.java
@@ -31,7 +31,6 @@ import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev17121
 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.ODUTTPCTP;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.OduFunctionIdentity;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev171215.PayloadTypeDef;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.OduAttributes.MonitoringMode;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.odu.container.OduBuilder;
 import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.opu.Opu;
@@ -134,8 +133,8 @@ public class OpenRoadmOtnInterface221 {
     }
 
     public String createOpenRoadmOdu2eInterface(String nodeId, String logicalConnPoint, String serviceName,
-            boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ)
-            throws OpenRoadmInterfaceException {
+            boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ,
+            String payloadType) throws OpenRoadmInterfaceException {
 
         Mapping mapping = this.portMapping.getMapping(nodeId, logicalConnPoint);
         if (mapping == null) {
@@ -171,8 +170,8 @@ public class OpenRoadmOtnInterface221 {
             oduFunction = ODUTTPCTP.class;
             monitoringMode = MonitoringMode.Terminated;
             opu = new OpuBuilder()
-                .setPayloadType(PayloadTypeDef.getDefaultInstance("03"))
-                .setExpPayloadType(PayloadTypeDef.getDefaultInstance("03"))
+                .setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
+                .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
                 .build();
         }
         OduBuilder oduIfBuilder = new OduBuilder()
@@ -209,111 +208,142 @@ public class OpenRoadmOtnInterface221 {
         return oduInterfaceBldr.getName();
     }
 
-    public String createOpenRoadmOdu0Interface(String nodeId,
-            String logicalConnPoint, String serviceName, String payLoad,
-            boolean isNetworkPort, int tribPortNumber, int tribSlot)
-            throws OpenRoadmInterfaceException {
-        Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint);
-        String supportingInterface = null;
+    public String createOpenRoadmOdu0Interface(String nodeId, String logicalConnPoint, String serviceName,
+            boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ,
+            String payloadType) throws OpenRoadmInterfaceException {
 
-        if (isNetworkPort) {
-            supportingInterface = portMap.getSupportingOdu4();
-        } else {
-            supportingInterface = logicalConnPoint + "-ETHERNET1G";
+        Mapping mapping = this.portMapping.getMapping(nodeId, logicalConnPoint);
+        if (mapping == null) {
+            throw new OpenRoadmInterfaceException(
+                String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
         }
-        if (portMap == null) {
-            throwException(nodeId, logicalConnPoint);
+        InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOdu.class,
+            logicalConnPoint + "-ODU0-" + serviceName);
+        if (mapping.getSupportingOdu4() != null) {
+            oduInterfaceBldr.setSupportingInterface(mapping.getSupportingOdu4());
+        }
+        if (mapping.getSupportingEthernet() != null) {
+            oduInterfaceBldr.setSupportingInterface(mapping.getSupportingEthernet());
         }
-        InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(
-                portMap, OtnOdu.class,
-                logicalConnPoint + "-ODU0-" + serviceName);
-        oduInterfaceBldr.setSupportingInterface(supportingInterface);
 
-        // ODU interface specific data
-        OduBuilder oduIfBuilder = new OduBuilder().setRate(ODU0.class)
-                .setOduFunction(ODUTTPCTP.class)
-                .setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
-        if (isNetworkPort) {
-            LOG.debug("Network port is true");
+        Class<? extends OduFunctionIdentity> oduFunction;
+        MonitoringMode monitoringMode;
+        Opu opu = null;
+        ParentOduAllocation parentOduAllocation = null;
+        if (isCTP) {
+            oduFunction = ODUCTP.class;
+            monitoringMode = MonitoringMode.Monitored;
             List<Uint16> tribSlots = new ArrayList<>();
-            // add trib slots
-            tribSlots.add(Uint16.valueOf(tribSlot));
-            ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
-                    // set trib port numbers
+            Uint16 newIdx = Uint16.valueOf(tribSlotIndex);
+            tribSlots.add(newIdx);
+            IntStream.range(tribSlotIndex, tribSlotIndex + 8)
+                    .forEach(nbr -> tribSlots.add(Uint16.valueOf(nbr)));
+            parentOduAllocation = new ParentOduAllocationBuilder()
                     .setTribPortNumber(Uint16.valueOf(tribPortNumber))
-                    .setTribSlots(tribSlots);
-            oduIfBuilder.setOduFunction(ODUCTP.class)
-                    .setMonitoringMode(OduAttributes.MonitoringMode.Monitored)
-                    .setParentOduAllocation(parentOduAllocationBuilder.build());
-            LOG.debug("Network port is true {} {} {}",
-                    oduIfBuilder.getParentOduAllocation().getTribSlots(),
-                    oduIfBuilder.getRate(),
-                    oduIfBuilder.getParentOduAllocation().getTribPortNumber());
+                    .setTribSlots(tribSlots)
+                    .build();
         } else {
-            LOG.debug("Current port is a client port");
-            OpuBuilder opuBldr = new OpuBuilder()
-                    .setPayloadType(new PayloadTypeDef(payLoad))
-                    .setExpPayloadType(new PayloadTypeDef(payLoad));
-            oduIfBuilder.setOpu(opuBldr.build());
+            oduFunction = ODUTTPCTP.class;
+            monitoringMode = MonitoringMode.Terminated;
+            opu = new OpuBuilder()
+                .setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
+                .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
+                .build();
+        }
+        OduBuilder oduIfBuilder = new OduBuilder()
+            .setRate(ODU0.class)
+            .setOduFunction(oduFunction)
+            .setMonitoringMode(monitoringMode)
+            .setOpu(opu)
+            .setParentOduAllocation(parentOduAllocation);
+        if (apiInfoA != null) {
+            oduIfBuilder.setTxSapi(apiInfoA.getSapi())
+                .setTxDapi(apiInfoA.getDapi())
+                .setExpectedSapi(apiInfoA.getExpectedSapi())
+                .setExpectedDapi(apiInfoA.getExpectedDapi());
+        }
+        if (apiInfoZ != null) {
+            oduIfBuilder.setTxSapi(apiInfoZ.getSapi())
+                .setTxDapi(apiInfoZ.getDapi())
+                .setExpectedSapi(apiInfoZ.getExpectedSapi())
+                .setExpectedDapi(apiInfoZ.getExpectedDapi());
         }
         // Create Interface1 type object required for adding as augmentation
         // TODO look at imports of different versions of class
         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder
             oduIf1Builder = new
-            org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
+                org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
         oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
 
         // Post interface on the device
         this.openRoadmInterfaces.postOTNInterface(nodeId, oduInterfaceBldr);
-        LOG.info("returning the ODU0 inteface {}", oduInterfaceBldr.getName());
+        if (!isCTP) {
+            LOG.info("{}-{} updating mapping with interface {}", nodeId, logicalConnPoint, oduInterfaceBldr.getName());
+            this.portMapping.updateMapping(nodeId, mapping);
+        }
         return oduInterfaceBldr.getName();
     }
 
-    public String createOpenRoadmOdu2Interface(String nodeId,
-            String logicalConnPoint, String serviceName, String payLoad,
-            boolean isNetworkPort, int tribPortNumber, int tribSlotIndex)
-            throws OpenRoadmInterfaceException {
-        Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint);
-        String supportingInterface = null;
+    public String createOpenRoadmOdu2Interface(String nodeId, String logicalConnPoint, String serviceName,
+            boolean isCTP, int tribPortNumber, int tribSlotIndex, AEndApiInfo apiInfoA, ZEndApiInfo apiInfoZ,
+            String payloadType) throws OpenRoadmInterfaceException {
 
-        if (portMap != null) {
-            if (isNetworkPort) {
-                supportingInterface = portMap.getSupportingOdu4();
-            } else {
-                supportingInterface = portMap.getSupportingEthernet();
-            }
-        } else {
-            throwException(nodeId, logicalConnPoint);
+        Mapping mapping = this.portMapping.getMapping(nodeId, logicalConnPoint);
+        if (mapping == null) {
+            throw new OpenRoadmInterfaceException(
+                String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
+        }
+        InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(mapping, OtnOdu.class,
+            logicalConnPoint + "-ODU2-" + serviceName);
+        if (mapping.getSupportingOdu4() != null) {
+            oduInterfaceBldr.setSupportingInterface(mapping.getSupportingOdu4());
+        }
+        if (mapping.getSupportingEthernet() != null) {
+            oduInterfaceBldr.setSupportingInterface(mapping.getSupportingEthernet());
         }
-        InterfaceBuilder oduInterfaceBldr = createGenericInterfaceBuilder(
-                portMap, OtnOdu.class,
-                logicalConnPoint + "-ODU2-" + serviceName)
-                        .setSupportingInterface(supportingInterface);
 
-        OduBuilder oduIfBuilder = new OduBuilder().setRate(ODU2.class)
-                .setOduFunction(ODUTTPCTP.class)
-                .setMonitoringMode(OduAttributes.MonitoringMode.Terminated);
-        if (isNetworkPort) {
+        Class<? extends OduFunctionIdentity> oduFunction;
+        MonitoringMode monitoringMode;
+        Opu opu = null;
+        ParentOduAllocation parentOduAllocation = null;
+        if (isCTP) {
+            oduFunction = ODUCTP.class;
+            monitoringMode = MonitoringMode.Monitored;
             List<Uint16> tribSlots = new ArrayList<>();
+            Uint16 newIdx = Uint16.valueOf(tribSlotIndex);
+            tribSlots.add(newIdx);
             IntStream.range(tribSlotIndex, tribSlotIndex + 8)
                     .forEach(nbr -> tribSlots.add(Uint16.valueOf(nbr)));
-            ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
-                    // set trib port numbers
+            parentOduAllocation = new ParentOduAllocationBuilder()
                     .setTribPortNumber(Uint16.valueOf(tribPortNumber))
-                    .setTribSlots(tribSlots);
-            oduIfBuilder.setOduFunction(ODUCTP.class)
-                    .setMonitoringMode(OduAttributes.MonitoringMode.Monitored)
-                    .setParentOduAllocation(parentOduAllocationBuilder.build());
+                    .setTribSlots(tribSlots)
+                    .build();
         } else {
-            // Set Opu attributes
-            OpuBuilder opuBldr = new OpuBuilder()
-                    .setPayloadType(new PayloadTypeDef(payLoad))
-                    .setExpPayloadType(new PayloadTypeDef(payLoad));
-            oduIfBuilder.setOpu(opuBldr.build());
+            oduFunction = ODUTTPCTP.class;
+            monitoringMode = MonitoringMode.Terminated;
+            opu = new OpuBuilder()
+                .setPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
+                .setExpPayloadType(PayloadTypeDef.getDefaultInstance(payloadType))
+                .build();
+        }
+        OduBuilder oduIfBuilder = new OduBuilder()
+            .setRate(ODU2.class)
+            .setOduFunction(oduFunction)
+            .setMonitoringMode(monitoringMode)
+            .setOpu(opu)
+            .setParentOduAllocation(parentOduAllocation);
+        if (apiInfoA != null) {
+            oduIfBuilder.setTxSapi(apiInfoA.getSapi())
+                .setTxDapi(apiInfoA.getDapi())
+                .setExpectedSapi(apiInfoA.getExpectedSapi())
+                .setExpectedDapi(apiInfoA.getExpectedDapi());
+        }
+        if (apiInfoZ != null) {
+            oduIfBuilder.setTxSapi(apiInfoZ.getSapi())
+                .setTxDapi(apiInfoZ.getDapi())
+                .setExpectedSapi(apiInfoZ.getExpectedSapi())
+                .setExpectedDapi(apiInfoZ.getExpectedDapi());
         }
-
-        // Create Interface1 type object required for adding as augmentation
-        // TODO look at imports of different versions of class
         // Create Interface1 type object required for adding as augmentation
         // TODO look at imports of different versions of class
         org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder
@@ -323,7 +353,10 @@ public class OpenRoadmOtnInterface221 {
 
         // Post interface on the device
         this.openRoadmInterfaces.postOTNInterface(nodeId, oduInterfaceBldr);
-        LOG.info("returning the ODU2 inteface {}", oduInterfaceBldr.getName());
+        if (!isCTP) {
+            LOG.info("{}-{} updating mapping with interface {}", nodeId, logicalConnPoint, oduInterfaceBldr.getName());
+            this.portMapping.updateMapping(nodeId, mapping);
+        }
         return oduInterfaceBldr.getName();
     }
 }

diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImpl.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImpl.java
index ee9448162ae426bd7f0ecc719c018ce5cc9848d9..bffe901a3de5e892f29c4adb7d1738ab7023e059 100644 (file)
--- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImpl.java
+++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/DeviceRendererServiceImpl.java
@@ -84,6 +84,7 @@ import org.slf4j.LoggerFactory;
 public class DeviceRendererServiceImpl implements DeviceRendererService {
     private static final String IS_NOT_MOUNTED_ON_THE_CONTROLLER = " is not mounted on the controller";
     private static final Logger LOG = LoggerFactory.getLogger(DeviceRendererServiceImpl.class);
+    private static final String PT_07 = "07";
     private final DataBroker dataBroker;
     private final DeviceTransactionManager deviceTransactionManager;
     private final OpenRoadmInterfaceFactory openRoadmInterfaceFactory;
@@ -165,7 +166,7 @@ public class DeviceRendererServiceImpl implements DeviceRendererService {
                             otnLinkTps.add(new LinkTpBuilder().setNodeId(nodeId).setTpId(destTp).build());
                         } else {
                             createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface(
-                                    nodeId, destTp, false, apiInfoA, apiInfoZ, "07"));
+                                    nodeId, destTp, false, apiInfoA, apiInfoZ, PT_07));
                         }
                     }
                     if ((srcTp != null) && srcTp.contains(StringConstants.CLIENT_TOKEN)) {
@@ -186,18 +187,12 @@ public class DeviceRendererServiceImpl implements DeviceRendererService {
                         String supportingOtuInterface = this.openRoadmInterfaceFactory.createOpenRoadmOtu4Interface(
                                 nodeId, srcTp, supportingOchInterface, apiInfoA, apiInfoZ);
                         createdOtuInterfaces.add(supportingOtuInterface);
-                        createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4Interface(
-                                nodeId, srcTp, supportingOtuInterface));
-                        Mapping mapping = this.portMapping.getMapping(nodeId,srcTp);
-                        createdOduInterfaces.add(
-                            mapping != null
-                            && mapping.getXponderType() != null
-                            && (mapping.getXponderType().getIntValue() == 3
-                                || mapping.getXponderType().getIntValue() == 2)
-                            ? this.openRoadmInterfaceFactory.createOpenRoadmOtnOdu4Interface(
-                                    nodeId, destTp, supportingOtuInterface)
-                            : this.openRoadmInterfaceFactory.createOpenRoadmOdu4Interface(
-                                    nodeId, destTp, supportingOtuInterface));
+                        if (destTp == null) {
+                            otnLinkTps.add(new LinkTpBuilder().setNodeId(nodeId).setTpId(srcTp).build());
+                        } else {
+                            createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface(
+                                nodeId, srcTp, false, apiInfoA, apiInfoZ, PT_07));
+                        }
                     }
                     if ((destTp != null) && destTp.contains(StringConstants.CLIENT_TOKEN)) {
                         LOG.info("Adding supporting EThernet interface for node {}, dest tp {}", nodeId, destTp);

diff --git a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java
index 3d3e704910d0d569c2807f4eb90d455b8ffbf905..a7588b777a21bac7507b1097f41787607ab4d079 100644 (file)
--- a/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java
+++ b/renderer/src/main/java/org/opendaylight/transportpce/renderer/provisiondevice/OtnDeviceRendererServiceImpl.java
@@ -337,19 +337,21 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService {
                         createdOduInterfaces.add(
                             // suppporting interface?, payload ?
                             openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getClientTp(),
-                                input.getServiceName(), PT_07, false, input.getTribPortNumber(), input.getTribSlot()));
+                                input.getServiceName(), false, input.getTribPortNumber(), input.getTribSlot(), apiInfoA,
+                                apiInfoZ, PT_07));
                     }
                     createdOduInterfaces.add(
                         openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getNetworkTp(),
-                            input.getServiceName(), PT_07, true, input.getTribPortNumber(), input.getTribSlot()));
+                            input.getServiceName(), true, input.getTribPortNumber(), input.getTribSlot(), null, null,
+                            null));
                     linkTpList.add(
                         new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build());
                     if (node.getNetwork2Tp() != null) {
                         createdOduInterfaces.add(
                             // supporting interface? payload ?
                             openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(),
-                                node.getNetwork2Tp(), input.getServiceName(), PT_07, true, input.getTribPortNumber(),
-                                input.getTribSlot()));
+                                node.getNetwork2Tp(), input.getServiceName(), true, input.getTribPortNumber(),
+                                input.getTribSlot(), null, null, null));
                         linkTpList.add(
                             new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build());
                     }
@@ -363,13 +365,13 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService {
                             // suppporting interface?, payload ?
                             openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(),
                                 node.getClientTp(), input.getServiceName(), false, input.getTribPortNumber(),
-                                input.getTribSlot(), apiInfoA, apiInfoZ));
+                                input.getTribSlot(), apiInfoA, apiInfoZ, PT_03));
                     }
                     createdOduInterfaces.add(
                         // supporting interface? payload ?
                         openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), node.getNetworkTp(),
-                            input.getServiceName(), true, input.getTribPortNumber(), input.getTribSlot(), apiInfoA,
-                            apiInfoZ));
+                            input.getServiceName(), true, input.getTribPortNumber(), input.getTribSlot(), null,
+                            null, null));
                     linkTpList.add(
                         new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build());
                     if (node.getNetwork2Tp() != null) {
@@ -377,7 +379,7 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService {
                             // supporting interface? payload ?
                             openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(),
                                 node.getNetwork2Tp(), input.getServiceName(), true, input.getTribPortNumber(),
-                                input.getTribSlot(), apiInfoA, apiInfoZ));
+                                input.getTribSlot(), null, null, null));
                         linkTpList.add(
                             new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build());
                     }
@@ -463,7 +465,7 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService {
                                 node.getNodeId(), node.getClientTp(), false, apiInfoA, apiInfoZ, "21"));
                         // supporting interface? payload ?
                         createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface(
-                                node.getNodeId(), node.getNetworkTp(), true, null, null, "21"));
+                                node.getNodeId(), node.getNetworkTp(), true, null, null, null));
                         linkTpList.add(new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getClientTp())
                                 .build());
                     }
@@ -476,9 +478,9 @@ public class OtnDeviceRendererServiceImpl implements OtnDeviceRendererService {
                     if (node.getClientTp() == null && node.getNetwork2Tp() != null) {
                         // supporting interface? payload ?
                         createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface(
-                            node.getNodeId(), node.getNetworkTp(), true, null, null, "21"));
+                            node.getNodeId(), node.getNetworkTp(), true, null, null, null));
                         createdOduInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmOdu4HOInterface(
-                                node.getNodeId(), node.getNetwork2Tp(), true, null, null, "21"));
+                                node.getNodeId(), node.getNetwork2Tp(), true, null, null, null));
                     }
                     break;
                 default:

diff --git a/tests/transportpce_tests/2.2.1/test14_otn_switch_end2end.py b/tests/transportpce_tests/2.2.1/test14_otn_switch_end2end.py
index b353cd810b4f11d44c3fd7b7a017e5200bd095da..2ee43776a12e42ebaab5bac1ebe471731a3da2f2 100644 (file)
--- a/tests/transportpce_tests/2.2.1/test14_otn_switch_end2end.py
+++ b/tests/transportpce_tests/2.2.1/test14_otn_switch_end2end.py
@@ -151,39 +151,39 @@ class TransportPCEtesting(unittest.TestCase):
         print("all processes killed")
 
     def setUp(self):
-        time.sleep(5)
+        time.sleep(2)
 
-    def test_01_connect_spdrA(self):
+    def test_001_connect_spdrA(self):
         response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
         self.assertEqual(response.status_code,
                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 
-    def test_02_connect_spdrB(self):
+    def test_002_connect_spdrB(self):
         response = test_utils.mount_device("SPDR-SB1", ('spdrb', self.NODE_VERSION))
         self.assertEqual(response.status_code,
                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 
-    def test_03_connect_spdrC(self):
+    def test_003_connect_spdrC(self):
         response = test_utils.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
         self.assertEqual(response.status_code,
                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 
-    def test_04_connect_rdmA(self):
+    def test_004_connect_rdmA(self):
         response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
         self.assertEqual(response.status_code,
                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 
-    def test_05_connect_rdmB(self):
+    def test_005_connect_rdmB(self):
         response = test_utils.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION))
         self.assertEqual(response.status_code,
                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 
-    def test_06_connect_rdmC(self):
+    def test_006_connect_rdmC(self):
         response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
         self.assertEqual(response.status_code,
                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 
-    def test_07_connect_sprdA_2_N1_to_roadmA_PP3(self):
+    def test_007_connect_sprdA_2_N1_to_roadmA_PP3(self):
         response = test_utils.connect_xpdr_to_rdm_request("SPDR-SA1", "2", "1",
                                                           "ROADM-A1", "1", "SRG1-PP3-TXRX")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -192,7 +192,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res["output"]["result"])
         time.sleep(2)
 
-    def test_08_connect_roadmA_PP3_to_spdrA_2_N1(self):
+    def test_008_connect_roadmA_PP3_to_spdrA_2_N1(self):
         response = test_utils.connect_rdm_to_xpdr_request("SPDR-SA1", "2", "1",
                                                           "ROADM-A1", "1", "SRG1-PP3-TXRX")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -201,7 +201,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res["output"]["result"])
         time.sleep(2)
 
-    def test_09_connect_sprdC_2_N1_to_roadmC_PP3(self):
+    def test_009_connect_sprdC_2_N1_to_roadmC_PP3(self):
         response = test_utils.connect_xpdr_to_rdm_request("SPDR-SC1", "2", "1",
                                                           "ROADM-C1", "1", "SRG1-PP3-TXRX")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -210,7 +210,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res["output"]["result"])
         time.sleep(2)
 
-    def test_10_connect_roadmC_PP3_to_spdrC_2_N1(self):
+    def test_010_connect_roadmC_PP3_to_spdrC_2_N1(self):
         response = test_utils.connect_rdm_to_xpdr_request("SPDR-SC1", "2", "1",
                                                           "ROADM-C1", "1", "SRG1-PP3-TXRX")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -219,7 +219,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res["output"]["result"])
         time.sleep(2)
 
-    def test_11_connect_sprdB_2_N1_to_roadmB_PP1(self):
+    def test_011_connect_sprdB_2_N1_to_roadmB_PP1(self):
         response = test_utils.connect_xpdr_to_rdm_request("SPDR-SB1", "2", "1",
                                                           "ROADM-B1", "1", "SRG1-PP1-TXRX")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -228,7 +228,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res["output"]["result"])
         time.sleep(2)
 
-    def test_12_connect_roadmB_PP1_to_spdrB_2_N1(self):
+    def test_012_connect_roadmB_PP1_to_spdrB_2_N1(self):
         response = test_utils.connect_rdm_to_xpdr_request("SPDR-SB1", "2", "1",
                                                           "ROADM-B1", "1", "SRG1-PP1-TXRX")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -237,7 +237,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res["output"]["result"])
         time.sleep(2)
 
-    def test_13_connect_sprdB_2_N2_to_roadmB_PP2(self):
+    def test_013_connect_sprdB_2_N2_to_roadmB_PP2(self):
         response = test_utils.connect_xpdr_to_rdm_request("SPDR-SB1", "2", "2",
                                                           "ROADM-B1", "1", "SRG1-PP2-TXRX")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -246,7 +246,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res["output"]["result"])
         time.sleep(2)
 
-    def test_14_connect_roadmB_PP2_to_spdrB_2_N2(self):
+    def test_014_connect_roadmB_PP2_to_spdrB_2_N2(self):
         response = test_utils.connect_rdm_to_xpdr_request("SPDR-SB1", "2", "2",
                                                           "ROADM-B1", "1", "SRG1-PP2-TXRX")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -255,7 +255,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res["output"]["result"])
         time.sleep(2)
 
-    def test_15_add_omsAttributes_ROADMA_ROADMB(self):
+    def test_015_add_omsAttributes_ROADMA_ROADMB(self):
         # Config ROADMA-ROADMB oms-attributes
         data = {"span": {
             "auto-spanloss": "true",
@@ -271,7 +271,7 @@ class TransportPCEtesting(unittest.TestCase):
             "ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
         self.assertEqual(response.status_code, requests.codes.created)
 
-    def test_16_add_omsAttributes_ROADMB_ROADMA(self):
+    def test_016_add_omsAttributes_ROADMB_ROADMA(self):
         # Config ROADMB-ROADMA oms-attributes
         data = {"span": {
             "auto-spanloss": "true",
@@ -287,7 +287,7 @@ class TransportPCEtesting(unittest.TestCase):
             "ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
         self.assertEqual(response.status_code, requests.codes.created)
 
-    def test_17_add_omsAttributes_ROADMB_ROADMC(self):
+    def test_017_add_omsAttributes_ROADMB_ROADMC(self):
         # Config ROADMB-ROADMC oms-attributes
         data = {"span": {
             "auto-spanloss": "true",
@@ -303,7 +303,7 @@ class TransportPCEtesting(unittest.TestCase):
             "ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
         self.assertEqual(response.status_code, requests.codes.created)
 
-    def test_18_add_omsAttributes_ROADMC_ROADMB(self):
+    def test_018_add_omsAttributes_ROADMC_ROADMB(self):
         # Config ROADMC-ROADMB oms-attributes
         data = {"span": {
             "auto-spanloss": "true",
@@ -319,7 +319,7 @@ class TransportPCEtesting(unittest.TestCase):
             "ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data)
         self.assertEqual(response.status_code, requests.codes.created)
 
-    def test_19_create_OTS_ROADMA_DEG1(self):
+    def test_019_create_OTS_ROADMA_DEG1(self):
         response = test_utils.create_ots_oms_request("ROADM-A1", "DEG1-TTP-TXRX")
         time.sleep(10)
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -327,7 +327,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADM-A1',
                       res["output"]["result"])
 
-    def test_20_create_OTS_ROADMB_DEG1(self):
+    def test_020_create_OTS_ROADMB_DEG1(self):
         response = test_utils.create_ots_oms_request("ROADM-B1", "DEG1-TTP-TXRX")
         time.sleep(10)
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -335,7 +335,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADM-B1',
                       res["output"]["result"])
 
-    def test_21_create_OTS_ROADMB_DEG2(self):
+    def test_021_create_OTS_ROADMB_DEG2(self):
         response = test_utils.create_ots_oms_request("ROADM-B1", "DEG2-TTP-TXRX")
         time.sleep(10)
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -343,7 +343,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADM-B1',
                       res["output"]["result"])
 
-    def test_22_create_OTS_ROADMC_DEG2(self):
+    def test_022_create_OTS_ROADMC_DEG2(self):
         response = test_utils.create_ots_oms_request("ROADM-C1", "DEG2-TTP-TXRX")
         time.sleep(10)
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -351,7 +351,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADM-C1',
                       res["output"]["result"])
 
-    def test_23_calculate_span_loss_base_all(self):
+    def test_023_calculate_span_loss_base_all(self):
         url = "{}/operations/transportpce-olm:calculate-spanloss-base"
         data = {
             "input": {
@@ -389,7 +389,7 @@ class TransportPCEtesting(unittest.TestCase):
         }, res["output"]["spans"])
         time.sleep(5)
 
-    def test_24_check_otn_topology(self):
+    def test_024_check_otn_topology(self):
         response = test_utils.get_otn_topo_request()
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -399,7 +399,7 @@ class TransportPCEtesting(unittest.TestCase):
                          'otn-topology should have no link')
 
 # test service-create for OCH-OTU4 service from spdrA to spdrB
-    def test_25_create_OCH_OTU4_service_AB(self):
+    def test_025_create_OCH_OTU4_service_AB(self):
         response = test_utils.service_create_request(self.cr_serv_sample_data)
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -407,7 +407,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res['output']['configuration-response-common']['response-message'])
         time.sleep(self.WAITING)
 
-    def test_26_get_OCH_OTU4_service_AB(self):
+    def test_026_get_OCH_OTU4_service_AB(self):
         response = test_utils.get_service_list_request(
             "services/service-OCH-OTU4-AB")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -423,7 +423,7 @@ class TransportPCEtesting(unittest.TestCase):
         time.sleep(2)
 
 # Check correct configuration of devices
-    def test_27_check_interface_och_spdra(self):
+    def test_027_check_interface_och_spdra(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SA1", "interface/XPDR2-NETWORK1-761:768")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -441,7 +441,7 @@ class TransportPCEtesting(unittest.TestCase):
              'transmit-power': -5, 'modulation-format': 'dp-qpsk'},
             res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
 
-    def test_28_check_interface_OTU4_spdra(self):
+    def test_028_check_interface_OTU4_spdra(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SA1", "interface/XPDR2-NETWORK1-OTU")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -466,8 +466,16 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertDictEqual(input_dict_2,
                              res['interface'][0]
                              ['org-openroadm-otn-otu-interfaces:otu'])
-
-    def test_29_check_interface_och_spdrB(self):
+        response2 = test_utils.check_netconf_node_request(
+            "SPDR-SB1", "interface/XPDR2-NETWORK1-OTU/otu")
+        self.assertEqual(response2.status_code, requests.codes.ok)
+        res2 = response2.json()['org-openroadm-otn-otu-interfaces:otu']
+        self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+        self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
+
+    def test_029_check_interface_och_spdrB(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SB1", "interface/XPDR2-NETWORK1-761:768")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -485,7 +493,7 @@ class TransportPCEtesting(unittest.TestCase):
              'transmit-power': -5, 'modulation-format': 'dp-qpsk'},
             res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
 
-    def test_30_check_interface_OTU4_spdrB(self):
+    def test_030_check_interface_OTU4_spdrB(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SB1", "interface/XPDR2-NETWORK1-OTU")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -511,8 +519,16 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertDictEqual(input_dict_2,
                              res['interface'][0]
                              ['org-openroadm-otn-otu-interfaces:otu'])
+        response2 = test_utils.check_netconf_node_request(
+            "SPDR-SA1", "interface/XPDR2-NETWORK1-OTU/otu")
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res2 = response2.json()['org-openroadm-otn-otu-interfaces:otu']
+        self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+        self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
 
-    def test_31_check_no_interface_ODU4_spdra(self):
+    def test_031_check_no_interface_ODU4_spdra(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SA1", "interface/XPDR2-NETWORK1-ODU4")
         self.assertEqual(response.status_code, requests.codes.conflict)
@@ -522,7 +538,7 @@ class TransportPCEtesting(unittest.TestCase):
              "error-message": "Request could not be completed because the relevant data model content does not exist"},
             res['errors']['error'])
 
-    def test_32_check_openroadm_topo_spdra(self):
+    def test_032_check_openroadm_topo_spdra(self):
         response = test_utils.get_ordm_topo_request("node/SPDR-SA1-XPDR2")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -535,7 +551,7 @@ class TransportPCEtesting(unittest.TestCase):
                          ele['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'])
         time.sleep(3)
 
-    def test_33_check_openroadm_topo_ROADMA_SRG(self):
+    def test_033_check_openroadm_topo_ROADMA_SRG(self):
         response = test_utils.get_ordm_topo_request("node/ROADM-A1-SRG1")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -554,7 +570,7 @@ class TransportPCEtesting(unittest.TestCase):
                 self.assertNotIn('avail-freq-maps', dict.keys(ele))
         time.sleep(3)
 
-    def test_33_check_openroadm_topo_ROADMA_DEG1(self):
+    def test_034_check_openroadm_topo_ROADMA_DEG1(self):
         response = test_utils.get_ordm_topo_request("node/ROADM-A1-DEG1")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -576,7 +592,7 @@ class TransportPCEtesting(unittest.TestCase):
                 self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
         time.sleep(3)
 
-    def test_34_check_otn_topo_otu4_links(self):
+    def test_035_check_otn_topo_otu4_links(self):
         response = test_utils.get_otn_topo_request()
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -597,8 +613,10 @@ class TransportPCEtesting(unittest.TestCase):
             self.assertIn(
                 link['org-openroadm-common-network:opposite-link'], listLinkId)
 
+
 # test service-create for OCH-OTU4 service from spdrB to spdrC
-    def test_35_create_OCH_OTU4_service_BC(self):
+
+    def test_036_create_OCH_OTU4_service_BC(self):
         # pylint: disable=line-too-long
         self.cr_serv_sample_data["input"]["service-name"] = "service-OCH-OTU4-BC"
         self.cr_serv_sample_data["input"]["service-a-end"]["node-id"] = "SPDR-SB1"
@@ -621,7 +639,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res['output']['configuration-response-common']['response-message'])
         time.sleep(self.WAITING)
 
-    def test_36_get_OCH_OTU4_service_BC(self):
+    def test_037_get_OCH_OTU4_service_BC(self):
         response = test_utils.get_service_list_request(
             "services/service-OCH-OTU4-BC")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -637,7 +655,7 @@ class TransportPCEtesting(unittest.TestCase):
         time.sleep(2)
 
 # Check correct configuration of devices
-    def test_37_check_interface_och_spdrB(self):
+    def test_038_check_interface_och_spdrB(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SB1", "interface/XPDR2-NETWORK2-753:760")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -655,7 +673,7 @@ class TransportPCEtesting(unittest.TestCase):
              'transmit-power': -5, 'modulation-format': 'dp-qpsk'},
             res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
 
-    def test_38_check_interface_OTU4_spdrB(self):
+    def test_039_check_interface_OTU4_spdrB(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SB1", "interface/XPDR2-NETWORK2-OTU")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -680,8 +698,16 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertDictEqual(input_dict_2,
                              res['interface'][0]
                              ['org-openroadm-otn-otu-interfaces:otu'])
+        response2 = test_utils.check_netconf_node_request(
+            "SPDR-SC1", "interface/XPDR2-NETWORK1-OTU/otu")
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res2 = response2.json()['org-openroadm-otn-otu-interfaces:otu']
+        self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+        self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
 
-    def test_39_check_interface_och_spdrC(self):
+    def test_040_check_interface_och_spdrC(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SC1", "interface/XPDR2-NETWORK1-753:760")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -699,7 +725,7 @@ class TransportPCEtesting(unittest.TestCase):
              'transmit-power': -5, 'modulation-format': 'dp-qpsk'},
             res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
 
-    def test_40_check_interface_OTU4_spdrC(self):
+    def test_041_check_interface_OTU4_spdrC(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SC1", "interface/XPDR2-NETWORK1-OTU")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -725,8 +751,16 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertDictEqual(input_dict_2,
                              res['interface'][0]
                              ['org-openroadm-otn-otu-interfaces:otu'])
+        response2 = test_utils.check_netconf_node_request(
+            "SPDR-SB1", "interface/XPDR2-NETWORK2-OTU/otu")
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res2 = response2.json()['org-openroadm-otn-otu-interfaces:otu']
+        self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+        self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
 
-    def test_41_check_no_interface_ODU4_spdrB(self):
+    def test_042_check_no_interface_ODU4_spdrB(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SB1", "interface/XPDR2-NETWORK1-ODU4")
         self.assertEqual(response.status_code, requests.codes.conflict)
@@ -736,7 +770,7 @@ class TransportPCEtesting(unittest.TestCase):
              "error-message": "Request could not be completed because the relevant data model content does not exist"},
             res['errors']['error'])
 
-    def test_42_check_openroadm_topo_spdrB(self):
+    def test_043_check_openroadm_topo_spdrB(self):
         response = test_utils.get_ordm_topo_request("node/SPDR-SB1-XPDR2")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -760,7 +794,7 @@ class TransportPCEtesting(unittest.TestCase):
                 self.assertNotIn('org-openroadm-network-topology:xpdr-network-attributes', dict.keys(ele))
         time.sleep(3)
 
-    def test_43_check_openroadm_topo_ROADMB_SRG1(self):
+    def test_044_check_openroadm_topo_ROADMB_SRG1(self):
         response = test_utils.get_ordm_topo_request("node/ROADM-B1-SRG1")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -786,7 +820,7 @@ class TransportPCEtesting(unittest.TestCase):
                 self.assertNotIn('avail-freq-maps', dict.keys(ele))
         time.sleep(3)
 
-    def test_44_check_openroadm_topo_ROADMB_DEG2(self):
+    def test_045_check_openroadm_topo_ROADMB_DEG2(self):
         response = test_utils.get_ordm_topo_request("node/ROADM-B1-DEG2")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -808,7 +842,7 @@ class TransportPCEtesting(unittest.TestCase):
                 self.assertEqual(freq_map_array[94], 0, "Lambda 1 should not be available")
         time.sleep(3)
 
-    def test_45_check_otn_topo_otu4_links(self):
+    def test_046_check_otn_topo_otu4_links(self):
         response = test_utils.get_otn_topo_request()
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -832,7 +866,7 @@ class TransportPCEtesting(unittest.TestCase):
                 link['org-openroadm-common-network:opposite-link'], listLinkId)
 
 # test service-create for 100GE service from spdrA to spdrC via spdrB
-    def test_46_create_100GE_service_ABC(self):
+    def test_047_create_100GE_service_ABC(self):
         # pylint: disable=line-too-long
         self.cr_serv_sample_data["input"]["service-name"] = "service-100GE-ABC"
         self.cr_serv_sample_data["input"]["connection-type"] = "service"
@@ -860,7 +894,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res['output']['configuration-response-common']['response-message'])
         time.sleep(self.WAITING)
 
-    def test_47_get_100GE_service_ABC(self):
+    def test_048_get_100GE_service_ABC(self):
         response = test_utils.get_service_list_request(
             "services/service-100GE-ABC")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -875,7 +909,7 @@ class TransportPCEtesting(unittest.TestCase):
             res['services'][0]['lifecycle-state'], 'planned')
         time.sleep(2)
 
-    def test_48_check_interface_100GE_CLIENT_spdra(self):
+    def test_049_check_interface_100GE_CLIENT_spdra(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SA1", "interface/XPDR2-CLIENT1-ETHERNET")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -893,7 +927,7 @@ class TransportPCEtesting(unittest.TestCase):
              'fec': 'off'},
             res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
 
-    def test_49_check_interface_ODU4_CLIENT_spdra(self):
+    def test_050_check_interface_ODU4_CLIENT_spdra(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SA1", "interface/XPDR2-CLIENT1-ODU4")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -921,8 +955,16 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertDictEqual(
             {'payload-type': '21', 'exp-payload-type': '21'},
             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
+        response2 = test_utils.check_netconf_node_request(
+            "SPDR-SC1", "interface/XPDR2-CLIENT1-ODU4")
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res2 = response2.json()['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
+        self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+        self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
 
-    def test_50_check_interface_ODU4_NETWORK_spdra(self):
+    def test_051_check_interface_ODU4_NETWORK_spdra(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SA1", "interface/XPDR2-NETWORK1-ODU4")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -947,7 +989,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertNotIn('opu',
                          dict.keys(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
 
-    def test_51_check_ODU4_connection_spdra(self):
+    def test_052_check_ODU4_connection_spdra(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SA1",
             "odu-connection/XPDR2-CLIENT1-ODU4-x-XPDR2-NETWORK1-ODU4")
@@ -966,7 +1008,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertDictEqual({'src-if': 'XPDR2-CLIENT1-ODU4'},
                              res['odu-connection'][0]['source'])
 
-    def test_52_check_interface_100GE_CLIENT_spdrc(self):
+    def test_053_check_interface_100GE_CLIENT_spdrc(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SC1", "interface/XPDR2-CLIENT1-ETHERNET")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -984,7 +1026,7 @@ class TransportPCEtesting(unittest.TestCase):
              'fec': 'off'},
             res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
 
-    def test_53_check_interface_ODU4_CLIENT_spdrc(self):
+    def test_054_check_interface_ODU4_CLIENT_spdrc(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SC1", "interface/XPDR2-CLIENT1-ODU4")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -1014,8 +1056,16 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertDictEqual(
             {'payload-type': '21', 'exp-payload-type': '21'},
             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
+        response2 = test_utils.check_netconf_node_request(
+            "SPDR-SA1", "interface/XPDR2-CLIENT1-ODU4")
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res2 = response2.json()['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
+        self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+        self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
 
-    def test_54_check_interface_ODU4_NETWORK_spdrc(self):
+    def test_055_check_interface_ODU4_NETWORK_spdrc(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SC1", "interface/XPDR2-NETWORK1-ODU4")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -1040,7 +1090,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertNotIn('opu',
                          dict.keys(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
 
-    def test_55_check_ODU4_connection_spdrc(self):
+    def test_056_check_ODU4_connection_spdrc(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SC1",
             "odu-connection/XPDR2-CLIENT1-ODU4-x-XPDR2-NETWORK1-ODU4")
@@ -1059,7 +1109,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertDictEqual({'src-if': 'XPDR2-CLIENT1-ODU4'},
                              res['odu-connection'][0]['source'])
 
-    def test_56_check_interface_ODU4_NETWORK1_spdrb(self):
+    def test_057_check_interface_ODU4_NETWORK1_spdrb(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SB1", "interface/XPDR2-NETWORK1-ODU4")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -1082,7 +1132,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertNotIn('opu',
                          dict.keys(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
 
-    def test_57_check_interface_ODU4_NETWORK2_spdrb(self):
+    def test_058_check_interface_ODU4_NETWORK2_spdrb(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SB1", "interface/XPDR2-NETWORK2-ODU4")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -1105,7 +1155,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertNotIn('opu',
                          dict.keys(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
 
-    def test_58_check_ODU4_connection_spdrb(self):
+    def test_059_check_ODU4_connection_spdrb(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SB1",
             "odu-connection/XPDR2-NETWORK1-ODU4-x-XPDR2-NETWORK2-ODU4")
@@ -1124,7 +1174,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertDictEqual({'src-if': 'XPDR2-NETWORK1-ODU4'},
                              res['odu-connection'][0]['source'])
 
-    def test_59_check_otn_topo_links(self):
+    def test_060_check_otn_topo_links(self):
         response = test_utils.get_otn_topo_request()
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -1136,7 +1186,7 @@ class TransportPCEtesting(unittest.TestCase):
             self.assertEqual(
                 link['org-openroadm-otn-network-topology:used-bandwidth'], 100000)
 
-    def test_60_delete_service_100GE_ABC(self):
+    def test_061_delete_service_100GE_ABC(self):
         response = test_utils.service_delete_request("service-100GE-ABC")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -1144,39 +1194,39 @@ class TransportPCEtesting(unittest.TestCase):
                       res['output']['configuration-response-common']['response-message'])
         time.sleep(self.WAITING)
 
-    def test_61_check_service_list(self):
+    def test_062_check_service_list(self):
         response = test_utils.get_service_list_request("")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertEqual(len(res['service-list']['services']), 2)
         time.sleep(2)
 
-    def test_62_check_no_ODU4_connection_spdra(self):
+    def test_063_check_no_ODU4_connection_spdra(self):
         response = test_utils.check_netconf_node_request("SPDR-SA1", "")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertNotIn(['odu-connection'][0], res['org-openroadm-device'])
         time.sleep(1)
 
-    def test_63_check_no_interface_ODU4_NETWORK_spdra(self):
+    def test_064_check_no_interface_ODU4_NETWORK_spdra(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SA1", "interface/XPDR2-NETWORK1-ODU4")
         self.assertEqual(response.status_code, requests.codes.conflict)
 
-    def test_64_check_no_interface_ODU4_CLIENT_spdra(self):
+    def test_065_check_no_interface_ODU4_CLIENT_spdra(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SA1", "interface/XPDR2-CLIENT1-ODU4")
         self.assertEqual(response.status_code, requests.codes.conflict)
 
-    def test_65_check_no_interface_100GE_CLIENT_spdra(self):
+    def test_066_check_no_interface_100GE_CLIENT_spdra(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SA1", "interface/XPDR2-CLIENT1-ETHERNET")
         self.assertEqual(response.status_code, requests.codes.conflict)
 
-    def test_66_check_otn_topo_links(self):
-        self.test_45_check_otn_topo_otu4_links()
+    def test_067_check_otn_topo_links(self):
+        self.test_046_check_otn_topo_otu4_links()
 
-    def test_67_delete_OCH_OTU4_service_AB(self):
+    def test_068_delete_OCH_OTU4_service_AB(self):
         response = test_utils.service_delete_request("service-OCH-OTU4-AB")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -1184,7 +1234,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res['output']['configuration-response-common']['response-message'])
         time.sleep(self.WAITING)
 
-    def test_68_delete_OCH_OTU4_service_BC(self):
+    def test_069_delete_OCH_OTU4_service_BC(self):
         response = test_utils.service_delete_request("service-OCH-OTU4-BC")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -1192,7 +1242,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res['output']['configuration-response-common']['response-message'])
         time.sleep(self.WAITING)
 
-    def test_69_get_no_service(self):
+    def test_070_get_no_service(self):
         response = test_utils.get_service_list_request("")
         self.assertEqual(response.status_code, requests.codes.conflict)
         res = response.json()
@@ -1202,23 +1252,23 @@ class TransportPCEtesting(unittest.TestCase):
             res['errors']['error'])
         time.sleep(1)
 
-    def test_70_check_no_interface_OTU4_spdra(self):
+    def test_071_check_no_interface_OTU4_spdra(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SA1", "interface/XPDR2-NETWORK1-OTU")
         self.assertEqual(response.status_code, requests.codes.conflict)
 
-    def test_71_check_no_interface_OCH_spdra(self):
+    def test_072_check_no_interface_OCH_spdra(self):
         response = test_utils.check_netconf_node_request(
             "SPDR-SA1", "interface/XPDR2-NETWORK1-761:768")
         self.assertEqual(response.status_code, requests.codes.conflict)
 
-    def test_72_getLinks_OtnTopology(self):
+    def test_073_getLinks_OtnTopology(self):
         response = test_utils.get_otn_topo_request()
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertNotIn('ietf-network-topology:link', res['network'][0])
 
-    def test_73_check_openroadm_topo_spdra(self):
+    def test_074_check_openroadm_topo_spdra(self):
         response = test_utils.get_ordm_topo_request("node/SPDR-SA1-XPDR2")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -1228,7 +1278,7 @@ class TransportPCEtesting(unittest.TestCase):
             tp['org-openroadm-network-topology:xpdr-network-attributes']))
         time.sleep(3)
 
-    def test_74_check_openroadm_topo_ROADMB_SRG1(self):
+    def test_075_check_openroadm_topo_ROADMB_SRG1(self):
         response = test_utils.get_ordm_topo_request("node/ROADM-B1-SRG1")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -1251,7 +1301,7 @@ class TransportPCEtesting(unittest.TestCase):
                 self.assertEqual(freq_map_array[94], 255, "Lambda 1 should be available")
         time.sleep(3)
 
-    def test_75_check_openroadm_topo_ROADMB_DEG1(self):
+    def test_076_check_openroadm_topo_ROADMB_DEG1(self):
         response = test_utils.get_ordm_topo_request("node/ROADM-B1-DEG1")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -1273,7 +1323,7 @@ class TransportPCEtesting(unittest.TestCase):
                 self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available")
         time.sleep(3)
 
-    def test_76_check_openroadm_topo_ROADMB_DEG2(self):
+    def test_077_check_openroadm_topo_ROADMB_DEG2(self):
         response = test_utils.get_ordm_topo_request("node/ROADM-B1-DEG2")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -1295,7 +1345,7 @@ class TransportPCEtesting(unittest.TestCase):
                 self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available")
         time.sleep(3)
 
-    def test_77_disconnect_xponders_from_roadm(self):
+    def test_078_disconnect_xponders_from_roadm(self):
         url = "{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"
         response = test_utils.get_ordm_topo_request("")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -1308,17 +1358,17 @@ class TransportPCEtesting(unittest.TestCase):
                 response = test_utils.delete_request(url+link_name)
                 self.assertEqual(response.status_code, requests.codes.ok)
 
-    def test_78_disconnect_spdrB(self):
+    def test_079_disconnect_spdrB(self):
         response = test_utils.unmount_device("SPDR-SB1")
         self.assertEqual(response.status_code, requests.codes.ok,
                          test_utils.CODE_SHOULD_BE_200)
 
-    def test_79_disconnect_roadmB(self):
+    def test_080_disconnect_roadmB(self):
         response = test_utils.unmount_device("ROADM-B1")
         self.assertEqual(response.status_code, requests.codes.ok,
                          test_utils.CODE_SHOULD_BE_200)
 
-    def test_80_remove_roadm_to_roadm_links(self):
+    def test_081_remove_roadm_to_roadm_links(self):
         url = "{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"
         response = test_utils.get_ordm_topo_request("")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -1331,7 +1381,7 @@ class TransportPCEtesting(unittest.TestCase):
                 response = test_utils.delete_request(url+link_name)
                 self.assertEqual(response.status_code, requests.codes.ok)
 
-    def test_81_add_omsAttributes_ROADMA_ROADMC(self):
+    def test_082_add_omsAttributes_ROADMA_ROADMC(self):
         # Config ROADMA-ROADMC oms-attributes
         data = {"span": {
             "auto-spanloss": "true",
@@ -1347,7 +1397,7 @@ class TransportPCEtesting(unittest.TestCase):
             "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
         self.assertEqual(response.status_code, requests.codes.created)
 
-    def test_82_add_omsAttributes_ROADMC_ROADMA(self):
+    def test_083_add_omsAttributes_ROADMC_ROADMA(self):
         # Config ROADMC-ROADMA oms-attributes
         data = {"span": {
             "auto-spanloss": "true",
@@ -1363,7 +1413,7 @@ class TransportPCEtesting(unittest.TestCase):
             "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
         self.assertEqual(response.status_code, requests.codes.created)
 
-    def test_83_create_OCH_OTU4_service_AC(self):
+    def test_084_create_OCH_OTU4_service_AC(self):
         # pylint: disable=line-too-long
         self.cr_serv_sample_data["input"]["service-name"] = "service-OCH-OTU4-AC"
         self.cr_serv_sample_data["input"]["connection-type"] = "infrastructure"
@@ -1388,7 +1438,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res['output']['configuration-response-common']['response-message'])
         time.sleep(self.WAITING)
 
-    def test_84_get_OCH_OTU4_service_AC(self):
+    def test_085_get_OCH_OTU4_service_AC(self):
         response = test_utils.get_service_list_request(
             "services/service-OCH-OTU4-AC")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -1404,7 +1454,7 @@ class TransportPCEtesting(unittest.TestCase):
         time.sleep(2)
 
 # test service-create for 100GE service from spdrA to spdrC via spdrB
-    def test_85_create_100GE_service_AC(self):
+    def test_086_create_100GE_service_AC(self):
         # pylint: disable=line-too-long
         self.cr_serv_sample_data["input"]["service-name"] = "service-100GE-AC"
         self.cr_serv_sample_data["input"]["connection-type"] = "service"
@@ -1432,7 +1482,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res['output']['configuration-response-common']['response-message'])
         time.sleep(self.WAITING)
 
-    def test_86_get_100GE_service_AC(self):
+    def test_087_get_100GE_service_AC(self):
         response = test_utils.get_service_list_request("services/service-100GE-AC")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -1446,19 +1496,87 @@ class TransportPCEtesting(unittest.TestCase):
             res['services'][0]['lifecycle-state'], 'planned')
         time.sleep(2)
 
-    def test_87_check_configuration_spdra(self):
-        self.test_48_check_interface_100GE_CLIENT_spdra()
-        self.test_49_check_interface_ODU4_CLIENT_spdra()
-        self.test_50_check_interface_ODU4_NETWORK_spdra()
-        self.test_51_check_ODU4_connection_spdra()
+    def test_088_check_interface_OTU4_spdra(self):
+        response = test_utils.check_netconf_node_request(
+            "SPDR-SA1", "interface/XPDR2-NETWORK1-OTU")
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        input_dict_1 = {'name': 'XPDR2-NETWORK1-OTU',
+                        'administrative-state': 'inService',
+                        'supporting-circuit-pack-name': 'CP5-CFP',
+                        'supporting-interface': 'XPDR2-NETWORK1-761:768',
+                        'type': 'org-openroadm-interfaces:otnOtu',
+                        'supporting-port': 'CP5-CFP-P1'
+                        }
+        input_dict_2 = {'tx-sapi': 'AOQxIv+6nCD+',
+                        'expected-dapi': 'AOQxIv+6nCD+',
+                        'tx-dapi': 'ALvne1QI5jo4',
+                        'expected-sapi': 'ALvne1QI5jo4',
+                        'rate': 'org-openroadm-otn-common-types:OTU4',
+                        'fec': 'scfec'
+                        }
+        self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
+                             res['interface'][0])
+
+        self.assertDictEqual(input_dict_2,
+                             res['interface'][0]
+                             ['org-openroadm-otn-otu-interfaces:otu'])
+        response2 = test_utils.check_netconf_node_request(
+            "SPDR-SC1", "interface/XPDR2-NETWORK1-OTU/otu")
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res2 = response2.json()['org-openroadm-otn-otu-interfaces:otu']
+        self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+        self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
 
-    def test_88_check_configuration_spdrc(self):
-        self.test_52_check_interface_100GE_CLIENT_spdrc()
-        self.test_53_check_interface_ODU4_CLIENT_spdrc()
-        self.test_54_check_interface_ODU4_NETWORK_spdrc()
-        self.test_55_check_ODU4_connection_spdrc()
+    def test_089_check_interface_OTU4_spdrC(self):
+        response = test_utils.check_netconf_node_request(
+            "SPDR-SC1", "interface/XPDR2-NETWORK1-OTU")
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        input_dict_1 = {'name': 'XPDR2-NETWORK1-OTU',
+                        'administrative-state': 'inService',
+                        'supporting-circuit-pack-name': 'CP5-CFP',
+                        'supporting-interface': 'XPDR2-NETWORK1-753:760',
+                        'type': 'org-openroadm-interfaces:otnOtu',
+                        'supporting-port': 'CP5-CFP-P1'
+                        }
+        input_dict_2 = {'tx-dapi': 'AOQxIv+6nCD+',
+                        'expected-sapi': 'AOQxIv+6nCD+',
+                        'tx-sapi': 'ALvne1QI5jo4',
+                        'expected-dapi': 'ALvne1QI5jo4',
+                        'rate': 'org-openroadm-otn-common-types:OTU4',
+                        'fec': 'scfec'
+                        }
 
-    def test_89_check_otn_topo_links(self):
+        self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
+                             res['interface'][0])
+        self.assertDictEqual(input_dict_2,
+                             res['interface'][0]
+                             ['org-openroadm-otn-otu-interfaces:otu'])
+        response2 = test_utils.check_netconf_node_request(
+            "SPDR-SA1", "interface/XPDR2-NETWORK1-OTU/otu")
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res2 = response2.json()['org-openroadm-otn-otu-interfaces:otu']
+        self.assertEqual(input_dict_2['tx-sapi'], res2['tx-dapi'])
+        self.assertEqual(input_dict_2['tx-sapi'], res2['expected-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['tx-sapi'])
+        self.assertEqual(input_dict_2['tx-dapi'], res2['expected-dapi'])
+
+    def test_090_check_configuration_spdra(self):
+        self.test_049_check_interface_100GE_CLIENT_spdra()
+        self.test_050_check_interface_ODU4_CLIENT_spdra()
+        self.test_051_check_interface_ODU4_NETWORK_spdra()
+        self.test_052_check_ODU4_connection_spdra()
+
+    def test_091_check_configuration_spdrc(self):
+        self.test_053_check_interface_100GE_CLIENT_spdrc()
+        self.test_054_check_interface_ODU4_CLIENT_spdrc()
+        self.test_055_check_interface_ODU4_NETWORK_spdrc()
+        self.test_056_check_ODU4_connection_spdrc()
+
+    def test_092_check_otn_topo_links(self):
         response = test_utils.get_otn_topo_request()
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -1470,7 +1588,7 @@ class TransportPCEtesting(unittest.TestCase):
             self.assertEqual(
                 link['org-openroadm-otn-network-topology:used-bandwidth'], 100000)
 
-    def test_90_delete_100GE_service_AC(self):
+    def test_093_delete_100GE_service_AC(self):
         response = test_utils.service_delete_request("service-100GE-AC")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -1478,20 +1596,20 @@ class TransportPCEtesting(unittest.TestCase):
                       res['output']['configuration-response-common']['response-message'])
         time.sleep(self.WAITING)
 
-    def test_91_check_service_list(self):
+    def test_094_check_service_list(self):
         response = test_utils.get_service_list_request("")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertEqual(len(res['service-list']['services']), 1)
         time.sleep(2)
 
-    def test_92_check_configuration_spdra(self):
-        self.test_62_check_no_ODU4_connection_spdra()
-        self.test_63_check_no_interface_ODU4_NETWORK_spdra()
-        self.test_64_check_no_interface_ODU4_CLIENT_spdra()
-        self.test_65_check_no_interface_100GE_CLIENT_spdra()
+    def test_095_check_configuration_spdra(self):
+        self.test_063_check_no_ODU4_connection_spdra()
+        self.test_064_check_no_interface_ODU4_NETWORK_spdra()
+        self.test_065_check_no_interface_ODU4_CLIENT_spdra()
+        self.test_066_check_no_interface_100GE_CLIENT_spdra()
 
-    def test_93_check_otn_topo_links(self):
+    def test_096_check_otn_topo_links(self):
         response = test_utils.get_otn_topo_request()
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -1503,7 +1621,7 @@ class TransportPCEtesting(unittest.TestCase):
             self.assertEqual(
                 link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
 
-    def test_94_disconnect_xponders_from_roadm(self):
+    def test_097_disconnect_xponders_from_roadm(self):
         url = "{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"
         response = test_utils.get_ordm_topo_request("")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -1515,22 +1633,22 @@ class TransportPCEtesting(unittest.TestCase):
                 response = test_utils.delete_request(url+link_name)
                 self.assertEqual(response.status_code, requests.codes.ok)
 
-    def test_95_disconnect_spdrA(self):
+    def test_098_disconnect_spdrA(self):
         response = test_utils.unmount_device("SPDR-SA1")
         self.assertEqual(response.status_code, requests.codes.ok,
                          test_utils.CODE_SHOULD_BE_200)
 
-    def test_96_disconnect_spdrC(self):
+    def test_099_disconnect_spdrC(self):
         response = test_utils.unmount_device("SPDR-SC1")
         self.assertEqual(response.status_code, requests.codes.ok,
                          test_utils.CODE_SHOULD_BE_200)
 
-    def test_97_disconnect_roadmA(self):
+    def test_100_disconnect_roadmA(self):
         response = test_utils.unmount_device("ROADM-A1")
         self.assertEqual(response.status_code, requests.codes.ok,
                          test_utils.CODE_SHOULD_BE_200)
 
-    def test_98_disconnect_roadmC(self):
+    def test_101_disconnect_roadmC(self):
         response = test_utils.unmount_device("ROADM-C1")
         self.assertEqual(response.status_code, requests.codes.ok,
                          test_utils.CODE_SHOULD_BE_200)

diff --git a/tests/transportpce_tests/hybrid/test02_B100G_end2end.py b/tests/transportpce_tests/hybrid/test02_B100G_end2end.py
index 85c308a13309adda148a416749dfb9fd07d95360..aa49014e03a459d7edf7a4e5b4e373968eeb76df 100644 (file)
--- a/tests/transportpce_tests/hybrid/test02_B100G_end2end.py
+++ b/tests/transportpce_tests/hybrid/test02_B100G_end2end.py
@@ -336,7 +336,11 @@ class TransportPCEtesting(unittest.TestCase):
                         'type': 'org-openroadm-interfaces:otnOtu',
                         'supporting-port': 'L1'
                         }
-        input_dict_2 = {'rate': 'org-openroadm-otn-common-types:OTUCn',
+        input_dict_2 = {'tx-sapi': 'G54UFNImtOE=',
+                        'expected-dapi': 'G54UFNImtOE=',
+                        'tx-dapi': 'J/FIUzQc+4M=',
+                        'expected-sapi': 'J/FIUzQc+4M=',
+                        'rate': 'org-openroadm-otn-common-types:OTUCn',
                         'degthr-percentage': 100,
                         'degm-intervals': 2,
                         'otucn-n-rate': 4
@@ -400,7 +404,11 @@ class TransportPCEtesting(unittest.TestCase):
                         'type': 'org-openroadm-interfaces:otnOtu',
                         'supporting-port': 'L1'
                         }
-        input_dict_2 = {'rate': 'org-openroadm-otn-common-types:OTUCn',
+        input_dict_2 = {'tx-dapi': 'G54UFNImtOE=',
+                        'expected-sapi': 'G54UFNImtOE=',
+                        'tx-sapi': 'J/FIUzQc+4M=',
+                        'expected-dapi': 'J/FIUzQc+4M=',
+                        'rate': 'org-openroadm-otn-common-types:OTUCn',
                         'degthr-percentage': 100,
                         'degm-intervals': 2,
                         'otucn-n-rate': 4
@@ -1090,7 +1098,7 @@ class TransportPCEtesting(unittest.TestCase):
         links = res['network'][0]['ietf-network-topology:link']
         self.assertEqual(22, len(links), 'Topology should contain 22 links')
 
-    def test_68_connect_xprda2_2_N1_to_roadma_PP2(self):
+    def test_68_connect_xprda2_1_N1_to_roadma_PP2(self):
         response = test_utils.connect_xpdr_to_rdm_request("XPDR-A2", "1", "1",
                                                           "ROADM-A1", "1", "SRG1-PP1-TXRX")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -1099,7 +1107,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res["output"]["result"])
         time.sleep(2)
 
-    def test_69_connect_roadma_PP2_to_xpdra2_2_N1(self):
+    def test_69_connect_roadma_PP2_to_xpdra2_1_N1(self):
         response = test_utils.connect_rdm_to_xpdr_request("XPDR-A2", "1", "1",
                                                           "ROADM-A1", "1", "SRG1-PP1-TXRX")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -1108,7 +1116,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res["output"]["result"])
         time.sleep(2)
 
-    def test_70_connect_xprdc2_2_N1_to_roadmc_PP2(self):
+    def test_70_connect_xprdc2_1_N1_to_roadmc_PP2(self):
         response = test_utils.connect_xpdr_to_rdm_request("XPDR-C2", "1", "1",
                                                           "ROADM-C1", "1", "SRG1-PP1-TXRX")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -1117,7 +1125,7 @@ class TransportPCEtesting(unittest.TestCase):
                       res["output"]["result"])
         time.sleep(2)
 
-    def test_71_connect_roadmc_PP2_to_xpdrc2_2_N1(self):
+    def test_71_connect_roadmc_PP2_to_xpdrc2_1_N1(self):
         response = test_utils.connect_rdm_to_xpdr_request("XPDR-C2", "1", "1",
                                                           "ROADM-C1", "1", "SRG1-PP1-TXRX")
         self.assertEqual(response.status_code, requests.codes.ok)
@@ -1306,7 +1314,11 @@ class TransportPCEtesting(unittest.TestCase):
                         ['supporting-interface-list'][0]: 'XPDR1-NETWORK1-OTSI-GROUP',
                         'type': 'org-openroadm-interfaces:otnOtu',
                         'supporting-port': 'L1'}
-        input_dict_2 = {"rate": "org-openroadm-otn-common-types:OTUCn",
+        input_dict_2 = {"tx-sapi": "ANeUjNzWtDLV",
+                        "expected-dapi": "ANeUjNzWtDLV",
+                        'tx-dapi': 'AKsqPmWceByv',
+                        'expected-sapi': 'AKsqPmWceByv',
+                        "rate": "org-openroadm-otn-common-types:OTUCn",
                         "degthr-percentage": 100,
                         "tim-detect-mode": "Disabled",
                         "otucn-n-rate": 4,
@@ -1318,7 +1330,6 @@ class TransportPCEtesting(unittest.TestCase):
                                   **res['interface'][0]['org-openroadm-otn-otu-interfaces:otu']),
                              res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
 
-    @unittest.skip("Temporary skipped waiting for the rest of the functionality in change 97834")
     def test_82_check_interface_ODUC4_xpdra2(self):
         response = test_utils.check_netconf_node_request(
             "XPDR-A2", "interface/XPDR1-NETWORK1-ODUC4")
@@ -1327,9 +1338,11 @@ class TransportPCEtesting(unittest.TestCase):
         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODUC4',
                         'administrative-state': 'inService',
                         'supporting-circuit-pack-name': '1/1/2-PLUG-NET',
-                        ['supporting-interface-list'][0]: 'XPDR1-NETWORK1-OTSI-GROUP',
+                        ['supporting-interface-list'][0]: 'XPDR1-NETWORK1-OTUC4',
                         'type': 'org-openroadm-interfaces:otnOdu',
-                        'supporting-port': 'L1'}
+                        'supporting-port': 'L1',
+                        'circuit-id': 'TBD',
+                        'description': 'TBD'}
         input_dict_2 = {"odu-function": "org-openroadm-otn-common-types:ODU-TTP",
                         "tim-detect-mode": "Disabled",
                         "degm-intervals": 2,
@@ -1347,6 +1360,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertDictEqual(dict(input_dict_3,
                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu']),
                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
+        self.assertEqual('XPDR1-NETWORK1-OTUC4', res['interface'][0]['supporting-interface-list'][0])
 
     def test_83_delete_400GE_service(self):
         response = test_utils.service_delete_request("service-400GE")