Functional test for OTN Renderer

New functional test suite for otn renderer. Tests OCH/OTU4/ho-ODU4
creation/deletion, and 10GE/lo-ODU2E creation/deletion.

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

diff --git a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl221.java b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl221.java
index eb01a74c259e6142b5cf06ec1918228e916c704e..3c8c95a1ab09429de9d2a80afc8ec82d8f106b7a 100755 (executable)
--- a/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl221.java
+++ b/common/src/main/java/org/opendaylight/transportpce/common/openroadminterfaces/OpenRoadmInterfacesImpl221.java
@@ -9,7 +9,6 @@
 package org.opendaylight.transportpce.common.openroadminterfaces;
 
 import com.google.common.util.concurrent.FluentFuture;
-
 import java.util.Optional;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
@@ -66,6 +65,7 @@ public class OpenRoadmInterfacesImpl221 {
             throw new OpenRoadmInterfaceException(String.format("Failed to obtain device transaction for node %s!",
                 nodeId), e);
         }
+
         InstanceIdentifier<Interface> interfacesIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(
             Interface.class, new InterfaceKey(ifBuilder.getName()));
         LOG.info("POST INTERF for {} : InterfaceBuilder : name = {} \t type = {}", nodeId, ifBuilder.getName(),

diff --git a/tests/transportpce_tests/2.2.1/test_otn_renderer.py b/tests/transportpce_tests/2.2.1/test_otn_renderer.py
new file mode 100644 (file)
index 0000000..adccedd
--- /dev/null
+++ b/tests/transportpce_tests/2.2.1/test_otn_renderer.py
@@ -0,0 +1,471 @@
+#!/usr/bin/env python
+
+##############################################################################
+# Copyright (c) 2020 Orange, Inc. and others.  All rights reserved.
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Apache License, Version 2.0
+# which accompanies this distribution, and is available at
+# http://www.apache.org/licenses/LICENSE-2.0
+##############################################################################
+
+import json
+import os
+import psutil
+import requests
+import signal
+import shutil
+import subprocess
+import time
+import unittest
+import logging
+import test_utils
+
+
+class TransportPCEtesting(unittest.TestCase):
+
+    honeynode_process1 = None
+    odl_process = None
+    restconf_baseurl = "http://localhost:8181/restconf"
+
+    @classmethod
+    def setUpClass(cls):
+        print ("starting honeynode1...")
+        cls.honeynode_process1 = test_utils.start_spdra_honeynode()
+        time.sleep(30)
+
+        print ("starting opendaylight...")
+        cls.odl_process = test_utils.start_tpce()
+        time.sleep(60)
+        print ("opendaylight started")
+
+    @classmethod
+    def tearDownClass(cls):
+        for child in psutil.Process(cls.odl_process.pid).children():
+            child.send_signal(signal.SIGINT)
+            child.wait()
+        cls.odl_process.send_signal(signal.SIGINT)
+        cls.odl_process.wait()
+        for child in psutil.Process(cls.honeynode_process1.pid).children():
+            child.send_signal(signal.SIGINT)
+            child.wait()
+        cls.honeynode_process1.send_signal(signal.SIGINT)
+        cls.honeynode_process1.wait()
+
+    def setUp(self):
+        time.sleep(5)
+
+    def test_01_connect_SPDR_SA1(self):
+        url = ("{}/config/network-topology:"
+                "network-topology/topology/topology-netconf/node/SPDR-SA1"
+               .format(self.restconf_baseurl))
+        data = {"node": [{
+             "node-id": "SPDR-SA1",
+             "netconf-node-topology:username": "admin",
+             "netconf-node-topology:password": "admin",
+             "netconf-node-topology:host": "127.0.0.1",
+             "netconf-node-topology:port": "17845",
+             "netconf-node-topology:tcp-only": "false",
+             "netconf-node-topology:pass-through": {}}]}
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "PUT", url, data=json.dumps(data), headers=headers,
+             auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.created)
+        time.sleep(10)
+        url = ("{}/operational/network-topology:"
+               "network-topology/topology/topology-netconf/node/SPDR-SA1"
+               .format(self.restconf_baseurl))
+        response = requests.request(
+            "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertEqual(
+            res['node'][0]['netconf-node-topology:connection-status'],
+            'connected')
+
+    def test_02_get_portmapping_CLIENT1(self):
+        url = ("{}/config/transportpce-portmapping:network/"
+               "nodes/SPDR-SA1/mapping/XPDR1-CLIENT1"
+               .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+            "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertIn(
+            {'supported-interface-capability': [
+                'org-openroadm-port-types:if-10GE-ODU2e',
+                'org-openroadm-port-types:if-10GE-ODU2',
+                'org-openroadm-port-types:if-10GE'],
+             'supporting-port': 'CP1-SFP4-P1',
+             'supporting-circuit-pack-name': 'CP1-SFP4',
+             'logical-connection-point': 'XPDR1-CLIENT1', 'port-direction': 'bidirectional',
+             'port-qual': 'xpdr-client'},
+            res['mapping'])
+
+    def test_03_get_portmapping_NETWORK1(self):
+        url = ("{}/config/transportpce-portmapping:network/"
+               "nodes/SPDR-SA1/mapping/XPDR1-NETWORK1"
+               .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+            "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertIn(
+            {"logical-connection-point": "XPDR1-NETWORK1",
+            "supporting-port": "CP1-CFP0-P1",
+            "supported-interface-capability": [
+                "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+            ],
+            "port-direction": "bidirectional",
+            "port-qual": "xpdr-network",
+            "supporting-circuit-pack-name": "CP1-CFP0",
+            "xponder-type": "mpdr"},
+            res['mapping'])
+
+    def test_04_service_path_create_ODU4(self):
+        url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+        data = {"renderer:input": {
+             "service-name": "service_ODU4",
+             "wave-number": "1",
+             "modulation-format": "qpsk",
+             "operation": "create",
+             "nodes": [
+                 {"node-id": "SPDR-SA1",
+                  "dest-tp": "XPDR1-NETWORK1"}]}}
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "POST", url, data=json.dumps(data),
+             headers=headers, auth=('admin', 'admin'))
+        time.sleep(3)
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertIn('Roadm-connection successfully created for nodes: ', res["output"]["result"])
+        self.assertTrue(res["output"]["success"])
+        self.assertIn(
+            {'node-id': 'SPDR-SA1',
+             'otu-interface-id': ['XPDR1-NETWORK1-OTU'],
+             'odu-interface-id': ['XPDR1-NETWORK1-ODU4'],
+             'och-interface-id': ['XPDR1-NETWORK1-1']}, res["output"]['node-interface'])
+
+    def test_05_get_portmapping_NETWORK1(self):
+        url = ("{}/config/transportpce-portmapping:network/"
+               "nodes/SPDR-SA1/mapping/XPDR1-NETWORK1"
+               .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+            "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertIn(
+            {"logical-connection-point": "XPDR1-NETWORK1",
+            "supporting-port": "CP1-CFP0-P1",
+            "supported-interface-capability": [
+                "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+            ],
+            "port-direction": "bidirectional",
+            "port-qual": "xpdr-network",
+            "supporting-circuit-pack-name": "CP1-CFP0",
+            "xponder-type": "mpdr",
+            "supporting-odu4": "XPDR1-NETWORK1-ODU4"},
+            res['mapping'])
+
+    def test_06_check_interface_och(self):
+        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
+                "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+                "interface/XPDR1-NETWORK1-1"
+                .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertDictContainsSubset({'name': 'XPDR1-NETWORK1-1', 'administrative-state': 'inService',
+              'supporting-circuit-pack-name': 'CP1-CFP0',
+              'type': 'org-openroadm-interfaces:opticalChannel',
+              'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
+        self.assertDictEqual(
+             {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
+              u'transmit-power': -5},
+             res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
+
+    def test_07_check_interface_OTU(self):
+        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
+                "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+                "interface/XPDR1-NETWORK1-OTU"
+                .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertDictContainsSubset({'name': 'XPDR1-NETWORK1-OTU', 'administrative-state': 'inService',
+              'supporting-circuit-pack-name': 'CP1-CFP0', 'supporting-interface': 'XPDR1-NETWORK1-1',
+              'type': 'org-openroadm-interfaces:otnOtu',
+              'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
+        self.assertDictEqual(
+             {u'rate': u'org-openroadm-otn-common-types:OTU4',
+              u'fec': u'scfec'},
+             res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
+
+    def test_08_check_interface_ODU4(self):
+        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
+                "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+                "interface/XPDR1-NETWORK1-ODU4"
+                .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertDictContainsSubset({'name': 'XPDR1-NETWORK1-ODU4', 'administrative-state': 'inService',
+              'supporting-circuit-pack-name': 'CP1-CFP0', 'supporting-interface': 'XPDR1-NETWORK1-OTU',
+              'type': 'org-openroadm-interfaces:otnOdu',
+              'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
+        self.assertDictContainsSubset(
+             {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
+              'rate': 'org-openroadm-otn-common-types:ODU4'},
+             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
+        self.assertDictEqual(
+             {u'payload-type': u'21', u'exp-payload-type': u'21'},
+             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
+
+    def test_09_otn_service_path_create_10GE(self):
+        url = "{}/operations/transportpce-device-renderer:otn-service-path".format(self.restconf_baseurl)
+        data = {"renderer:input": {
+             "service-name": "service1",
+             "operation": "create",
+             "service-rate": "10G",
+             "service-type": "Ethernet",
+             "ethernet-encoding": "eth encode",
+             "trib-slot" : ["1"],
+             "trib-port-number": "1",
+             "opucn-trib-slots": ["1"],
+             "nodes": [
+                 {"node-id": "SPDR-SA1",
+                  "client-tp": "XPDR1-CLIENT1",
+                  "network-tp": "XPDR1-NETWORK1"}]}}
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "POST", url, data=json.dumps(data),
+             headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertIn('Otn Service path was set up successfully for node :service1-SPDR-SA1', res["output"]["result"])
+        self.assertTrue(res["output"]["success"])
+
+    def test_10_check_interface_10GE_CLIENT(self):
+        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
+                "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+                "interface/XPDR1-CLIENT1-ETHERNET10G"
+                .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertDictContainsSubset({'name': 'XPDR1-CLIENT1-ETHERNET10G', 'administrative-state': 'inService',
+              'supporting-circuit-pack-name': 'CP1-SFP4',
+              'type': 'org-openroadm-interfaces:ethernetCsmacd',
+              'supporting-port': 'CP1-SFP4-P1'}, res['interface'][0])
+        self.assertDictEqual(
+             {u'speed': 10000},
+             res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
+
+    def test_11_check_interface_ODU2E_CLIENT(self):
+        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
+                "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+                "interface/XPDR1-CLIENT1-ODU2e-service1"
+                .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertDictContainsSubset({'name': 'XPDR1-CLIENT1-ODU2e-service1', 'administrative-state': 'inService',
+              'supporting-circuit-pack-name': 'CP1-SFP4',
+              'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
+              'type': 'org-openroadm-interfaces:otnOdu',
+              'supporting-port': 'CP1-SFP4-P1'}, res['interface'][0])
+        self.assertDictContainsSubset({
+            'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
+            'rate': 'org-openroadm-otn-common-types:ODU2e',
+            'monitoring-mode': 'terminated'}, res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
+        self.assertDictEqual(
+             {u'payload-type': u'03', u'exp-payload-type': u'03'},
+             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
+
+    def test_12_check_interface_ODU2E_NETWORK(self):
+        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
+                "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+                "interface/XPDR1-NETWORK1-ODU2e-service1"
+                .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertDictContainsSubset({'name': 'XPDR1-NETWORK1-ODU2e-service1', 'administrative-state': 'inService',
+              'supporting-circuit-pack-name': 'CP1-CFP0',
+              'supporting-interface': 'XPDR1-NETWORK1-ODU4',
+              'type': 'org-openroadm-interfaces:otnOdu',
+              'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
+        self.assertDictContainsSubset({
+            'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
+            'rate': 'org-openroadm-otn-common-types:ODU2e',
+            'monitoring-mode': 'monitored'}, res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
+        self.assertDictContainsSubset(
+             {'trib-port-number': 1},
+             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'])
+        self.assertIn(1,
+             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']['trib-slots'])
+
+    def test_13_check_ODU2E_connection(self):
+        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
+                "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+                "odu-connection/XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1"
+                .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertDictContainsSubset({
+            'connection-name': 'XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1',
+            'direction': 'bidirectional'},
+            res['odu-connection'][0])
+        self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-service1'},
+            res['odu-connection'][0]['destination'])
+        self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-service1'},
+            res['odu-connection'][0]['source'])
+
+    def test_14_otn_service_path_delete_10GE(self):
+        url = "{}/operations/transportpce-device-renderer:otn-service-path".format(self.restconf_baseurl)
+        data = {"renderer:input": {
+             "service-name": "service1",
+             "operation": "delete",
+             "service-rate": "10G",
+             "service-type": "Ethernet",
+             "ethernet-encoding": "eth encode",
+             "trib-slot" : ["1"],
+             "trib-port-number": "1",
+             "opucn-trib-slots": ["1"],
+             "nodes": [
+                 {"node-id": "SPDR-SA1",
+                  "client-tp": "XPDR1-CLIENT1",
+                  "network-tp": "XPDR1-NETWORK1"}]}}
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "POST", url, data=json.dumps(data),
+             headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertIn('Request processed', res["output"]["result"])
+        self.assertTrue(res["output"]["success"])
+
+    def test_15_check_no_ODU2E_connection(self):
+        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
+                "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+                "odu-connection/XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1"
+                .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.not_found)
+
+    def test_16_check_no_interface_ODU2E_NETWORK(self):
+        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
+                "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+                "interface/XPDR1-NETWORK1-ODU2e-service1"
+                .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.not_found)
+
+    def test_17_check_no_interface_ODU2E_CLIENT(self):
+        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
+                "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+                "interface/XPDR1-CLIENT1-ODU2e-service1"
+                .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.not_found)
+
+    def test_18_check_no_interface_10GE_CLIENT(self):
+        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
+                "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+                "interface/XPDR1-CLIENT1-ETHERNET10G"
+                .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.not_found)
+
+    def test_19_service_path_delete_ODU4(self):
+        url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+        data = {"renderer:input": {
+             "service-name": "service_ODU4",
+             "wave-number": "1",
+             "modulation-format": "qpsk",
+             "operation": "delete",
+             "nodes": [
+                 {"node-id": "SPDR-SA1",
+                  "dest-tp": "XPDR1-NETWORK1"}]}}
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "POST", url, data=json.dumps(data),
+             headers=headers, auth=('admin', 'admin'))
+        time.sleep(3)
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        self.assertIn('Request processed', res["output"]["result"])
+        self.assertTrue(res["output"]["success"])
+
+    def test_20_check_no_interface_ODU4(self):
+        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
+                "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+                "interface/XPDR1-NETWORK1-ODU4"
+                .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.not_found)
+
+    def test_21_check_no_interface_OTU(self):
+        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
+                "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+                "interface/XPDR1-NETWORK1-OTU"
+                .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.not_found)
+
+    def test_22_check_no_interface_och(self):
+        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
+                "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+                "interface/XPDR1-NETWORK1-1"
+                .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+             "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.not_found)
+
+    def test_23_disconnect_SPDR_SA1(self):
+        url = ("{}/config/network-topology:"
+               "network-topology/topology/topology-netconf/node/SPDR-SA1"
+              .format(self.restconf_baseurl))
+        data = {}
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+            "DELETE", url, data=json.dumps(data), headers=headers,
+            auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

diff --git a/tox.ini b/tox.ini
index da63aad4dafdf6145e8475a97540de38cf8d91aa..c46a010d11f69bb11b252736791d84e06ba6bd5b 100644 (file)
--- a/tox.ini
+++ b/tox.ini
@@ -18,17 +18,17 @@ whitelist_externals = bash
 changedir={toxinidir}/tests
 commands =
 #install maven and JDK11 on the Gate since they are not there by default
-  {py3,portmapping,topoPortMapping,rspn,topology,pce,olm,end2end,portmapping221,rspn221,topology221,otntopology,olm221,end2end221,gnpy}: - bash -c "if [ ! `which mvn` ]; then ./installMavenCentOS.sh  ; fi"
+  {py3,portmapping,topoPortMapping,rspn,topology,pce,olm,end2end,portmapping221,rspn221,otnrenderer,topology221,otntopology,olm221,end2end221,gnpy}: - bash -c "if [ ! `which mvn` ]; then ./installMavenCentOS.sh  ; fi"
 #build 1.2.1 sims
   {py3,portmapping,topoPortMapping,rspn,topology,olm,end2end}: - bash -c "./buildHoneynode.sh"
 #patch OLM constant to speed up tests, unnecessary for PCE
-  {py3,portmapping,topoPortMapping,rspn,topology,olm,end2end,portmapping221,rspn221,topology221,otn-topology,olm221,end2end221}: - bash -c "sed -i' ' 's@=.*//#FUNCTESTVAL=@=@g' ../olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils.java"
+  {py3,portmapping,topoPortMapping,rspn,topology,olm,end2end,portmapping221,rspn221,otnrenderer,topology221,otn-topology,olm221,end2end221}: - bash -c "sed -i' ' 's@=.*//#FUNCTESTVAL=@=@g' ../olm/src/main/java/org/opendaylight/transportpce/olm/util/OlmUtils.java"
 #build controller, source JDK_JAVA_OPTIONS to remove illegal reflective acces warnings introduced by Java11
-  {py3,portmapping,topoPortMapping,rspn,topology,pce,olm,end2end,portmapping221,rspn221,topology221,otntopology,olm221,end2end221,gnpy}: - bash -c ". reflectwarn.sh && cd .. && mvn clean install -s tests/odl_settings.xml -DskipTests -Dmaven.javadoc.skip=true"
+  {py3,portmapping,topoPortMapping,rspn,topology,pce,olm,end2end,portmapping221,rspn221,otnrenderer,topology221,otntopology,olm221,end2end221,gnpy}: - bash -c ". reflectwarn.sh && cd .. && mvn clean install -s tests/odl_settings.xml -DskipTests -Dmaven.javadoc.skip=true"
 #patch Karaf exec for the same reason at runtime
-  {py3,portmapping,topoPortMapping,rspn,topology,pce,olm,end2end,portmapping221,rspn221,topology221,otntopology,olm221,end2end221,gnpy}: - bash -c "sed -i' ' 's@!/bin/sh@!/bin/sh\n. $(dirname $0)/../../../../tests/reflectwarn.sh@' ../karaf/target/assembly/bin/karaf"
+  {py3,portmapping,topoPortMapping,rspn,topology,pce,olm,end2end,portmapping221,rspn221,otnrenderer,topology221,otntopology,olm221,end2end221,gnpy}: - bash -c "sed -i' ' 's@!/bin/sh@!/bin/sh\n. $(dirname $0)/../../../../tests/reflectwarn.sh@' ../karaf/target/assembly/bin/karaf"
 #build Lighty if needed
-  {py3,portmapping,topoPortMapping,rspn,topology,pce,olm,end2end,portmapping221,rspn221,topology221,otntopology,olm221,end2end221,gnpy}: - bash -c 'if [ "$USE_LIGHTY" == "True" ]; then (cd ../lighty && ./build.sh); fi'
+  {py3,portmapping,topoPortMapping,rspn,topology,pce,olm,end2end,portmapping221,rspn221,otnrenderer,topology221,otntopology,olm221,end2end221,gnpy}: - bash -c 'if [ "$USE_LIGHTY" == "True" ]; then (cd ../lighty && ./build.sh); fi'
 #run 1.2.1 functional tests
   {py3,portmapping}: nosetests --with-xunit transportpce_tests/1.2.1/test_portmapping.py
   {py3,topoPortMapping}: nosetests --with-xunit transportpce_tests/1.2.1/test_topoPortMapping.py
@@ -38,12 +38,13 @@ commands =
   {py3,olm}: nosetests --with-xunit transportpce_tests/1.2.1/test_olm.py
   {end2end}: nosetests --with-xunit transportpce_tests/1.2.1/test_end2end.py
 #build 2.2.1 sims
-  {py3,portmapping221,rspn221,topology221,otntopology,olm221,end2end221}: - bash -c "./buildHoneynode.sh 2.2.1"
+  {py3,portmapping221,rspn221,otnrenderer,topology221,otntopology,olm221,end2end221}: - bash -c "./buildHoneynode.sh 2.2.1"
 #run 2.2.1 functional tests
   {py3,portmapping221}: nosetests --with-xunit transportpce_tests/2.2.1/test_portmapping.py
   {py3,topology221}: nosetests --with-xunit transportpce_tests/2.2.1/test_topology.py
   {otntopology}: nosetests --with-xunit transportpce_tests/2.2.1/test_otn_topology.py
   {py3,rspn221}: nosetests --with-xunit transportpce_tests/2.2.1/test_renderer_service_path_nominal.py
+  {py3,otnrenderer}: nosetests --with-xunit transportpce_tests/2.2.1/test_otn_renderer.py
   {py3,olm221}: nosetests --with-xunit transportpce_tests/2.2.1/test_olm.py
   {end2end221}: nosetests --with-xunit transportpce_tests/2.2.1/test_end2end.py
   #{gnpy}: - sudo docker pull atriki/gnpyrest:v1.2