From c25c72eda3ff7907139369ada84ceb700ae07899 Mon Sep 17 00:00:00 2001 From: Gilles Thouenon Date: Thu, 25 Aug 2022 11:12:47 +0200 Subject: [PATCH] Migrate end2end functional tests to RFC8040 - 1.2.1-end2end - 2.2.1-end2end - 2.2.1-otn_switch_end2end - 2.2.1-otn_end2end_with_intermediate_switch JIRA: TRNSPRTPCE-567 Signed-off-by: Gilles Thouenon Change-Id: I1ca04f930bb0bfcc1c6d40220153640bcdf38c5b --- .../1.2.1/test06_end2end.py | 685 ++++---- .../2.2.1/test12_end2end.py | 700 ++++---- .../2.2.1/test14_otn_switch_end2end.py | 1537 ++++++++--------- ...15_otn_end2end_with_intermediate_switch.py | 1534 ++++++++-------- .../common/test_utils_rfc8040.py | 3 +- 5 files changed, 2176 insertions(+), 2283 deletions(-) diff --git a/tests/transportpce_tests/1.2.1/test06_end2end.py b/tests/transportpce_tests/1.2.1/test06_end2end.py index 439715112..058f6d3be 100644 --- a/tests/transportpce_tests/1.2.1/test06_end2end.py +++ b/tests/transportpce_tests/1.2.1/test06_end2end.py @@ -20,11 +20,11 @@ import sys sys.path.append('transportpce_tests/common/') # pylint: disable=wrong-import-position # pylint: disable=import-error -import test_utils # nopep8 +import test_utils_rfc8040 # nopep8 class TransportPCEFulltesting(unittest.TestCase): - cr_serv_sample_data = {"input": { + cr_serv_input_data = { "sdnc-request-header": { "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58", "rpc-action": "service-create", @@ -56,6 +56,15 @@ class TransportPCEFulltesting(unittest.TestCase): "due-date": "2016-11-28T00:00:01Z", "operator-contact": "pw1234" } + del_serv_input_data = { + "sdnc-request-header": { + "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58", + "rpc-action": "service-delete", + "request-system-id": "appname", + "notification-url": "http://localhost:8585/NotificationServer/notify"}, + "service-delete-req-info": { + "service-name": "TBD", + "tail-retention": "no"} } processes = None WAITING = 20 @@ -63,74 +72,74 @@ class TransportPCEFulltesting(unittest.TestCase): @classmethod def setUpClass(cls): - cls.processes = test_utils.start_tpce() - cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION), - ('roadma-full', cls.NODE_VERSION), - ('roadmc-full', cls.NODE_VERSION), - ('xpdrc', cls.NODE_VERSION)]) + cls.processes = test_utils_rfc8040.start_tpce() + cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION), + ('roadma-full', cls.NODE_VERSION), + ('roadmc-full', cls.NODE_VERSION), + ('xpdrc', cls.NODE_VERSION)]) @classmethod def tearDownClass(cls): # pylint: disable=not-an-iterable for process in cls.processes: - test_utils.shutdown_process(process) + test_utils_rfc8040.shutdown_process(process) print("all processes killed") def setUp(self): # instruction executed before each test method # pylint: disable=consider-using-f-string print("execution of {}".format(self.id().split(".")[-1])) - # connect netconf devices + # connect netconf devices def test_01_connect_xpdrA(self): - response = test_utils.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION)) - self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201) + response = test_utils_rfc8040.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION)) + self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_02_connect_xpdrC(self): - response = test_utils.mount_device("XPDRC01", ('xpdrc', self.NODE_VERSION)) - self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201) + response = test_utils_rfc8040.mount_device("XPDRC01", ('xpdrc', self.NODE_VERSION)) + self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_03_connect_rdmA(self): - response = test_utils.mount_device("ROADMA01", ('roadma-full', self.NODE_VERSION)) - self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201) + response = test_utils_rfc8040.mount_device("ROADMA01", ('roadma-full', self.NODE_VERSION)) + self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_04_connect_rdmC(self): - response = test_utils.mount_device("ROADMC01", ('roadmc-full', self.NODE_VERSION)) - self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201) + response = test_utils_rfc8040.mount_device("ROADMC01", ('roadmc-full', self.NODE_VERSION)) + self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_05_connect_xprdA_N1_to_roadmA_PP1(self): - response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "1", - "ROADMA01", "1", "SRG1-PP1-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '1', + 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) def test_06_connect_roadmA_PP1_to_xpdrA_N1(self): - response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "1", - "ROADMA01", "1", "SRG1-PP1-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '1', + 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) def test_07_connect_xprdC_N1_to_roadmC_PP1(self): - response = test_utils.connect_xpdr_to_rdm_request("XPDRC01", "1", "1", - "ROADMC01", "1", "SRG1-PP1-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'XPDRC01', 'xpdr-num': '1', 'network-num': '1', + 'rdm-node': 'ROADMC01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) def test_08_connect_roadmC_PP1_to_xpdrC_N1(self): - response = test_utils.connect_rdm_to_xpdr_request("XPDRC01", "1", "1", - "ROADMC01", "1", "SRG1-PP1-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'XPDRC01', 'xpdr-num': '1', 'network-num': '1', + 'rdm-node': 'ROADMC01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) def test_09_add_omsAttributes_ROADMA_ROADMC(self): @@ -145,7 +154,8 @@ class TransportPCEFulltesting(unittest.TestCase): "fiber-type": "smf", "SRLG-length": 100000, "pmd": 0.5}]}} - response = test_utils.add_oms_attr_request("ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX", data) + response = test_utils_rfc8040.add_oms_attr_request("ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX", + data) self.assertEqual(response.status_code, requests.codes.created) def test_10_add_omsAttributes_ROADMC_ROADMA(self): @@ -160,106 +170,87 @@ class TransportPCEFulltesting(unittest.TestCase): "fiber-type": "smf", "SRLG-length": 100000, "pmd": 0.5}]}} - response = test_utils.add_oms_attr_request("ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX", data) + response = test_utils_rfc8040.add_oms_attr_request("ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX", + data) self.assertEqual(response.status_code, requests.codes.created) # test service-create for Eth service from xpdr to xpdr + def test_11_create_eth_service1(self): - self.cr_serv_sample_data["input"]["service-name"] = "service1" - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service1" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common'][ - 'response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_12_get_eth_service1(self): - response = test_utils.get_service_list_request("services/service1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], - 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service1') - self.assertEqual( - res['services'][0]['connection-type'], 'service') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service1') + self.assertEqual(response['services'][0]['connection-type'], 'service') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') + time.sleep(1) def test_13_check_xc1_ROADMA(self): - response = test_utils.check_netconf_node_request( - "ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + "ROADMA01", "roadm-connections", "SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768") + self.assertEqual(response['status_code'], requests.codes.ok) # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2 self.assertDictEqual( dict({ 'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768', 'wavelength-number': 1, - 'opticalControlMode': 'gainLoss', - 'target-output-power': -3.0 - }, **res['roadm-connections'][0]), - res['roadm-connections'][0] - ) - self.assertDictEqual( - {'src-if': 'SRG1-PP1-TXRX-761:768'}, - res['roadm-connections'][0]['source']) - self.assertDictEqual( - {'dst-if': 'DEG1-TTP-TXRX-761:768'}, - res['roadm-connections'][0]['destination']) - time.sleep(5) + 'opticalControlMode': 'gainLoss' + }, **response['roadm-connections'][0]), response['roadm-connections'][0]) + self.assertDictEqual({'src-if': 'SRG1-PP1-TXRX-761:768'}, response['roadm-connections'][0]['source']) + self.assertDictEqual({'dst-if': 'DEG1-TTP-TXRX-761:768'}, response['roadm-connections'][0]['destination']) + time.sleep(1) def test_14_check_xc1_ROADMC(self): - response = test_utils.check_netconf_node_request( - "ROADMC01", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + "ROADMC01", "roadm-connections", "SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768") + self.assertEqual(response['status_code'], requests.codes.ok) # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2 self.assertDictEqual( dict({ 'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768', 'wavelength-number': 1, - 'opticalControlMode': 'gainLoss', - 'target-output-power': 2.0 - }, **res['roadm-connections'][0]), - res['roadm-connections'][0] - ) - self.assertDictEqual( - {'src-if': 'SRG1-PP1-TXRX-761:768'}, - res['roadm-connections'][0]['source']) - self.assertDictEqual( - {'dst-if': 'DEG2-TTP-TXRX-761:768'}, - res['roadm-connections'][0]['destination']) - time.sleep(5) + 'opticalControlMode': 'gainLoss' + }, **response['roadm-connections'][0]), response['roadm-connections'][0]) + self.assertDictEqual({'src-if': 'SRG1-PP1-TXRX-761:768'}, response['roadm-connections'][0]['source']) + self.assertDictEqual({'dst-if': 'DEG2-TTP-TXRX-761:768'}, response['roadm-connections'][0]['destination']) + time.sleep(1) def test_15_check_topo_XPDRA(self): - response = test_utils.get_ordm_topo_request("node/XPDRA01-XPDR1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDRA01-XPDR1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'XPDR1-NETWORK1': - self.assertEqual({'frequency': 196.1, - 'width': 40}, - ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']) + self.assertEqual( + 196.1, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['frequency'])) + self.assertEqual( + 40.0, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['width'])) elif ele['tp-id'] in ('XPDR1-CLIENT2', 'XPDR1-CLIENT1'): self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele)) elif ele['tp-id'] == 'XPDR1-NETWORK2': self.assertNotIn('org-openroadm-network-topology:xpdr-network-attributes', dict.keys(ele)) - time.sleep(3) + time.sleep(1) def test_16_check_topo_ROADMA_SRG1(self): - response = test_utils.get_ordm_topo_request("node/ROADMA01-SRG1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-SRG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'SRG1-PP1-TXRX': freq_map = base64.b64decode( @@ -268,17 +259,16 @@ class TransportPCEFulltesting(unittest.TestCase): self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") elif ele['tp-id'] == 'SRG1-PP2-TXRX': self.assertNotIn('avail-freq-maps', dict.keys(ele)) - time.sleep(3) + time.sleep(1) def test_17_check_topo_ROADMA_DEG1(self): - response = test_utils.get_ordm_topo_request("node/ROADMA01-DEG1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-DEG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'DEG2-CTP-TXRX': freq_map = base64.b64decode( @@ -290,118 +280,110 @@ class TransportPCEFulltesting(unittest.TestCase): ele['org-openroadm-network-topology:tx-ttp-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") - time.sleep(3) + time.sleep(1) def test_18_connect_xprdA_N2_to_roadmA_PP2(self): - response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "2", - "ROADMA01", "1", "SRG1-PP2-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '2', + 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) def test_19_connect_roadmA_PP2_to_xpdrA_N2(self): - response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "2", - "ROADMA01", "1", "SRG1-PP2-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '2', + 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) def test_20_connect_xprdC_N2_to_roadmC_PP2(self): - response = test_utils.connect_xpdr_to_rdm_request("XPDRC01", "1", "2", - "ROADMC01", "1", "SRG1-PP2-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'XPDRC01', 'xpdr-num': '1', 'network-num': '2', + 'rdm-node': 'ROADMC01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) def test_21_connect_roadmC_PP2_to_xpdrC_N2(self): - response = test_utils.connect_rdm_to_xpdr_request("XPDRC01", "1", "2", - "ROADMC01", "1", "SRG1-PP2-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'XPDRC01', 'xpdr-num': '1', 'network-num': '2', + 'rdm-node': 'ROADMC01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) def test_22_create_eth_service2(self): - self.cr_serv_sample_data["input"]["service-name"] = "service2" - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service2" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common'][ - 'response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_23_get_eth_service2(self): - response = test_utils.get_service_list_request("services/service2") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], - 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service2') - self.assertEqual( - res['services'][0]['connection-type'], 'service') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service2") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service2') + self.assertEqual(response['services'][0]['connection-type'], 'service') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') time.sleep(1) def test_24_check_xc2_ROADMA(self): - response = test_utils.check_netconf_node_request( - "ROADMA01", "roadm-connections/DEG1-TTP-TXRX-SRG1-PP2-TXRX-753:760") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + "ROADMA01", "roadm-connections", "DEG1-TTP-TXRX-SRG1-PP2-TXRX-753:760") + self.assertEqual(response['status_code'], requests.codes.ok) # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2 self.assertDictEqual( dict({ 'connection-number': 'DEG1-TTP-TXRX-SRG1-PP2-TXRX-753:760', 'wavelength-number': 2, 'opticalControlMode': 'power' - }, **res['roadm-connections'][0]), - res['roadm-connections'][0] - ) - self.assertDictEqual( - {'src-if': 'DEG1-TTP-TXRX-753:760'}, - res['roadm-connections'][0]['source']) - self.assertDictEqual( - {'dst-if': 'SRG1-PP2-TXRX-753:760'}, - res['roadm-connections'][0]['destination']) + }, **response['roadm-connections'][0]), response['roadm-connections'][0]) + self.assertDictEqual({'src-if': 'DEG1-TTP-TXRX-753:760'}, response['roadm-connections'][0]['source']) + self.assertDictEqual({'dst-if': 'SRG1-PP2-TXRX-753:760'}, response['roadm-connections'][0]['destination']) + time.sleep(1) def test_25_check_topo_XPDRA(self): - response = test_utils.get_ordm_topo_request("node/XPDRA01-XPDR1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDRA01-XPDR1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'XPDR1-NETWORK1': - self.assertEqual({'frequency': 196.1, - 'width': 40}, - ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']) + self.assertEqual( + 196.1, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['frequency'])) + self.assertEqual( + 40.0, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['width'])) elif ele['tp-id'] == 'XPDR1-NETWORK2': - self.assertEqual({'frequency': 196.05, - 'width': 40}, - ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']) + self.assertEqual( + 196.05, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['frequency'])) + self.assertEqual( + 40.0, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['width'])) elif ele['tp-id'] in ('XPDR1-CLIENT1', 'XPDR1-CLIENT2'): self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele)) - time.sleep(10) + time.sleep(1) def test_26_check_topo_ROADMA_SRG1(self): - response = test_utils.get_ordm_topo_request("node/ROADMA01-SRG1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-SRG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'SRG1-PP1-TXRX': freq_map = base64.b64decode( @@ -417,18 +399,17 @@ class TransportPCEFulltesting(unittest.TestCase): self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available") elif ele['tp-id'] == 'SRG1-PP3-TXRX': self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele)) - time.sleep(10) + time.sleep(1) def test_27_check_topo_ROADMA_DEG1(self): - response = test_utils.get_ordm_topo_request("node/ROADMA01-DEG1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-DEG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'DEG2-CTP-TXRX': freq_map = base64.b64decode( @@ -442,66 +423,65 @@ class TransportPCEFulltesting(unittest.TestCase): freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available") - time.sleep(10) + time.sleep(1) # creation service test on a non-available resource def test_28_create_eth_service3(self): - self.cr_serv_sample_data["input"]["service-name"] = "service3" - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service3" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common'][ - 'response-message']) - self.assertIn('200', res['output']['configuration-response-common'][ - 'response-code']) + response['output']['configuration-response-common']['response-message']) + self.assertIn('200', response['output']['configuration-response-common']['response-code']) time.sleep(self.WAITING) # add a test that check the openroadm-service-list still only # contains 2 elements def test_29_delete_eth_service3(self): - response = test_utils.service_delete_request("service3") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service3" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Service \'service3\' does not exist in datastore', - res['output']['configuration-response-common'][ - 'response-message']) - self.assertIn('500', res['output']['configuration-response-common'][ - 'response-code']) - time.sleep(20) + response['output']['configuration-response-common']['response-message']) + self.assertIn('500', response['output']['configuration-response-common']['response-code']) + time.sleep(3) def test_30_delete_eth_service1(self): - response = test_utils.service_delete_request("service1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common'][ - 'response-message']) - time.sleep(20) + response['output']['configuration-response-common']['response-message']) + time.sleep(self.WAITING) def test_31_delete_eth_service2(self): - response = test_utils.service_delete_request("service2") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service2" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common'][ - 'response-message']) - time.sleep(20) + response['output']['configuration-response-common']['response-message']) + time.sleep(self.WAITING) def test_32_check_no_xc_ROADMA(self): - response = test_utils.check_netconf_node_request("ROADMA01", "") - res = response.json() - self.assertEqual(response.status_code, requests.codes.ok) + response = test_utils_rfc8040.check_node_request("ROADMA01") + self.assertEqual(response['status_code'], requests.codes.ok) self.assertNotIn('roadm-connections', - dict.keys(res['org-openroadm-device'])) + dict.keys(response['org-openroadm-device'])) time.sleep(2) def test_33_check_topo_XPDRA(self): - response = test_utils.get_ordm_topo_request("node/XPDRA01-XPDR1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDRA01-XPDR1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if (ele['org-openroadm-common-network:tp-type'] == 'XPONDER-CLIENT' and ele['tp-id'] in ('XPDR1-CLIENT1', 'XPDR1-CLIENT3')): @@ -515,18 +495,17 @@ class TransportPCEFulltesting(unittest.TestCase): self.assertNotIn('wavelength', dict.keys( ele['org-openroadm-network-topology:' 'xpdr-network-attributes'])) - time.sleep(10) + time.sleep(1) def test_34_check_topo_ROADMA_SRG1(self): - response = test_utils.get_ordm_topo_request("node/ROADMA01-SRG1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-SRG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available") self.assertEqual(freq_map_array[94], 255, "Lambda 2 should be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'SRG1-PP1-TXRX' or ele['tp-id'] == 'SRG1-PP2-TXRX': freq_map = base64.b64decode( @@ -542,18 +521,17 @@ class TransportPCEFulltesting(unittest.TestCase): self.assertEqual(freq_map_array[94], 255, "Lambda 2 should be available") else: self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele)) - time.sleep(10) + time.sleep(1) def test_35_check_topo_ROADMA_DEG1(self): - response = test_utils.get_ordm_topo_request("node/ROADMA01-DEG1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-DEG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available") self.assertEqual(freq_map_array[94], 255, "Lambda 2 should be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'DEG2-CTP-TXRX': freq_map = base64.b64decode( @@ -567,44 +545,38 @@ class TransportPCEFulltesting(unittest.TestCase): freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available") self.assertEqual(freq_map_array[94], 255, "Lambda 2 should be available") - time.sleep(10) + time.sleep(1) # test service-create for Optical Channel (OC) service from srg-pp to srg-pp + def test_36_create_oc_service1(self): - self.cr_serv_sample_data["input"]["service-name"] = "service1" - self.cr_serv_sample_data["input"]["connection-type"] = "roadm-line" - self.cr_serv_sample_data["input"]["service-a-end"]["node-id"] = "ROADMA01" - self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "OC" - self.cr_serv_sample_data["input"]["service-z-end"]["node-id"] = "ROADMC01" - self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "OC" - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service1" + self.cr_serv_input_data["connection-type"] = "roadm-line" + self.cr_serv_input_data["service-a-end"]["node-id"] = "ROADMA01" + self.cr_serv_input_data["service-a-end"]["service-format"] = "OC" + self.cr_serv_input_data["service-z-end"]["node-id"] = "ROADMC01" + self.cr_serv_input_data["service-z-end"]["service-format"] = "OC" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common'][ - 'response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_37_get_oc_service1(self): - response = test_utils.get_service_list_request("services/service1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], - 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service1') - self.assertEqual( - res['services'][0]['connection-type'], 'roadm-line') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service1') + self.assertEqual(response['services'][0]['connection-type'], 'roadm-line') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') time.sleep(1) def test_38_check_xc1_ROADMA(self): - response = test_utils.check_netconf_node_request( - "ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + "ROADMA01", "roadm-connections", "SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768") + self.assertEqual(response['status_code'], requests.codes.ok) # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2 self.assertDictEqual( dict({ @@ -612,22 +584,15 @@ class TransportPCEFulltesting(unittest.TestCase): 'wavelength-number': 1, 'opticalControlMode': 'gainLoss', 'target-output-power': -3.0 - }, **res['roadm-connections'][0]), - res['roadm-connections'][0] - ) - self.assertDictEqual( - {'src-if': 'SRG1-PP1-TXRX-761:768'}, - res['roadm-connections'][0]['source']) - self.assertDictEqual( - {'dst-if': 'DEG1-TTP-TXRX-761:768'}, - res['roadm-connections'][0]['destination']) - time.sleep(7) + }, **response['roadm-connections'][0]), response['roadm-connections'][0]) + self.assertDictEqual({'src-if': 'SRG1-PP1-TXRX-761:768'}, response['roadm-connections'][0]['source']) + self.assertDictEqual({'dst-if': 'DEG1-TTP-TXRX-761:768'}, response['roadm-connections'][0]['destination']) + time.sleep(1) def test_39_check_xc1_ROADMC(self): - response = test_utils.check_netconf_node_request( - "ROADMC01", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + "ROADMC01", "roadm-connections", "SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768") + self.assertEqual(response['status_code'], requests.codes.ok) # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2 self.assertDictEqual( dict({ @@ -635,52 +600,39 @@ class TransportPCEFulltesting(unittest.TestCase): 'wavelength-number': 1, 'opticalControlMode': 'gainLoss', 'target-output-power': 2.0 - }, **res['roadm-connections'][0]), - res['roadm-connections'][0] - ) - self.assertDictEqual( - {'src-if': 'SRG1-PP1-TXRX-761:768'}, - res['roadm-connections'][0]['source']) - self.assertDictEqual( - {'dst-if': 'DEG2-TTP-TXRX-761:768'}, - res['roadm-connections'][0]['destination']) - time.sleep(7) + }, **response['roadm-connections'][0]), response['roadm-connections'][0]) + self.assertDictEqual({'src-if': 'SRG1-PP1-TXRX-761:768'}, response['roadm-connections'][0]['source']) + self.assertDictEqual({'dst-if': 'DEG2-TTP-TXRX-761:768'}, response['roadm-connections'][0]['destination']) + time.sleep(1) def test_40_create_oc_service2(self): - self.cr_serv_sample_data["input"]["service-name"] = "service2" - self.cr_serv_sample_data["input"]["connection-type"] = "roadm-line" - self.cr_serv_sample_data["input"]["service-a-end"]["node-id"] = "ROADMA01" - self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "OC" - self.cr_serv_sample_data["input"]["service-z-end"]["node-id"] = "ROADMC01" - self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "OC" - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service2" + self.cr_serv_input_data["connection-type"] = "roadm-line" + self.cr_serv_input_data["service-a-end"]["node-id"] = "ROADMA01" + self.cr_serv_input_data["service-a-end"]["service-format"] = "OC" + self.cr_serv_input_data["service-z-end"]["node-id"] = "ROADMC01" + self.cr_serv_input_data["service-z-end"]["service-format"] = "OC" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common'][ - 'response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_41_get_oc_service2(self): - response = test_utils.get_service_list_request("services/service2") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], - 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service2') - self.assertEqual( - res['services'][0]['connection-type'], 'roadm-line') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service2") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service2') + self.assertEqual(response['services'][0]['connection-type'], 'roadm-line') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') time.sleep(2) def test_42_check_xc2_ROADMA(self): - response = test_utils.check_netconf_node_request( - "ROADMA01", "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-753:760") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + "ROADMA01", "roadm-connections", "SRG1-PP2-TXRX-DEG1-TTP-TXRX-753:760") + self.assertEqual(response['status_code'], requests.codes.ok) # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2 self.assertDictEqual( dict({ @@ -688,61 +640,59 @@ class TransportPCEFulltesting(unittest.TestCase): 'wavelength-number': 2, 'opticalControlMode': 'gainLoss', 'target-output-power': -3.0 - }, **res['roadm-connections'][0]), - res['roadm-connections'][0] - ) - self.assertDictEqual( - {'src-if': 'SRG1-PP2-TXRX-753:760'}, - res['roadm-connections'][0]['source']) - self.assertDictEqual( - {'dst-if': 'DEG1-TTP-TXRX-753:760'}, - res['roadm-connections'][0]['destination']) - time.sleep(2) + }, **response['roadm-connections'][0]), response['roadm-connections'][0]) + self.assertDictEqual({'src-if': 'SRG1-PP2-TXRX-753:760'}, response['roadm-connections'][0]['source']) + self.assertDictEqual({'dst-if': 'DEG1-TTP-TXRX-753:760'}, response['roadm-connections'][0]['destination']) + time.sleep(1) def test_43_check_topo_ROADMA(self): self.test_26_check_topo_ROADMA_SRG1() self.test_27_check_topo_ROADMA_DEG1() - time.sleep(3) + time.sleep(1) def test_44_delete_oc_service1(self): - response = test_utils.service_delete_request("service1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common'][ - 'response-message']) - time.sleep(20) + response['output']['configuration-response-common']['response-message']) + time.sleep(self.WAITING) def test_45_delete_oc_service2(self): - response = test_utils.service_delete_request("service2") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service2" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common'][ - 'response-message']) - time.sleep(20) + response['output']['configuration-response-common']['response-message']) + time.sleep(self.WAITING) def test_46_get_no_oc_services(self): - print("start test") - response = test_utils.get_service_list_request("") - self.assertEqual(response.status_code, requests.codes.conflict) - res = response.json() - self.assertIn( + response = test_utils_rfc8040.get_ordm_serv_list_request() + self.assertEqual(response['status_code'], requests.codes.conflict) + self.assertIn(response['service-list'], ( { + "error-type": "protocol", + "error-tag": "data-missing", + "error-message": + "Request could not be completed because the relevant data " + "model content does not exist" + }, { "error-type": "application", "error-tag": "data-missing", "error-message": "Request could not be completed because the relevant data " "model content does not exist" - }, - res['errors']['error']) + })) time.sleep(1) def test_47_get_no_xc_ROADMA(self): - response = test_utils.check_netconf_node_request("ROADMA01", "") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device']) + response = test_utils_rfc8040.check_node_request("ROADMA01") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertNotIn('roadm-connections', dict.keys(response['org-openroadm-device'])) time.sleep(1) def test_48_check_topo_ROADMA(self): @@ -751,7 +701,7 @@ class TransportPCEFulltesting(unittest.TestCase): def test_49_loop_create_eth_service(self): # pylint: disable=consider-using-f-string - for i in range(1, 6): + for i in range(1, 4): print("iteration number {}".format(i)) print("eth service creation") self.test_11_create_eth_service1() @@ -763,13 +713,16 @@ class TransportPCEFulltesting(unittest.TestCase): self.test_30_delete_eth_service1() def test_50_loop_create_oc_service(self): - response = test_utils.get_service_list_request("services/service1") - if response.status_code != 404: - response = test_utils.service_delete_request("service1") + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1") + if response['status_code'] != 404: + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) time.sleep(5) # pylint: disable=consider-using-f-string - for i in range(1, 6): + for i in range(1, 4): print("iteration number {}".format(i)) print("oc service creation") self.test_36_create_oc_service1() @@ -781,20 +734,20 @@ class TransportPCEFulltesting(unittest.TestCase): self.test_44_delete_oc_service1() def test_51_disconnect_XPDRA(self): - response = test_utils.unmount_device("XPDRA01") - self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200) + response = test_utils_rfc8040.unmount_device("XPDRA01") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) def test_52_disconnect_XPDRC(self): - response = test_utils.unmount_device("XPDRC01") - self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200) + response = test_utils_rfc8040.unmount_device("XPDRC01") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) def test_53_disconnect_ROADMA(self): - response = test_utils.unmount_device("ROADMA01") - self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200) + response = test_utils_rfc8040.unmount_device("ROADMA01") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) def test_54_disconnect_ROADMC(self): - response = test_utils.unmount_device("ROADMC01") - self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200) + response = test_utils_rfc8040.unmount_device("ROADMC01") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) if __name__ == "__main__": diff --git a/tests/transportpce_tests/2.2.1/test12_end2end.py b/tests/transportpce_tests/2.2.1/test12_end2end.py index ce56cf0d2..8d047bb58 100644 --- a/tests/transportpce_tests/2.2.1/test12_end2end.py +++ b/tests/transportpce_tests/2.2.1/test12_end2end.py @@ -20,13 +20,13 @@ import sys sys.path.append('transportpce_tests/common/') # pylint: disable=wrong-import-position # pylint: disable=import-error -import test_utils # nopep8 +import test_utils_rfc8040 # nopep8 class TransportPCEFulltesting(unittest.TestCase): processes = None - cr_serv_sample_data = {"input": { + cr_serv_input_data = { "sdnc-request-header": { "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58", "rpc-action": "service-create", @@ -117,6 +117,16 @@ class TransportPCEFulltesting(unittest.TestCase): "due-date": "2016-11-28T00:00:01Z", "operator-contact": "pw1234" } + + del_serv_input_data = { + "sdnc-request-header": { + "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58", + "rpc-action": "service-delete", + "request-system-id": "appname", + "notification-url": "http://localhost:8585/NotificationServer/notify"}, + "service-delete-req-info": { + "service-name": "TBD", + "tail-retention": "no"} } WAITING = 20 # nominal value is 300 @@ -124,17 +134,17 @@ class TransportPCEFulltesting(unittest.TestCase): @classmethod def setUpClass(cls): - cls.processes = test_utils.start_tpce() - cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION), - ('roadma', cls.NODE_VERSION), - ('roadmc', cls.NODE_VERSION), - ('xpdrc', cls.NODE_VERSION)]) + cls.processes = test_utils_rfc8040.start_tpce() + cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION), + ('roadma', cls.NODE_VERSION), + ('roadmc', cls.NODE_VERSION), + ('xpdrc', cls.NODE_VERSION)]) @classmethod def tearDownClass(cls): # pylint: disable=not-an-iterable for process in cls.processes: - test_utils.shutdown_process(process) + test_utils_rfc8040.shutdown_process(process) print("all processes killed") def setUp(self): # instruction executed before each test method @@ -142,83 +152,91 @@ class TransportPCEFulltesting(unittest.TestCase): print("execution of {}".format(self.id().split(".")[-1])) def test_01_connect_xpdrA(self): - response = test_utils.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION)) - self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201) + response = test_utils_rfc8040.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION)) + self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_02_connect_xpdrC(self): - response = test_utils.mount_device("XPDR-C1", ('xpdrc', self.NODE_VERSION)) - self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201) + response = test_utils_rfc8040.mount_device("XPDR-C1", ('xpdrc', self.NODE_VERSION)) + self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_03_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) + response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION)) + self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_04_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) + response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION)) + self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_05_connect_xprdA_N1_to_roadmA_PP1(self): - response = test_utils.connect_xpdr_to_rdm_request("XPDR-A1", "1", "1", - "ROADM-A1", "1", "SRG1-PP1-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '1', + 'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) def test_06_connect_roadmA_PP1_to_xpdrA_N1(self): - response = test_utils.connect_rdm_to_xpdr_request("XPDR-A1", "1", "1", - "ROADM-A1", "1", "SRG1-PP1-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '1', + 'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) def test_07_connect_xprdC_xpdr1_N1_to_roadmC_PP1(self): - response = test_utils.connect_xpdr_to_rdm_request("XPDR-C1", "1", "1", - "ROADM-C1", "1", "SRG1-PP1-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'XPDR-C1', 'xpdr-num': '1', 'network-num': '1', + 'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) def test_08_connect_roadmC_PP1_to_xpdrC_xprd1_N1(self): - response = test_utils.connect_rdm_to_xpdr_request("XPDR-C1", "1", "1", - "ROADM-C1", "1", "SRG1-PP1-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'XPDR-C1', 'xpdr-num': '1', 'network-num': '1', + 'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) def test_09_connect_xprdA_N2_to_roadmA_PP2(self): - response = test_utils.connect_xpdr_to_rdm_request("XPDR-A1", "1", "2", - "ROADM-A1", "1", "SRG1-PP2-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '2', + 'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) def test_10_connect_roadmA_PP2_to_xpdrA_N2(self): - response = test_utils.connect_rdm_to_xpdr_request("XPDR-A1", "1", "2", - "ROADM-A1", "1", "SRG1-PP2-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '2', + 'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) def test_11_connect_xprdC_xpdr2_N1_to_roadmC_PP2(self): - response = test_utils.connect_xpdr_to_rdm_request("XPDR-C1", "2", "1", - "ROADM-C1", "1", "SRG1-PP2-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'XPDR-C1', 'xpdr-num': '2', 'network-num': '1', + 'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) def test_12_connect_roadmC_PP2_to_xpdrC_xpdr2_N1(self): - response = test_utils.connect_rdm_to_xpdr_request("XPDR-C1", "2", "1", - "ROADM-C1", "1", "SRG1-PP2-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'XPDR-C1', 'xpdr-num': '2', 'network-num': '1', + 'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) def test_13_add_omsAttributes_ROADMA_ROADMC(self): @@ -233,7 +251,8 @@ class TransportPCEFulltesting(unittest.TestCase): "fiber-type": "smf", "SRLG-length": 100000, "pmd": 0.5}]}} - response = test_utils.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data) + response = test_utils_rfc8040.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", + data) self.assertEqual(response.status_code, requests.codes.created) def test_14_add_omsAttributes_ROADMC_ROADMA(self): @@ -248,102 +267,86 @@ class TransportPCEFulltesting(unittest.TestCase): "fiber-type": "smf", "SRLG-length": 100000, "pmd": 0.5}]}} - response = test_utils.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data) + response = test_utils_rfc8040.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", + data) self.assertEqual(response.status_code, requests.codes.created) # test service-create for Eth service from xpdr to xpdr def test_15_create_eth_service2(self): - self.cr_serv_sample_data["input"]["service-name"] = "service2" - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service2" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) - def test_16_get_eth_service1(self): - response = test_utils.get_service_list_request("services/service2") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service2') - self.assertEqual( - res['services'][0]['connection-type'], 'service') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') - time.sleep(2) + def test_16_get_eth_service2(self): + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service2") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service2') + self.assertEqual(response['services'][0]['connection-type'], 'service') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') + time.sleep(1) def test_17_check_xc1_ROADMA(self): - response = test_utils.check_netconf_node_request( - "ROADM-A1", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + "ROADM-A1", "roadm-connections", "SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768") + self.assertEqual(response['status_code'], requests.codes.ok) # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2 self.assertDictEqual( dict({ 'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768', 'opticalControlMode': 'gainLoss', 'target-output-power': -3.0 - }, **res['roadm-connections'][0]), - res['roadm-connections'][0] - ) - self.assertDictEqual( - {'src-if': 'SRG1-PP1-TXRX-nmc-761:768'}, - res['roadm-connections'][0]['source']) - self.assertDictEqual( - {'dst-if': 'DEG2-TTP-TXRX-nmc-761:768'}, - res['roadm-connections'][0]['destination']) - time.sleep(5) + }, **response['roadm-connections'][0]), response['roadm-connections'][0]) + self.assertDictEqual({'src-if': 'SRG1-PP1-TXRX-nmc-761:768'}, response['roadm-connections'][0]['source']) + self.assertDictEqual({'dst-if': 'DEG2-TTP-TXRX-nmc-761:768'}, response['roadm-connections'][0]['destination']) + time.sleep(1) def test_18_check_xc1_ROADMC(self): - response = test_utils.check_netconf_node_request( - "ROADM-C1", "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-761:768") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + "ROADM-C1", "roadm-connections", "SRG1-PP2-TXRX-DEG1-TTP-TXRX-761:768") + self.assertEqual(response['status_code'], requests.codes.ok) # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2 self.assertDictEqual( dict({ 'connection-name': 'SRG1-PP2-TXRX-DEG1-TTP-TXRX-761:768', 'opticalControlMode': 'gainLoss', 'target-output-power': -3.0 - }, **res['roadm-connections'][0]), - res['roadm-connections'][0] - ) - self.assertDictEqual( - {'src-if': 'SRG1-PP2-TXRX-nmc-761:768'}, - res['roadm-connections'][0]['source']) - self.assertDictEqual( - {'dst-if': 'DEG1-TTP-TXRX-nmc-761:768'}, - res['roadm-connections'][0]['destination']) - time.sleep(5) + }, **response['roadm-connections'][0]), response['roadm-connections'][0]) + self.assertDictEqual({'src-if': 'SRG1-PP2-TXRX-nmc-761:768'}, response['roadm-connections'][0]['source']) + self.assertDictEqual({'dst-if': 'DEG1-TTP-TXRX-nmc-761:768'}, response['roadm-connections'][0]['destination']) + time.sleep(1) def test_19_check_topo_XPDRA(self): - response = test_utils.get_ordm_topo_request("node/XPDR-A1-XPDR1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDR-A1-XPDR1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'XPDR1-NETWORK1': - self.assertEqual({'frequency': 196.1, - 'width': 40}, - ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']) + self.assertEqual( + 196.1, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['frequency'])) + self.assertEqual( + 40.0, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['width'])) elif ele['tp-id'] in ('XPDR1-CLIENT1', 'XPDR1-CLIENT2'): self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele)) elif ele['tp-id'] == 'XPDR1-NETWORK2': self.assertIn('org-openroadm-network-topology:xpdr-network-attributes', dict.keys(ele)) - time.sleep(3) + time.sleep(1) def test_20_check_topo_ROADMA_SRG1(self): - response = test_utils.get_ordm_topo_request("node/ROADM-A1-SRG1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] - self.assertEqual(freq_map_array[95], 0, "Index 1 should not be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'SRG1-PP1-TXRX': freq_map = base64.b64decode( @@ -352,17 +355,16 @@ class TransportPCEFulltesting(unittest.TestCase): self.assertEqual(freq_map_array[95], 0, "Index 1 should not be available") elif ele['tp-id'] == 'SRG1-PP2-TXRX': self.assertNotIn('avail-freq-maps', dict.keys(ele)) - time.sleep(3) + time.sleep(1) def test_21_check_topo_ROADMA_DEG2(self): - response = test_utils.get_ordm_topo_request("node/ROADM-A1-DEG2") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] - self.assertEqual(freq_map_array[95], 0, "Index 1 should not be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'DEG2-CTP-TXRX': freq_map = base64.b64decode( @@ -374,85 +376,74 @@ class TransportPCEFulltesting(unittest.TestCase): ele['org-openroadm-network-topology:tx-ttp-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Index 1 should not be available") - time.sleep(3) + time.sleep(1) def test_22_create_eth_service1(self): - self.cr_serv_sample_data["input"]["service-name"] = "service1" - del self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] - del self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-name"] - del self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] - del self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-name"] - del self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] - del self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-name"] - del self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] - del self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-name"] - - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service1" + del self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] + del self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] + del self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] + del self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] + del self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] + del self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] + del self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] + del self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_23_get_eth_service1(self): - response = test_utils.get_service_list_request("services/service1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], - 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service1') - self.assertEqual( - res['services'][0]['connection-type'], 'service') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service1') + self.assertEqual(response['services'][0]['connection-type'], 'service') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') time.sleep(1) def test_24_check_xc1_ROADMA(self): - response = test_utils.check_netconf_node_request( - "ROADM-A1", "roadm-connections/DEG2-TTP-TXRX-SRG1-PP2-TXRX-753:760") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + "ROADM-A1", "roadm-connections", "DEG2-TTP-TXRX-SRG1-PP2-TXRX-753:760") + self.assertEqual(response['status_code'], requests.codes.ok) # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2 self.assertDictEqual( dict({ 'connection-name': 'DEG2-TTP-TXRX-SRG1-PP2-TXRX-753:760', 'opticalControlMode': 'power' - }, **res['roadm-connections'][0]), - res['roadm-connections'][0] - ) - self.assertDictEqual( - {'src-if': 'DEG2-TTP-TXRX-nmc-753:760'}, - res['roadm-connections'][0]['source']) - self.assertDictEqual( - {'dst-if': 'SRG1-PP2-TXRX-nmc-753:760'}, - res['roadm-connections'][0]['destination']) + }, **response['roadm-connections'][0]), response['roadm-connections'][0]) + self.assertDictEqual({'src-if': 'DEG2-TTP-TXRX-nmc-753:760'}, response['roadm-connections'][0]['source']) + self.assertDictEqual({'dst-if': 'SRG1-PP2-TXRX-nmc-753:760'}, response['roadm-connections'][0]['destination']) + time.sleep(1) def test_25_check_topo_XPDRA(self): - response = test_utils.get_ordm_topo_request("node/XPDR-A1-XPDR1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDR-A1-XPDR1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'XPDR1-NETWORK2': - self.assertEqual({'frequency': 196.05, - 'width': 40}, - ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']) + self.assertEqual( + 196.05, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['frequency'])) + self.assertEqual( + 40.0, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['width'])) elif ele['tp-id'] in ('XPDR1-CLIENT1'): self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele)) - time.sleep(10) + time.sleep(1) def test_26_check_topo_ROADMA_SRG1(self): - response = test_utils.get_ordm_topo_request("node/ROADM-A1-SRG1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'SRG1-PP1-TXRX': freq_map = base64.b64decode( @@ -468,18 +459,17 @@ class TransportPCEFulltesting(unittest.TestCase): self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available") elif ele['tp-id'] == 'SRG1-PP3-TXRX': self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele)) - time.sleep(10) + time.sleep(1) def test_27_check_topo_ROADMA_DEG2(self): - response = test_utils.get_ordm_topo_request("node/ROADM-A1-DEG2") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'DEG2-CTP-TXRX': freq_map = base64.b64decode( @@ -493,77 +483,82 @@ class TransportPCEFulltesting(unittest.TestCase): freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available") - time.sleep(10) + time.sleep(1) # creation service test on a non-available resource def test_28_create_eth_service3(self): - self.cr_serv_sample_data["input"]["service-name"] = "service3" - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service3" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) - self.assertIn('200', res['output']['configuration-response-common']['response-code']) + response['output']['configuration-response-common']['response-message']) + self.assertIn('200', response['output']['configuration-response-common']['response-code']) time.sleep(self.WAITING) # add a test that check the openroadm-service-list still only contains 2 elements def test_29_delete_eth_service3(self): - response = test_utils.service_delete_request("service3") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service3" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Service \'service3\' does not exist in datastore', - res['output']['configuration-response-common']['response-message']) - self.assertIn('500', res['output']['configuration-response-common']['response-code']) - time.sleep(20) + response['output']['configuration-response-common']['response-message']) + self.assertIn('500', response['output']['configuration-response-common']['response-code']) + time.sleep(3) def test_30_delete_eth_service1(self): - response = test_utils.service_delete_request("service1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) - time.sleep(20) + response['output']['configuration-response-common']['response-message']) + time.sleep(self.WAITING) def test_31_delete_eth_service2(self): - response = test_utils.service_delete_request("service2") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service2" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) - time.sleep(20) + response['output']['configuration-response-common']['response-message']) + time.sleep(self.WAITING) def test_32_check_no_xc_ROADMA(self): - response = test_utils.check_netconf_node_request("ROADM-A1", "") - res = response.json() - self.assertEqual(response.status_code, requests.codes.ok) - self.assertNotIn('roadm-connections', dict.keys(res['org-openroadm-device'])) + response = test_utils_rfc8040.check_node_request("ROADM-A1") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertNotIn('roadm-connections', + dict.keys(response['org-openroadm-device'])) time.sleep(2) def test_33_check_topo_XPDRA(self): - response = test_utils.get_ordm_topo_request("node/XPDR-A1-XPDR1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDR-A1-XPDR1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['org-openroadm-common-network:tp-type'] == 'XPONDER-CLIENT': self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele)) elif ele['org-openroadm-common-network:tp-type'] == 'XPONDER-NETWORK': self.assertIn('tail-equipment-id', dict.keys(ele['org-openroadm-network-topology:xpdr-network-attributes'])) - self.assertNotIn('wavelength', dict.keys( - ele['org-openroadm-network-topology:xpdr-network-attributes'])) - time.sleep(10) + self.assertNotIn('wavelength', + dict.keys(ele['org-openroadm-network-topology:xpdr-network-attributes'])) + time.sleep(1) def test_34_check_topo_ROADMA_SRG1(self): - response = test_utils.get_ordm_topo_request("node/ROADM-A1-SRG1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 255, "Index 1 should be available") self.assertEqual(freq_map_array[94], 255, "Index 2 should be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] in ('SRG1-PP1-TXRX', 'SRG1-PP2-TXRX'): freq_map = base64.b64decode( @@ -579,18 +574,17 @@ class TransportPCEFulltesting(unittest.TestCase): self.assertEqual(freq_map_array[94], 255, "Index 2 should be available") else: self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele)) - time.sleep(10) + time.sleep(1) def test_35_check_topo_ROADMA_DEG2(self): - response = test_utils.get_ordm_topo_request("node/ROADM-A1-DEG2") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available") self.assertEqual(freq_map_array[94], 255, "Lambda 2 should be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'DEG2-CTP-TXRX': freq_map = base64.b64decode( @@ -604,143 +598,111 @@ class TransportPCEFulltesting(unittest.TestCase): freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available") self.assertEqual(freq_map_array[94], 255, "Lambda 2 should be available") - time.sleep(10) + time.sleep(1) # test service-create for Optical Channel (OC) service from srg-pp to srg-pp def test_36_create_oc_service1(self): - self.cr_serv_sample_data["input"]["service-name"] = "service1" - self.cr_serv_sample_data["input"]["connection-type"] = "roadm-line" - self.cr_serv_sample_data["input"]["service-a-end"]["node-id"] = "ROADM-A1" - self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "OC" - self.cr_serv_sample_data["input"]["service-z-end"]["node-id"] = "ROADM-C1" - self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "OC" - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service1" + self.cr_serv_input_data["connection-type"] = "roadm-line" + self.cr_serv_input_data["service-a-end"]["node-id"] = "ROADM-A1" + self.cr_serv_input_data["service-a-end"]["service-format"] = "OC" + self.cr_serv_input_data["service-z-end"]["node-id"] = "ROADM-C1" + self.cr_serv_input_data["service-z-end"]["service-format"] = "OC" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_37_get_oc_service1(self): - response = test_utils.get_service_list_request("services/service1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], - 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service1') - self.assertEqual( - res['services'][0]['connection-type'], 'roadm-line') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service1') + self.assertEqual(response['services'][0]['connection-type'], 'roadm-line') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') time.sleep(1) def test_38_check_xc1_ROADMA(self): - response = test_utils.check_netconf_node_request( - "ROADM-A1", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + "ROADM-A1", "roadm-connections", "SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768") + self.assertEqual(response['status_code'], requests.codes.ok) # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2 self.assertDictEqual( dict({ 'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768', 'opticalControlMode': 'gainLoss', 'target-output-power': -3.0 - }, **res['roadm-connections'][0]), - res['roadm-connections'][0] - ) - self.assertDictEqual( - {'src-if': 'SRG1-PP1-TXRX-nmc-761:768'}, - res['roadm-connections'][0]['source']) - self.assertDictEqual( - {'dst-if': 'DEG2-TTP-TXRX-nmc-761:768'}, - res['roadm-connections'][0]['destination']) - time.sleep(7) + }, **response['roadm-connections'][0]), response['roadm-connections'][0]) + self.assertDictEqual({'src-if': 'SRG1-PP1-TXRX-nmc-761:768'}, response['roadm-connections'][0]['source']) + self.assertDictEqual({'dst-if': 'DEG2-TTP-TXRX-nmc-761:768'}, response['roadm-connections'][0]['destination']) + time.sleep(1) def test_39_check_xc1_ROADMC(self): - response = test_utils.check_netconf_node_request( - "ROADM-C1", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + "ROADM-C1", "roadm-connections", "SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768") + self.assertEqual(response['status_code'], requests.codes.ok) # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2 self.assertDictEqual( dict({ 'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768', 'opticalControlMode': 'gainLoss', 'target-output-power': -3.0 - }, **res['roadm-connections'][0]), - res['roadm-connections'][0] - ) - self.assertDictEqual( - {'src-if': 'SRG1-PP1-TXRX-nmc-761:768'}, - res['roadm-connections'][0]['source']) - self.assertDictEqual( - {'dst-if': 'DEG1-TTP-TXRX-nmc-761:768'}, - res['roadm-connections'][0]['destination']) - time.sleep(7) + }, **response['roadm-connections'][0]), response['roadm-connections'][0]) + self.assertDictEqual({'src-if': 'SRG1-PP1-TXRX-nmc-761:768'}, response['roadm-connections'][0]['source']) + self.assertDictEqual({'dst-if': 'DEG1-TTP-TXRX-nmc-761:768'}, response['roadm-connections'][0]['destination']) + time.sleep(1) def test_40_create_oc_service2(self): - self.cr_serv_sample_data["input"]["service-name"] = "service2" - self.cr_serv_sample_data["input"]["connection-type"] = "roadm-line" - self.cr_serv_sample_data["input"]["service-a-end"]["node-id"] = "ROADM-A1" - self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "OC" - self.cr_serv_sample_data["input"]["service-z-end"]["node-id"] = "ROADM-C1" - self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "OC" - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service2" + self.cr_serv_input_data["connection-type"] = "roadm-line" + self.cr_serv_input_data["service-a-end"]["node-id"] = "ROADM-A1" + self.cr_serv_input_data["service-a-end"]["service-format"] = "OC" + self.cr_serv_input_data["service-z-end"]["node-id"] = "ROADM-C1" + self.cr_serv_input_data["service-z-end"]["service-format"] = "OC" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_41_get_oc_service2(self): - response = test_utils.get_service_list_request("services/service2") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], - 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service2') - self.assertEqual( - res['services'][0]['connection-type'], 'roadm-line') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service2") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service2') + self.assertEqual(response['services'][0]['connection-type'], 'roadm-line') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') + time.sleep(1) def test_42_check_xc2_ROADMA(self): - response = test_utils.check_netconf_node_request( - "ROADM-A1", "roadm-connections/SRG1-PP2-TXRX-DEG2-TTP-TXRX-753:760") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + "ROADM-A1", "roadm-connections", "SRG1-PP2-TXRX-DEG2-TTP-TXRX-753:760") + self.assertEqual(response['status_code'], requests.codes.ok) # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2 self.assertDictEqual( dict({ 'connection-name': 'SRG1-PP2-TXRX-DEG2-TTP-TXRX-753:760', 'opticalControlMode': 'gainLoss', 'target-output-power': -3.0 - }, **res['roadm-connections'][0]), - res['roadm-connections'][0] - ) - self.assertDictEqual( - {'src-if': 'SRG1-PP2-TXRX-nmc-753:760'}, - res['roadm-connections'][0]['source']) - self.assertDictEqual( - {'dst-if': 'DEG2-TTP-TXRX-nmc-753:760'}, - res['roadm-connections'][0]['destination']) - time.sleep(2) + }, **response['roadm-connections'][0]), response['roadm-connections'][0]) + self.assertDictEqual({'src-if': 'SRG1-PP2-TXRX-nmc-753:760'}, response['roadm-connections'][0]['source']) + self.assertDictEqual({'dst-if': 'DEG2-TTP-TXRX-nmc-753:760'}, response['roadm-connections'][0]['destination']) + time.sleep(1) def test_43_check_topo_ROADMA(self): - response = test_utils.get_ordm_topo_request("node/ROADM-A1-SRG1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'SRG1-PP1-TXRX': freq_map = base64.b64decode( @@ -756,42 +718,53 @@ class TransportPCEFulltesting(unittest.TestCase): self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available") elif ele['tp-id'] == 'SRG1-PP3-TXRX': self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele)) - time.sleep(10) + time.sleep(1) self.test_27_check_topo_ROADMA_DEG2() - time.sleep(3) + time.sleep(1) def test_44_delete_oc_service1(self): - response = test_utils.service_delete_request("service1") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) - time.sleep(20) + response['output']['configuration-response-common']['response-message']) + time.sleep(self.WAITING) def test_45_delete_oc_service2(self): - response = test_utils.service_delete_request("service2") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service2" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) - time.sleep(20) + response['output']['configuration-response-common']['response-message']) + time.sleep(self.WAITING) def test_46_get_no_oc_services(self): - print("start test") - response = test_utils.get_service_list_request("") - self.assertEqual(response.status_code, requests.codes.conflict) - res = response.json() - self.assertIn( - {"error-type": "application", "error-tag": "data-missing", - "error-message": "Request could not be completed because the relevant data model content does not exist"}, - res['errors']['error']) + response = test_utils_rfc8040.get_ordm_serv_list_request() + self.assertEqual(response['status_code'], requests.codes.conflict) + self.assertIn(response['service-list'], ( + { + "error-type": "protocol", + "error-tag": "data-missing", + "error-message": + "Request could not be completed because the relevant data " + "model content does not exist" + }, { + "error-type": "application", + "error-tag": "data-missing", + "error-message": + "Request could not be completed because the relevant data " + "model content does not exist" + })) time.sleep(1) def test_47_get_no_xc_ROADMA(self): - response = test_utils.check_netconf_node_request("ROADM-A1", "") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device']) + response = test_utils_rfc8040.check_node_request("ROADM-A1") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertNotIn('roadm-connections', dict.keys(response['org-openroadm-device'])) time.sleep(1) def test_48_check_topo_ROADMA(self): @@ -812,15 +785,18 @@ class TransportPCEFulltesting(unittest.TestCase): self.test_44_delete_oc_service1() def test_50_loop_create_eth_service(self): - response = test_utils.get_service_list_request("services/service1") - if response.status_code != requests.codes.not_found: - response = test_utils.service_delete_request("service1") + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1") + if response['status_code'] != 404: + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) time.sleep(5) - self.cr_serv_sample_data["input"]["connection-type"] = "service" - self.cr_serv_sample_data["input"]["service-a-end"]["node-id"] = "XPDR-A1" - self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "Ethernet" - self.cr_serv_sample_data["input"]["service-z-end"]["node-id"] = "XPDR-C1" - self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "Ethernet" + self.cr_serv_input_data["connection-type"] = "service" + self.cr_serv_input_data["service-a-end"]["node-id"] = "XPDR-A1" + self.cr_serv_input_data["service-a-end"]["service-format"] = "Ethernet" + self.cr_serv_input_data["service-z-end"]["node-id"] = "XPDR-C1" + self.cr_serv_input_data["service-z-end"]["service-format"] = "Ethernet" for i in range(1, 3): # pylint: disable=consider-using-f-string print("iteration number {}".format(i)) @@ -832,20 +808,20 @@ class TransportPCEFulltesting(unittest.TestCase): self.test_31_delete_eth_service2() def test_51_disconnect_XPDRA(self): - response = test_utils.unmount_device("XPDR-A1") - self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200) + response = test_utils_rfc8040.unmount_device("XPDR-A1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) def test_52_disconnect_XPDRC(self): - response = test_utils.unmount_device("XPDR-C1") - self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200) + response = test_utils_rfc8040.unmount_device("XPDR-C1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) def test_53_disconnect_ROADMA(self): - response = test_utils.unmount_device("ROADM-A1") - self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200) + response = test_utils_rfc8040.unmount_device("ROADM-A1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) def test_54_disconnect_ROADMC(self): - response = test_utils.unmount_device("ROADM-C1") - self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200) + response = test_utils_rfc8040.unmount_device("ROADM-C1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) if __name__ == "__main__": 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 22707c43e..5a8a30079 100644 --- a/tests/transportpce_tests/2.2.1/test14_otn_switch_end2end.py +++ b/tests/transportpce_tests/2.2.1/test14_otn_switch_end2end.py @@ -22,7 +22,7 @@ import sys sys.path.append('transportpce_tests/common/') # pylint: disable=wrong-import-position # pylint: disable=import-error -import test_utils # nopep8 +import test_utils_rfc8040 # nopep8 class TransportPCEtesting(unittest.TestCase): @@ -31,7 +31,7 @@ class TransportPCEtesting(unittest.TestCase): WAITING = 20 # nominal value is 300 NODE_VERSION = '2.2.1' - cr_serv_sample_data = {"input": { + cr_serv_input_data = { "sdnc-request-header": { "request-id": "request-1", "rpc-action": "service-create", @@ -123,128 +123,138 @@ class TransportPCEtesting(unittest.TestCase): "due-date": "2018-06-15T00:00:01Z", "operator-contact": "pw1234" } + + del_serv_input_data = { + "sdnc-request-header": { + "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58", + "rpc-action": "service-delete", + "request-system-id": "appname", + "notification-url": "http://localhost:8585/NotificationServer/notify"}, + "service-delete-req-info": { + "service-name": "TBD", + "tail-retention": "no"} } @classmethod def setUpClass(cls): - cls.processes = test_utils.start_tpce() - cls.processes = test_utils.start_sims([('spdra', cls.NODE_VERSION), - ('spdrb', cls.NODE_VERSION), - ('spdrc', cls.NODE_VERSION), - ('roadma', cls.NODE_VERSION), - ('roadmb', cls.NODE_VERSION), - ('roadmc', cls.NODE_VERSION)]) + cls.processes = test_utils_rfc8040.start_tpce() + cls.processes = test_utils_rfc8040.start_sims([('spdra', cls.NODE_VERSION), + ('spdrb', cls.NODE_VERSION), + ('spdrc', cls.NODE_VERSION), + ('roadma', cls.NODE_VERSION), + ('roadmb', cls.NODE_VERSION), + ('roadmc', cls.NODE_VERSION)]) @classmethod def tearDownClass(cls): # pylint: disable=not-an-iterable for process in cls.processes: - test_utils.shutdown_process(process) + test_utils_rfc8040.shutdown_process(process) print("all processes killed") def setUp(self): time.sleep(2) def test_001_connect_spdrA(self): - response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION)) + response = test_utils_rfc8040.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION)) self.assertEqual(response.status_code, - requests.codes.created, test_utils.CODE_SHOULD_BE_201) + requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_002_connect_spdrB(self): - response = test_utils.mount_device("SPDR-SB1", ('spdrb', self.NODE_VERSION)) + response = test_utils_rfc8040.mount_device("SPDR-SB1", ('spdrb', self.NODE_VERSION)) self.assertEqual(response.status_code, - requests.codes.created, test_utils.CODE_SHOULD_BE_201) + requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_003_connect_spdrC(self): - response = test_utils.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION)) + response = test_utils_rfc8040.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION)) self.assertEqual(response.status_code, - requests.codes.created, test_utils.CODE_SHOULD_BE_201) + requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_004_connect_rdmA(self): - response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION)) + response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION)) self.assertEqual(response.status_code, - requests.codes.created, test_utils.CODE_SHOULD_BE_201) + requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_005_connect_rdmB(self): - response = test_utils.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION)) + response = test_utils_rfc8040.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION)) self.assertEqual(response.status_code, - requests.codes.created, test_utils.CODE_SHOULD_BE_201) + requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_006_connect_rdmC(self): - response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION)) + response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION)) self.assertEqual(response.status_code, - requests.codes.created, test_utils.CODE_SHOULD_BE_201) + requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) 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) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'SPDR-SA1', 'xpdr-num': '2', 'network-num': '1', + 'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP3-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) 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) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'SPDR-SA1', 'xpdr-num': '2', 'network-num': '1', + 'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP3-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) 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) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'SPDR-SC1', 'xpdr-num': '2', 'network-num': '1', + 'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP3-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) 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) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'SPDR-SC1', 'xpdr-num': '2', 'network-num': '1', + 'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP3-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) 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) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'SPDR-SB1', 'xpdr-num': '2', 'network-num': '1', + 'rdm-node': 'ROADM-B1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) 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) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'SPDR-SB1', 'xpdr-num': '2', 'network-num': '1', + 'rdm-node': 'ROADM-B1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) 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) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'SPDR-SB1', 'xpdr-num': '2', 'network-num': '2', + 'rdm-node': 'ROADM-B1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) 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) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'SPDR-SB1', 'xpdr-num': '2', 'network-num': '2', + 'rdm-node': 'ROADM-B1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) def test_015_add_omsAttributes_ROADMA_ROADMB(self): @@ -259,8 +269,8 @@ class TransportPCEtesting(unittest.TestCase): "fiber-type": "smf", "SRLG-length": 100000, "pmd": 0.5}]}} - response = test_utils.add_oms_attr_request( - "ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data) + response = test_utils_rfc8040.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", + data) self.assertEqual(response.status_code, requests.codes.created) def test_016_add_omsAttributes_ROADMB_ROADMA(self): @@ -275,8 +285,8 @@ class TransportPCEtesting(unittest.TestCase): "fiber-type": "smf", "SRLG-length": 100000, "pmd": 0.5}]}} - response = test_utils.add_oms_attr_request( - "ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data) + response = test_utils_rfc8040.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", + data) self.assertEqual(response.status_code, requests.codes.created) def test_017_add_omsAttributes_ROADMB_ROADMC(self): @@ -291,8 +301,8 @@ class TransportPCEtesting(unittest.TestCase): "fiber-type": "smf", "SRLG-length": 100000, "pmd": 0.5}]}} - response = test_utils.add_oms_attr_request( - "ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data) + response = test_utils_rfc8040.add_oms_attr_request("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", + data) self.assertEqual(response.status_code, requests.codes.created) def test_018_add_omsAttributes_ROADMC_ROADMB(self): @@ -307,137 +317,145 @@ class TransportPCEtesting(unittest.TestCase): "fiber-type": "smf", "SRLG-length": 100000, "pmd": 0.5}]}} - response = test_utils.add_oms_attr_request( - "ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data) + response = test_utils_rfc8040.add_oms_attr_request("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", + data) self.assertEqual(response.status_code, requests.codes.created) 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) - res = response.json() + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-device-renderer', 'create-ots-oms', + { + 'node-id': 'ROADM-A1', + 'logical-connection-point': 'DEG1-TTP-TXRX' + }) + # time.sleep(10) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADM-A1', - res["output"]["result"]) + response["output"]["result"]) 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) - res = response.json() + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-device-renderer', 'create-ots-oms', + { + 'node-id': 'ROADM-B1', + 'logical-connection-point': 'DEG1-TTP-TXRX' + }) + # time.sleep(10) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADM-B1', - res["output"]["result"]) + response["output"]["result"]) 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) - res = response.json() + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-device-renderer', 'create-ots-oms', + { + 'node-id': 'ROADM-B1', + 'logical-connection-point': 'DEG2-TTP-TXRX' + }) + # time.sleep(10) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADM-B1', - res["output"]["result"]) + response["output"]["result"]) 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) - res = response.json() + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-device-renderer', 'create-ots-oms', + { + 'node-id': 'ROADM-C1', + 'logical-connection-point': 'DEG2-TTP-TXRX' + }) + # time.sleep(10) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADM-C1', - res["output"]["result"]) + response["output"]["result"]) def test_023_calculate_span_loss_base_all(self): - url = "{}/operations/transportpce-olm:calculate-spanloss-base" - data = { - "input": { - "src-type": "all" - } - } - response = test_utils.post_request(url, data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Success', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-olm', 'calculate-spanloss-base', + { + 'src-type': 'all' + }) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Success', response["output"]["result"]) self.assertIn({ "spanloss": "25.7", "link-id": "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX" - }, res["output"]["spans"]) + }, response["output"]["spans"]) self.assertIn({ "spanloss": "17.6", "link-id": "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX" - }, res["output"]["spans"]) + }, response["output"]["spans"]) self.assertIn({ "spanloss": "23.6", "link-id": "ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX" - }, res["output"]["spans"]) + }, response["output"]["spans"]) self.assertIn({ "spanloss": "23.6", "link-id": "ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX" - }, res["output"]["spans"]) + }, response["output"]["spans"]) self.assertIn({ "spanloss": "25.7", "link-id": "ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX" - }, res["output"]["spans"]) + }, response["output"]["spans"]) self.assertIn({ "spanloss": "17.6", "link-id": "ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX" - }, res["output"]["spans"]) + }, response["output"]["spans"]) time.sleep(5) 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() - nbNode = len(res['network'][0]['node']) - self.assertEqual(nbNode, 9, 'There should be 9 nodes') - self.assertNotIn('ietf-network-topology:link', res['network'][0], + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['network'][0]['node']), 9, 'There should be 9 nodes') + self.assertNotIn('ietf-network-topology:link', response['network'][0], 'otn-topology should have no link') # test service-create for OCH-OTU4 service from spdrA to spdrB 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() + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) 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) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service-OCH-OTU4-AB') - self.assertEqual( - res['services'][0]['connection-type'], 'infrastructure') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-OCH-OTU4-AB") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service-OCH-OTU4-AB') + self.assertEqual(response['services'][0]['connection-type'], 'infrastructure') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') + time.sleep(1) # Check correct configuration of devices 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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR2-NETWORK1-761:768') + self.assertEqual(response['status_code'], requests.codes.ok) self.assertDictEqual(dict({'name': 'XPDR2-NETWORK1-761:768', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP5-CFP', 'type': 'org-openroadm-interfaces:opticalChannel', 'supporting-port': 'CP5-CFP-P1' - }, **res['interface'][0]), - res['interface'][0]) - - self.assertDictEqual( - {'frequency': 196.1, 'rate': 'org-openroadm-common-types:R100G', - 'transmit-power': -5, 'modulation-format': 'dp-qpsk'}, - res['interface'][0]['org-openroadm-optical-channel-interfaces:och']) + }, **response['interface'][0]), + response['interface'][0]) + + self.assertEqual('org-openroadm-common-types:R100G', + response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['rate']) + self.assertEqual('dp-qpsk', + response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['modulation-format']) + self.assertEqual(196.1, + float(response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['frequency'])) + self.assertEqual( + -5, + float(response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['transmit-power'])) 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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR2-NETWORK1-OTU') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK1-OTU', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP5-CFP', @@ -452,44 +470,45 @@ class TransportPCEtesting(unittest.TestCase): '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-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']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(input_dict_2, **response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']), + response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']) + + response2 = test_utils_rfc8040.check_node_attribute2_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-OTU', 'org-openroadm-otn-otu-interfaces:otu') + self.assertEqual(response2['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-otu-interfaces:otu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-761:768') + self.assertEqual(response['status_code'], requests.codes.ok) self.assertDictEqual(dict({'name': 'XPDR2-NETWORK1-761:768', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP5-CFP', 'type': 'org-openroadm-interfaces:opticalChannel', 'supporting-port': 'CP5-CFP-P1' - }, **res['interface'][0]), - res['interface'][0]) - - self.assertDictEqual( - {'frequency': 196.1, 'rate': 'org-openroadm-common-types:R100G', - 'transmit-power': -5, 'modulation-format': 'dp-qpsk'}, - res['interface'][0]['org-openroadm-optical-channel-interfaces:och']) + }, **response['interface'][0]), + response['interface'][0]) + + self.assertEqual('org-openroadm-common-types:R100G', + response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['rate']) + self.assertEqual('dp-qpsk', + response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['modulation-format']) + self.assertEqual(196.1, + float(response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['frequency'])) + self.assertEqual( + -5, + float(response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['transmit-power'])) 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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-OTU') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK1-OTU', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP5-CFP', @@ -504,54 +523,61 @@ class TransportPCEtesting(unittest.TestCase): '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-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']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(input_dict_2, **response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']), + response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']) + + response2 = test_utils_rfc8040.check_node_attribute2_request( + 'SPDR-SA1', 'interface', 'XPDR2-NETWORK1-OTU', 'org-openroadm-otn-otu-interfaces:otu') + self.assertEqual(response2['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-otu-interfaces:otu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-dapi']) 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) - res = response.json() - self.assertIn( - {"error-type": "application", "error-tag": "data-missing", - "error-message": "Request could not be completed because the relevant data model content does not exist"}, - res['errors']['error']) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR2-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.conflict) + self.assertIn(response['interface'], ( + { + "error-type": "protocol", + "error-tag": "data-missing", + "error-message": + "Request could not be completed because the relevant data " + "model content does not exist" + }, { + "error-type": "application", + "error-tag": "data-missing", + "error-message": + "Request could not be completed because the relevant data " + "model content does not exist" + })) 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() - ele = res['node'][0]['ietf-network-topology:termination-point'][0] + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'SPDR-SA1-XPDR2', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + ele = response['node']['ietf-network-topology:termination-point'][0] self.assertEqual('XPDR2-NETWORK1', ele['tp-id']) - self.assertEqual({'frequency': 196.1, - 'width': 40}, - ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']) + self.assertEqual( + 196.1, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['frequency'])) + self.assertEqual( + 40, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['width'])) self.assertEqual('ROADM-A1-SRG1--SRG1-PP3-TXRX', ele['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id']) - time.sleep(3) + time.sleep(1) 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() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'SRG1-PP3-TXRX': freq_map = base64.b64decode( @@ -560,17 +586,16 @@ class TransportPCEtesting(unittest.TestCase): self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") if ele['tp-id'] == 'SRG1-PP2-TXRX': self.assertNotIn('avail-freq-maps', dict.keys(ele)) - time.sleep(3) + time.sleep(1) 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() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'DEG1-CTP-TXRX': freq_map = base64.b64decode( @@ -582,17 +607,15 @@ class TransportPCEtesting(unittest.TestCase): ele['org-openroadm-network-topology:tx-ttp-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") - time.sleep(3) + time.sleep(1) 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() - nb_links = len(res['network'][0]['ietf-network-topology:link']) - self.assertEqual(nb_links, 2) + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 2) listLinkId = ['OTU4-SPDR-SA1-XPDR2-XPDR2-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK1', 'OTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK1toSPDR-SA1-XPDR2-XPDR2-NETWORK1'] - for link in res['network'][0]['ietf-network-topology:link']: + for link in response['network'][0]['ietf-network-topology:link']: self.assertIn(link['link-id'], listLinkId) self.assertEqual( link['transportpce-networkutils:otn-link-type'], 'OTU4') @@ -608,68 +631,65 @@ class TransportPCEtesting(unittest.TestCase): # test service-create for OCH-OTU4 service from spdrB to spdrC + 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" - self.cr_serv_sample_data["input"]["service-a-end"]["clli"] = "NodeSB" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2" - self.cr_serv_sample_data["input"]["service-z-end"]["node-id"] = "SPDR-SC1" - self.cr_serv_sample_data["input"]["service-z-end"]["clli"] = "NodeSC" - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" - - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service-OCH-OTU4-BC" + self.cr_serv_input_data["service-a-end"]["node-id"] = "SPDR-SB1" + self.cr_serv_input_data["service-a-end"]["clli"] = "NodeSB" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2" + self.cr_serv_input_data["service-z-end"]["node-id"] = "SPDR-SC1" + self.cr_serv_input_data["service-z-end"]["clli"] = "NodeSC" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) 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) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service-OCH-OTU4-BC') - self.assertEqual( - res['services'][0]['connection-type'], 'infrastructure') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-OCH-OTU4-BC") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service-OCH-OTU4-BC') + self.assertEqual(response['services'][0]['connection-type'], 'infrastructure') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') + time.sleep(1) # Check correct configuration of devices 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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-753:760') + self.assertEqual(response['status_code'], requests.codes.ok) self.assertDictEqual(dict({'name': 'XPDR2-NETWORK1-753:760', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP6-CFP', 'type': 'org-openroadm-interfaces:opticalChannel', 'supporting-port': 'CP1-CFP0-P1' - }, **res['interface'][0]), - res['interface'][0]) - - self.assertDictEqual( - {'frequency': 196.05, 'rate': 'org-openroadm-common-types:R100G', - 'transmit-power': -5, 'modulation-format': 'dp-qpsk'}, - res['interface'][0]['org-openroadm-optical-channel-interfaces:och']) + }, **response['interface'][0]), + response['interface'][0]) + + self.assertEqual('org-openroadm-common-types:R100G', + response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['rate']) + self.assertEqual('dp-qpsk', + response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['modulation-format']) + self.assertEqual(196.05, + float(response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['frequency'])) + self.assertEqual( + -5, + float(response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['transmit-power'])) 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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-OTU') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK2-OTU', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP6-CFP', @@ -684,44 +704,45 @@ class TransportPCEtesting(unittest.TestCase): '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']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(input_dict_2, **response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']), + response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']) + + response2 = test_utils_rfc8040.check_node_attribute2_request( + 'SPDR-SC1', 'interface', 'XPDR2-NETWORK1-OTU', 'org-openroadm-otn-otu-interfaces:otu') + self.assertEqual(response2['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-otu-interfaces:otu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-dapi']) 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) - res = response.json() - self.assertDictEqual(dict({'name': 'XPDR2-NETWORK1-761:768', + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR2-NETWORK1-753:760') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertDictEqual(dict({'name': 'XPDR2-NETWORK1-753:760', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP5-CFP', 'type': 'org-openroadm-interfaces:opticalChannel', 'supporting-port': 'CP5-CFP-P1' - }, **res['interface'][0]), - res['interface'][0]) - - self.assertDictEqual( - {'frequency': 196.05, 'rate': 'org-openroadm-common-types:R100G', - 'transmit-power': -5, 'modulation-format': 'dp-qpsk'}, - res['interface'][0]['org-openroadm-optical-channel-interfaces:och']) + }, **response['interface'][0]), + response['interface'][0]) + + self.assertEqual('org-openroadm-common-types:R100G', + response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['rate']) + self.assertEqual('dp-qpsk', + response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['modulation-format']) + self.assertEqual(196.05, + float(response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['frequency'])) + self.assertEqual( + -5, + float(response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['transmit-power'])) 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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR2-NETWORK1-OTU') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK1-OTU', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP5-CFP', @@ -736,67 +757,76 @@ class TransportPCEtesting(unittest.TestCase): '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-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']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(input_dict_2, **response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']), + response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']) + + response2 = test_utils_rfc8040.check_node_attribute2_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-OTU', 'org-openroadm-otn-otu-interfaces:otu') + self.assertEqual(response2['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-otu-interfaces:otu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-dapi']) 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) - res = response.json() - self.assertIn( - {"error-type": "application", "error-tag": "data-missing", - "error-message": "Request could not be completed because the relevant data model content does not exist"}, - res['errors']['error']) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.conflict) + self.assertIn(response['interface'], ( + { + "error-type": "protocol", + "error-tag": "data-missing", + "error-message": + "Request could not be completed because the relevant data " + "model content does not exist" + }, { + "error-type": "application", + "error-tag": "data-missing", + "error-message": + "Request could not be completed because the relevant data " + "model content does not exist" + })) 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() - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'SPDR-SB1-XPDR2', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + liste_tp = response['node']['ietf-network-topology:termination-point'] # pylint: disable=consider-using-f-string for ele in liste_tp: if ele['tp-id'] == 'XPDR2-NETWORK1': - self.assertEqual({'frequency': 196.1, - 'width': 40}, - ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']) + self.assertEqual( + 196.1, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['frequency'])) + self.assertEqual( + 40, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['width'])) self.assertEqual('ROADM-B1-SRG1--SRG1-PP1-TXRX', ele['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id']) elif ele['tp-id'] == 'XPDR2-NETWORK2': - self.assertEqual({'frequency': 196.05, - 'width': 40}, - ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']) + self.assertEqual( + 196.05, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['frequency'])) + self.assertEqual( + 40, + float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['width'])) self.assertEqual('ROADM-B1-SRG1--SRG1-PP2-TXRX', ele['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id']) else: - print("ele = {}".format(ele)) self.assertNotIn('org-openroadm-network-topology:xpdr-network-attributes', dict.keys(ele)) - time.sleep(3) + time.sleep(1) 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() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-SRG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available") self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available") self.assertEqual(freq_map_array[93], 255, "Lambda 3 should be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'SRG1-PP1-TXRX': freq_map = base64.b64decode( @@ -810,17 +840,16 @@ class TransportPCEtesting(unittest.TestCase): self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available") if ele['tp-id'] == 'SRG1-PP3-TXRX': self.assertNotIn('avail-freq-maps', dict.keys(ele)) - time.sleep(3) + time.sleep(1) 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() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-DEG2', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'DEG2-CTP-TXRX': freq_map = base64.b64decode( @@ -832,19 +861,17 @@ class TransportPCEtesting(unittest.TestCase): ele['org-openroadm-network-topology:tx-ttp-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[94], 0, "Lambda 1 should not be available") - time.sleep(3) + time.sleep(1) 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() - nb_links = len(res['network'][0]['ietf-network-topology:link']) - self.assertEqual(nb_links, 4) + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 4) listLinkId = ['OTU4-SPDR-SA1-XPDR2-XPDR2-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK1', 'OTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK1toSPDR-SA1-XPDR2-XPDR2-NETWORK1', 'OTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK2toSPDR-SC1-XPDR2-XPDR2-NETWORK1', 'OTU4-SPDR-SC1-XPDR2-XPDR2-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK2'] - for link in res['network'][0]['ietf-network-topology:link']: + for link in response['network'][0]['ietf-network-topology:link']: self.assertIn(link['link-id'], listLinkId) self.assertEqual( link['transportpce-networkutils:otn-link-type'], 'OTU4') @@ -857,81 +884,73 @@ class TransportPCEtesting(unittest.TestCase): self.assertIn( link['org-openroadm-common-network:opposite-link'], listLinkId) + # test service-create for 100GE service from spdrA to spdrC via spdrB + 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" - self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "Ethernet" - self.cr_serv_sample_data["input"]["service-a-end"]["node-id"] = "SPDR-SA1" - self.cr_serv_sample_data["input"]["service-a-end"]["clli"] = "NodeSA" - del self.cr_serv_sample_data["input"]["service-a-end"]["otu-service-rate"] - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR2" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR2" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" - self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "Ethernet" - self.cr_serv_sample_data["input"]["service-z-end"]["node-id"] = "SPDR-SC1" - self.cr_serv_sample_data["input"]["service-z-end"]["clli"] = "NodeSC" - del self.cr_serv_sample_data["input"]["service-z-end"]["otu-service-rate"] - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" - - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service-100GE-ABC" + self.cr_serv_input_data["connection-type"] = "service" + self.cr_serv_input_data["service-a-end"]["service-format"] = "Ethernet" + self.cr_serv_input_data["service-a-end"]["node-id"] = "SPDR-SA1" + self.cr_serv_input_data["service-a-end"]["clli"] = "NodeSA" + del self.cr_serv_input_data["service-a-end"]["otu-service-rate"] + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR2" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR2" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" + self.cr_serv_input_data["service-z-end"]["service-format"] = "Ethernet" + self.cr_serv_input_data["service-z-end"]["node-id"] = "SPDR-SC1" + self.cr_serv_input_data["service-z-end"]["clli"] = "NodeSC" + del self.cr_serv_input_data["service-z-end"]["otu-service-rate"] + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) 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) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service-100GE-ABC') - self.assertEqual( - res['services'][0]['connection-type'], 'service') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-100GE-ABC") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service-100GE-ABC') + self.assertEqual(response['services'][0]['connection-type'], 'service') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') + time.sleep(1) 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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR2-CLIENT1-ETHERNET') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict = {'name': 'XPDR2-CLIENT1-ETHERNET', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP2-QSFP1', 'type': 'org-openroadm-interfaces:ethernetCsmacd', 'supporting-port': 'CP2-QSFP1-P1' } - self.assertDictEqual(dict(input_dict, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual( - {'speed': 100000, - 'fec': 'off'}, - res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']) + self.assertDictEqual(dict(input_dict, **response['interface'][0]), + response['interface'][0]) + self.assertEqual(100000, response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed']) + self.assertEqual('off', response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['fec']) 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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR2-CLIENT1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-CLIENT1-ODU4', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP2-QSFP1', 'supporting-interface': 'XPDR2-CLIENT1-ETHERNET', 'type': 'org-openroadm-interfaces:otnOdu', 'supporting-port': 'CP2-QSFP1-P1'} + # SAPI/DAPI are added in the Otu4 renderer input_dict_2 = { - 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP', + 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP', 'rate': 'org-openroadm-otn-common-types:ODU4', 'monitoring-mode': 'terminated', 'expected-dapi': 'AItaZ6nmyaKJ', @@ -939,28 +958,32 @@ class TransportPCEtesting(unittest.TestCase): 'tx-dapi': 'AKFnJJaijWiz', 'tx-sapi': 'AItaZ6nmyaKJ'} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(input_dict_2, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + **input_dict_2), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + ) 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']) + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu']) + + response2 = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR2-CLIENT1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-dapi']) 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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR2-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP5-CFP', @@ -973,56 +996,51 @@ class TransportPCEtesting(unittest.TestCase): 'rate': 'org-openroadm-otn-common-types:ODU4', 'monitoring-mode': 'monitored'} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(input_dict_2, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + **input_dict_2), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + ) self.assertNotIn('opu', - dict.keys(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])) + dict.keys(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])) 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") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'odu-connection', 'XPDR2-CLIENT1-ODU4-x-XPDR2-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = { 'connection-name': 'XPDR2-CLIENT1-ODU4-x-XPDR2-NETWORK1-ODU4', 'direction': 'bidirectional' } - self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]), - res['odu-connection'][0]) + self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]), + response['odu-connection'][0]) self.assertDictEqual({'dst-if': 'XPDR2-NETWORK1-ODU4'}, - res['odu-connection'][0]['destination']) + response['odu-connection'][0]['destination']) self.assertDictEqual({'src-if': 'XPDR2-CLIENT1-ODU4'}, - res['odu-connection'][0]['source']) + response['odu-connection'][0]['source']) 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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR2-CLIENT1-ETHERNET') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict = {'name': 'XPDR2-CLIENT1-ETHERNET', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP2-QSFP1', 'type': 'org-openroadm-interfaces:ethernetCsmacd', 'supporting-port': 'CP2-QSFP1-P1' } - self.assertDictEqual(dict(input_dict, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual( - {'speed': 100000, - 'fec': 'off'}, - res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']) + self.assertDictEqual(dict(input_dict, **response['interface'][0]), + response['interface'][0]) + self.assertEqual(100000, response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed']) + self.assertEqual('off', response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['fec']) 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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR2-CLIENT1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-CLIENT1-ODU4', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP2-QSFP1', @@ -1040,28 +1058,32 @@ class TransportPCEtesting(unittest.TestCase): 'tx-dapi': 'AItaZ6nmyaKJ', 'tx-sapi': 'AKFnJJaijWiz'} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(input_dict_2, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + **input_dict_2), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + ) 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']) + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu']) + + response2 = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR2-CLIENT1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-dapi']) 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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR2-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP5-CFP', @@ -1074,38 +1096,36 @@ class TransportPCEtesting(unittest.TestCase): 'rate': 'org-openroadm-otn-common-types:ODU4', 'monitoring-mode': 'monitored'} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(input_dict_2, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + **input_dict_2), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + ) self.assertNotIn('opu', - dict.keys(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])) + dict.keys(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])) 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") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'odu-connection', 'XPDR2-CLIENT1-ODU4-x-XPDR2-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = { 'connection-name': 'XPDR2-CLIENT1-ODU4-x-XPDR2-NETWORK1-ODU4', 'direction': 'bidirectional' } - self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]), - res['odu-connection'][0]) + self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]), + response['odu-connection'][0]) self.assertDictEqual({'dst-if': 'XPDR2-NETWORK1-ODU4'}, - res['odu-connection'][0]['destination']) + response['odu-connection'][0]['destination']) self.assertDictEqual({'src-if': 'XPDR2-CLIENT1-ODU4'}, - res['odu-connection'][0]['source']) + response['odu-connection'][0]['source']) 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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP5-CFP', @@ -1116,20 +1136,20 @@ class TransportPCEtesting(unittest.TestCase): 'rate': 'org-openroadm-otn-common-types:ODU4', 'monitoring-mode': 'monitored'} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(input_dict_2, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + **input_dict_2), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + ) self.assertNotIn('opu', - dict.keys(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])) + dict.keys(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])) 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) - res = response.json() - input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4', + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) + input_dict_1 = {'name': 'XPDR2-NETWORK2-ODU4', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP6-CFP', 'type': 'org-openroadm-interfaces:otnOdu', @@ -1139,147 +1159,154 @@ class TransportPCEtesting(unittest.TestCase): 'rate': 'org-openroadm-otn-common-types:ODU4', 'monitoring-mode': 'monitored'} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(input_dict_2, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + **input_dict_2), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + ) self.assertNotIn('opu', - dict.keys(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])) + dict.keys(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])) 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") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'odu-connection', 'XPDR2-NETWORK1-ODU4-x-XPDR2-NETWORK2-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = { 'connection-name': 'XPDR2-NETWORK1-ODU4-x-XPDR2-NETWORK2-ODU4', 'direction': 'bidirectional' } - self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]), - res['odu-connection'][0]) + self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]), + response['odu-connection'][0]) self.assertDictEqual({'dst-if': 'XPDR2-NETWORK2-ODU4'}, - res['odu-connection'][0]['destination']) + response['odu-connection'][0]['destination']) self.assertDictEqual({'src-if': 'XPDR2-NETWORK1-ODU4'}, - res['odu-connection'][0]['source']) + response['odu-connection'][0]['source']) 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() - nb_links = len(res['network'][0]['ietf-network-topology:link']) - self.assertEqual(nb_links, 4) - for link in res['network'][0]['ietf-network-topology:link']: + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 4) + for link in response['network'][0]['ietf-network-topology:link']: self.assertEqual( link['org-openroadm-otn-network-topology:available-bandwidth'], 0) self.assertEqual( link['org-openroadm-otn-network-topology:used-bandwidth'], 100000) 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() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-100GE-ABC" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) 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) + response = test_utils_rfc8040.get_ordm_serv_list_request() + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['service-list']['services']), 2) + time.sleep(1) 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']) + response = test_utils_rfc8040.check_node_request("SPDR-SA1") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertNotIn(['odu-connection'][0], response['org-openroadm-device']) time.sleep(1) 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) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR2-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.conflict) 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) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR2-CLIENT1-ODU4') + self.assertEqual(response['status_code'], requests.codes.conflict) 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) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR2-CLIENT1-ETHERNET') + self.assertEqual(response['status_code'], requests.codes.conflict) def test_067_check_otn_topo_links(self): self.test_046_check_otn_topo_otu4_links() 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() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-OCH-OTU4-AB" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) 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() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-OCH-OTU4-BC" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) 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() - self.assertIn( - {"error-type": "application", "error-tag": "data-missing", - "error-message": "Request could not be completed because the relevant data model content does not exist"}, - res['errors']['error']) + response = test_utils_rfc8040.get_ordm_serv_list_request() + self.assertEqual(response['status_code'], requests.codes.conflict) + self.assertIn(response['service-list'], ( + { + "error-type": "protocol", + "error-tag": "data-missing", + "error-message": + "Request could not be completed because the relevant data " + "model content does not exist" + }, { + "error-type": "application", + "error-tag": "data-missing", + "error-message": + "Request could not be completed because the relevant data " + "model content does not exist" + })) time.sleep(1) 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) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR2-NETWORK1-OTU') + self.assertEqual(response['status_code'], requests.codes.conflict) 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) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR2-NETWORK1-761:768') + self.assertEqual(response['status_code'], requests.codes.conflict) 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]) + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertNotIn('ietf-network-topology:link', response['network'][0]) 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() - tp = res['node'][0]['ietf-network-topology:termination-point'][0] + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'SPDR-SA1-XPDR2', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + tp = response['node']['ietf-network-topology:termination-point'][0] self.assertEqual('XPDR2-NETWORK1', tp['tp-id']) self.assertNotIn('wavelength', dict.keys( tp['org-openroadm-network-topology:xpdr-network-attributes'])) - time.sleep(3) + time.sleep(1) 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() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-SRG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available") self.assertEqual(freq_map_array[94], 255, "Lambda 1 should be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'SRG1-PP1-TXRX': freq_map = base64.b64decode( @@ -1291,17 +1318,16 @@ class TransportPCEtesting(unittest.TestCase): ele['org-openroadm-network-topology:pp-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[94], 255, "Lambda 1 should be available") - time.sleep(3) + time.sleep(1) 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() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-DEG1', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'DEG1-CTP-TXRX': freq_map = base64.b64decode( @@ -1313,17 +1339,16 @@ class TransportPCEtesting(unittest.TestCase): ele['org-openroadm-network-topology:tx-ttp-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available") - time.sleep(3) + time.sleep(1) 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() + response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-DEG2', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) freq_map = base64.b64decode( - res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) + response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available") - liste_tp = res['node'][0]['ietf-network-topology:termination-point'] + liste_tp = response['node']['ietf-network-topology:termination-point'] for ele in liste_tp: if ele['tp-id'] == 'DEG2-CTP-TXRX': freq_map = base64.b64decode( @@ -1335,43 +1360,37 @@ class TransportPCEtesting(unittest.TestCase): ele['org-openroadm-network-topology:tx-ttp-attributes']['avail-freq-maps'][0]['freq-map']) freq_map_array = [int(x) for x in freq_map] self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available") - time.sleep(3) + time.sleep(1) 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) - res = response.json() - links = res['network'][0]['ietf-network-topology:link'] + response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + links = response['network'][0]['ietf-network-topology:link'] for link in links: if (link["org-openroadm-common-network:link-type"] in ('XPONDER-OUTPUT', 'XPONDER-INPUT') and ('SPDR-SB1' in link['link-id'] or 'ROADM-B1' in link['link-id'])): - link_name = link["link-id"] - response = test_utils.delete_request(url+link_name) - self.assertEqual(response.status_code, requests.codes.ok) + response = test_utils_rfc8040.del_ietf_network_link_request( + 'openroadm-topology', link['link-id'], 'config') + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) 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) + response = test_utils_rfc8040.unmount_device("SPDR-SB1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) 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) + response = test_utils_rfc8040.unmount_device("ROADM-B1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) 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) - res = response.json() - links = res['network'][0]['ietf-network-topology:link'] + response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + links = response['network'][0]['ietf-network-topology:link'] for link in links: if (link["org-openroadm-common-network:link-type"] == "ROADM-TO-ROADM" and 'ROADM-B1' in link['link-id']): - link_name = link["link-id"] - response = test_utils.delete_request(url+link_name) - self.assertEqual(response.status_code, requests.codes.ok) + response = test_utils_rfc8040.del_ietf_network_link_request( + 'openroadm-topology', link['link-id'], 'config') + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) def test_082_add_omsAttributes_ROADMA_ROADMC(self): # Config ROADMA-ROADMC oms-attributes @@ -1385,8 +1404,8 @@ class TransportPCEtesting(unittest.TestCase): "fiber-type": "smf", "SRLG-length": 100000, "pmd": 0.5}]}} - response = test_utils.add_oms_attr_request( - "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data) + response = test_utils_rfc8040.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", + data) self.assertEqual(response.status_code, requests.codes.created) def test_083_add_omsAttributes_ROADMC_ROADMA(self): @@ -1401,98 +1420,86 @@ class TransportPCEtesting(unittest.TestCase): "fiber-type": "smf", "SRLG-length": 100000, "pmd": 0.5}]}} - response = test_utils.add_oms_attr_request( - "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data) + response = test_utils_rfc8040.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", + data) self.assertEqual(response.status_code, requests.codes.created) 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" - self.cr_serv_sample_data["input"]["service-a-end"]["service-rate"] = "100" - self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "OTU" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR2" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR2" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" - self.cr_serv_sample_data["input"]["service-a-end"]["otu-service-rate"] = "org-openroadm-otn-common-types:OTU4" - self.cr_serv_sample_data["input"]["service-z-end"]["service-rate"] = "100" - self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "OTU" - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" - self.cr_serv_sample_data["input"]["service-z-end"]["otu-service-rate"] = "org-openroadm-otn-common-types:OTU4" - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service-OCH-OTU4-AC" + self.cr_serv_input_data["connection-type"] = "infrastructure" + self.cr_serv_input_data["service-a-end"]["service-rate"] = "100" + self.cr_serv_input_data["service-a-end"]["service-format"] = "OTU" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR2" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR2" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" + self.cr_serv_input_data["service-a-end"]["otu-service-rate"] = "org-openroadm-otn-common-types:OTU4" + self.cr_serv_input_data["service-z-end"]["service-rate"] = "100" + self.cr_serv_input_data["service-z-end"]["service-format"] = "OTU" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" + self.cr_serv_input_data["service-z-end"]["otu-service-rate"] = "org-openroadm-otn-common-types:OTU4" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) 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) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service-OCH-OTU4-AC') - self.assertEqual( - res['services'][0]['connection-type'], 'infrastructure') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-OCH-OTU4-AC") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service-OCH-OTU4-AC') + self.assertEqual(response['services'][0]['connection-type'], 'infrastructure') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') + time.sleep(1) # test service-create for 100GE service from spdrA to spdrC via spdrB 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" - self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "Ethernet" - self.cr_serv_sample_data["input"]["service-a-end"]["node-id"] = "SPDR-SA1" - self.cr_serv_sample_data["input"]["service-a-end"]["clli"] = "NodeSA" - del self.cr_serv_sample_data["input"]["service-a-end"]["otu-service-rate"] - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR2" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR2" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" - self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "Ethernet" - self.cr_serv_sample_data["input"]["service-z-end"]["node-id"] = "SPDR-SC1" - self.cr_serv_sample_data["input"]["service-z-end"]["clli"] = "NodeSC" - del self.cr_serv_sample_data["input"]["service-z-end"]["otu-service-rate"] - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" - - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service-100GE-AC" + self.cr_serv_input_data["connection-type"] = "service" + self.cr_serv_input_data["service-a-end"]["service-format"] = "Ethernet" + self.cr_serv_input_data["service-a-end"]["node-id"] = "SPDR-SA1" + self.cr_serv_input_data["service-a-end"]["clli"] = "NodeSA" + del self.cr_serv_input_data["service-a-end"]["otu-service-rate"] + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR2" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR2" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" + self.cr_serv_input_data["service-z-end"]["service-format"] = "Ethernet" + self.cr_serv_input_data["service-z-end"]["node-id"] = "SPDR-SC1" + self.cr_serv_input_data["service-z-end"]["clli"] = "NodeSC" + del self.cr_serv_input_data["service-z-end"]["otu-service-rate"] + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR2" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1" + + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) 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() - self.assertEqual( - res['services'][0]['administrative-state'], 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service-100GE-AC') - self.assertEqual( - res['services'][0]['connection-type'], 'service') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-100GE-AC") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service-100GE-AC') + self.assertEqual(response['services'][0]['connection-type'], 'service') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') + time.sleep(1) 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() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR2-NETWORK1-OTU') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK1-OTU', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP5-CFP', @@ -1507,26 +1514,23 @@ class TransportPCEtesting(unittest.TestCase): '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']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(input_dict_2, **response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']), + response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']) + + response2 = test_utils_rfc8040.check_node_attribute2_request( + 'SPDR-SC1', 'interface', 'XPDR2-NETWORK1-OTU', 'org-openroadm-otn-otu-interfaces:otu') + self.assertEqual(response2['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-otu-interfaces:otu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-dapi']) 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() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR2-NETWORK1-OTU') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK1-OTU', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP5-CFP', @@ -1541,20 +1545,18 @@ class TransportPCEtesting(unittest.TestCase): '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-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']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(input_dict_2, **response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']), + response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']) + + response2 = test_utils_rfc8040.check_node_attribute2_request( + 'SPDR-SA1', 'interface', 'XPDR2-NETWORK1-OTU', 'org-openroadm-otn-otu-interfaces:otu') + self.assertEqual(response2['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-otu-interfaces:otu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-dapi']) def test_090_check_configuration_spdra(self): self.test_049_check_interface_100GE_CLIENT_spdra() @@ -1569,31 +1571,30 @@ class TransportPCEtesting(unittest.TestCase): 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() - nb_links = len(res['network'][0]['ietf-network-topology:link']) - self.assertEqual(nb_links, 2) - for link in res['network'][0]['ietf-network-topology:link']: + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 2) + for link in response['network'][0]['ietf-network-topology:link']: self.assertEqual( link['org-openroadm-otn-network-topology:available-bandwidth'], 0) self.assertEqual( link['org-openroadm-otn-network-topology:used-bandwidth'], 100000) 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() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-100GE-AC" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) 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) + response = test_utils_rfc8040.get_ordm_serv_list_request() + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['service-list']['services']), 1) + time.sleep(1) def test_095_check_configuration_spdra(self): self.test_063_check_no_ODU4_connection_spdra() @@ -1602,48 +1603,40 @@ class TransportPCEtesting(unittest.TestCase): self.test_066_check_no_interface_100GE_CLIENT_spdra() 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() - nb_links = len(res['network'][0]['ietf-network-topology:link']) - self.assertEqual(nb_links, 2) - for link in res['network'][0]['ietf-network-topology:link']: + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 2) + for link in response['network'][0]['ietf-network-topology:link']: self.assertEqual( link['org-openroadm-otn-network-topology:available-bandwidth'], 100000) self.assertEqual( link['org-openroadm-otn-network-topology:used-bandwidth'], 0) 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) - res = response.json() - links = res['network'][0]['ietf-network-topology:link'] + response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + links = response['network'][0]['ietf-network-topology:link'] for link in links: if link["org-openroadm-common-network:link-type"] in ('XPONDER-OUTPUT', 'XPONDER-INPUT'): - link_name = link["link-id"] - response = test_utils.delete_request(url+link_name) - self.assertEqual(response.status_code, requests.codes.ok) + response = test_utils_rfc8040.del_ietf_network_link_request( + 'openroadm-topology', link['link-id'], 'config') + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) 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) + response = test_utils_rfc8040.unmount_device("SPDR-SA1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) 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) + response = test_utils_rfc8040.unmount_device("SPDR-SC1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) 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) + response = test_utils_rfc8040.unmount_device("ROADM-A1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) 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) + response = test_utils_rfc8040.unmount_device("ROADM-C1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) if __name__ == "__main__": diff --git a/tests/transportpce_tests/2.2.1/test15_otn_end2end_with_intermediate_switch.py b/tests/transportpce_tests/2.2.1/test15_otn_end2end_with_intermediate_switch.py index 11de71040..fc4c1ba63 100644 --- a/tests/transportpce_tests/2.2.1/test15_otn_end2end_with_intermediate_switch.py +++ b/tests/transportpce_tests/2.2.1/test15_otn_end2end_with_intermediate_switch.py @@ -21,7 +21,7 @@ import sys sys.path.append('transportpce_tests/common/') # pylint: disable=wrong-import-position # pylint: disable=import-error -import test_utils # nopep8 +import test_utils_rfc8040 # nopep8 class TransportPCEtesting(unittest.TestCase): @@ -30,7 +30,7 @@ class TransportPCEtesting(unittest.TestCase): WAITING = 20 # nominal value is 300 NODE_VERSION = '2.2.1' - cr_serv_sample_data = {"input": { + cr_serv_input_data = { "sdnc-request-header": { "request-id": "request-1", "rpc-action": "service-create", @@ -122,128 +122,137 @@ class TransportPCEtesting(unittest.TestCase): "due-date": "2018-06-15T00:00:01Z", "operator-contact": "pw1234" } + del_serv_input_data = { + "sdnc-request-header": { + "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58", + "rpc-action": "service-delete", + "request-system-id": "appname", + "notification-url": "http://localhost:8585/NotificationServer/notify"}, + "service-delete-req-info": { + "service-name": "TBD", + "tail-retention": "no"} } @classmethod def setUpClass(cls): - cls.processes = test_utils.start_tpce() - cls.processes = test_utils.start_sims([('spdra', cls.NODE_VERSION), - ('spdrb', cls.NODE_VERSION), - ('spdrc', cls.NODE_VERSION), - ('roadma', cls.NODE_VERSION), - ('roadmb', cls.NODE_VERSION), - ('roadmc', cls.NODE_VERSION)]) + cls.processes = test_utils_rfc8040.start_tpce() + cls.processes = test_utils_rfc8040.start_sims([('spdra', cls.NODE_VERSION), + ('spdrb', cls.NODE_VERSION), + ('spdrc', cls.NODE_VERSION), + ('roadma', cls.NODE_VERSION), + ('roadmb', cls.NODE_VERSION), + ('roadmc', cls.NODE_VERSION)]) @classmethod def tearDownClass(cls): # pylint: disable=not-an-iterable for process in cls.processes: - test_utils.shutdown_process(process) + test_utils_rfc8040.shutdown_process(process) print("all processes killed") def setUp(self): time.sleep(2) def test_001_connect_spdrA(self): - response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION)) + response = test_utils_rfc8040.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION)) self.assertEqual(response.status_code, - requests.codes.created, test_utils.CODE_SHOULD_BE_201) + requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_002_connect_spdrB(self): - response = test_utils.mount_device("SPDR-SB1", ('spdrb', self.NODE_VERSION)) + response = test_utils_rfc8040.mount_device("SPDR-SB1", ('spdrb', self.NODE_VERSION)) self.assertEqual(response.status_code, - requests.codes.created, test_utils.CODE_SHOULD_BE_201) + requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_003_connect_spdrC(self): - response = test_utils.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION)) + response = test_utils_rfc8040.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION)) self.assertEqual(response.status_code, - requests.codes.created, test_utils.CODE_SHOULD_BE_201) + requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_004_connect_rdmA(self): - response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION)) + response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION)) self.assertEqual(response.status_code, - requests.codes.created, test_utils.CODE_SHOULD_BE_201) + requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_005_connect_rdmB(self): - response = test_utils.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION)) + response = test_utils_rfc8040.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION)) self.assertEqual(response.status_code, - requests.codes.created, test_utils.CODE_SHOULD_BE_201) + requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_006_connect_rdmC(self): - response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION)) + response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION)) self.assertEqual(response.status_code, - requests.codes.created, test_utils.CODE_SHOULD_BE_201) + requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201) def test_007_connect_sprdA_1_N1_to_roadmA_PP1(self): - response = test_utils.connect_xpdr_to_rdm_request("SPDR-SA1", "1", "1", - "ROADM-A1", "1", "SRG1-PP1-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'SPDR-SA1', 'xpdr-num': '1', 'network-num': '1', + 'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) def test_008_connect_roadmA_PP1_to_spdrA_1_N1(self): - response = test_utils.connect_rdm_to_xpdr_request("SPDR-SA1", "1", "1", - "ROADM-A1", "1", "SRG1-PP1-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'SPDR-SA1', 'xpdr-num': '1', 'network-num': '1', + 'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) def test_009_connect_sprdC_1_N1_to_roadmC_PP1(self): - response = test_utils.connect_xpdr_to_rdm_request("SPDR-SC1", "1", "1", - "ROADM-C1", "1", "SRG1-PP1-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'SPDR-SC1', 'xpdr-num': '1', 'network-num': '1', + 'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) def test_010_connect_roadmC_PP1_to_spdrC_1_N1(self): - response = test_utils.connect_rdm_to_xpdr_request("SPDR-SC1", "1", "1", - "ROADM-C1", "1", "SRG1-PP1-TXRX") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'SPDR-SC1', 'xpdr-num': '1', 'network-num': '1', + 'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) 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) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'SPDR-SB1', 'xpdr-num': '2', 'network-num': '1', + 'rdm-node': 'ROADM-B1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) 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) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'SPDR-SB1', 'xpdr-num': '2', 'network-num': '1', + 'rdm-node': 'ROADM-B1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) 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) - res = response.json() - self.assertIn('Xponder Roadm Link created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-xpdr-rdm-links', + {'links-input': {'xpdr-node': 'SPDR-SB1', 'xpdr-num': '2', 'network-num': '2', + 'rdm-node': 'ROADM-B1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"]) time.sleep(2) 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) - res = response.json() - self.assertIn('Roadm Xponder links created successfully', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-networkutils', 'init-rdm-xpdr-links', + {'links-input': {'xpdr-node': 'SPDR-SB1', 'xpdr-num': '2', 'network-num': '2', + 'rdm-node': 'ROADM-B1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}}) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Roadm Xponder links created successfully', response["output"]["result"]) time.sleep(2) def test_015_add_omsAttributes_ROADMA_ROADMB(self): @@ -258,8 +267,8 @@ class TransportPCEtesting(unittest.TestCase): "fiber-type": "smf", "SRLG-length": 100000, "pmd": 0.5}]}} - response = test_utils.add_oms_attr_request( - "ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data) + response = test_utils_rfc8040.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", + data) self.assertEqual(response.status_code, requests.codes.created) def test_016_add_omsAttributes_ROADMB_ROADMA(self): @@ -274,8 +283,8 @@ class TransportPCEtesting(unittest.TestCase): "fiber-type": "smf", "SRLG-length": 100000, "pmd": 0.5}]}} - response = test_utils.add_oms_attr_request( - "ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data) + response = test_utils_rfc8040.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", + data) self.assertEqual(response.status_code, requests.codes.created) def test_017_add_omsAttributes_ROADMB_ROADMC(self): @@ -290,8 +299,8 @@ class TransportPCEtesting(unittest.TestCase): "fiber-type": "smf", "SRLG-length": 100000, "pmd": 0.5}]}} - response = test_utils.add_oms_attr_request( - "ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data) + response = test_utils_rfc8040.add_oms_attr_request("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", + data) self.assertEqual(response.status_code, requests.codes.created) def test_018_add_omsAttributes_ROADMC_ROADMB(self): @@ -306,122 +315,121 @@ class TransportPCEtesting(unittest.TestCase): "fiber-type": "smf", "SRLG-length": 100000, "pmd": 0.5}]}} - response = test_utils.add_oms_attr_request( - "ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data) + response = test_utils_rfc8040.add_oms_attr_request("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", + data) self.assertEqual(response.status_code, requests.codes.created) 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) - res = response.json() + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-device-renderer', 'create-ots-oms', + { + 'node-id': 'ROADM-A1', + 'logical-connection-point': 'DEG1-TTP-TXRX' + }) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADM-A1', - res["output"]["result"]) + response["output"]["result"]) 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) - res = response.json() + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-device-renderer', 'create-ots-oms', + { + 'node-id': 'ROADM-B1', + 'logical-connection-point': 'DEG1-TTP-TXRX' + }) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADM-B1', - res["output"]["result"]) + response["output"]["result"]) 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) - res = response.json() + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-device-renderer', 'create-ots-oms', + { + 'node-id': 'ROADM-B1', + 'logical-connection-point': 'DEG2-TTP-TXRX' + }) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADM-B1', - res["output"]["result"]) + response["output"]["result"]) 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) - res = response.json() + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-device-renderer', 'create-ots-oms', + { + 'node-id': 'ROADM-C1', + 'logical-connection-point': 'DEG2-TTP-TXRX' + }) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADM-C1', - res["output"]["result"]) + response["output"]["result"]) def test_023_calculate_span_loss_base_all(self): - url = "{}/operations/transportpce-olm:calculate-spanloss-base" - data = { - "input": { - "src-type": "all" - } - } - response = test_utils.post_request(url, data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertIn('Success', - res["output"]["result"]) + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'transportpce-olm', 'calculate-spanloss-base', + { + 'src-type': 'all' + }) + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertIn('Success', response["output"]["result"]) self.assertIn({ "spanloss": "25.7", "link-id": "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX" - }, res["output"]["spans"]) + }, response["output"]["spans"]) self.assertIn({ "spanloss": "17.6", "link-id": "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX" - }, res["output"]["spans"]) + }, response["output"]["spans"]) self.assertIn({ "spanloss": "23.6", "link-id": "ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX" - }, res["output"]["spans"]) + }, response["output"]["spans"]) self.assertIn({ "spanloss": "23.6", "link-id": "ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX" - }, res["output"]["spans"]) + }, response["output"]["spans"]) self.assertIn({ "spanloss": "25.7", "link-id": "ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX" - }, res["output"]["spans"]) + }, response["output"]["spans"]) self.assertIn({ "spanloss": "17.6", "link-id": "ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX" - }, res["output"]["spans"]) + }, response["output"]["spans"]) time.sleep(5) 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() - nbNode = len(res['network'][0]['node']) - self.assertEqual(nbNode, 9, 'There should be 9 nodes') - self.assertNotIn('ietf-network-topology:link', res['network'][0], + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['network'][0]['node']), 9, 'There should be 9 nodes') + self.assertNotIn('ietf-network-topology:link', response['network'][0], 'otn-topology should have no link') # test service-create for OCH-OTU4 service from spdrA to spdrB 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() + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) 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) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service-OCH-OTU4-AB') - self.assertEqual( - res['services'][0]['connection-type'], 'infrastructure') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-OCH-OTU4-AB") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service-OCH-OTU4-AB') + self.assertEqual(response['services'][0]['connection-type'], 'infrastructure') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') + time.sleep(1) def test_027_check_otn_topo_otu4_links(self): - response = test_utils.get_otn_topo_request() - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - nb_links = len(res['network'][0]['ietf-network-topology:link']) - self.assertEqual(nb_links, 2) + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 2) listLinkId = ['OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK1', 'OTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1'] - for link in res['network'][0]['ietf-network-topology:link']: + for link in response['network'][0]['ietf-network-topology:link']: self.assertIn(link['link-id'], listLinkId) self.assertEqual( link['transportpce-networkutils:otn-link-type'], 'OTU4') @@ -436,54 +444,45 @@ class TransportPCEtesting(unittest.TestCase): # test service-create for OCH-OTU4 service from spdrB to spdrC def test_028_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" - self.cr_serv_sample_data["input"]["service-a-end"]["clli"] = "NodeSB" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2" - self.cr_serv_sample_data["input"]["service-z-end"]["node-id"] = "SPDR-SC1" - self.cr_serv_sample_data["input"]["service-z-end"]["clli"] = "NodeSC" - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1" - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" - - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service-OCH-OTU4-BC" + self.cr_serv_input_data["service-a-end"]["node-id"] = "SPDR-SB1" + self.cr_serv_input_data["service-a-end"]["clli"] = "NodeSB" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2" + self.cr_serv_input_data["service-z-end"]["node-id"] = "SPDR-SC1" + self.cr_serv_input_data["service-z-end"]["clli"] = "NodeSC" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_029_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) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service-OCH-OTU4-BC') - self.assertEqual( - res['services'][0]['connection-type'], 'infrastructure') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-OCH-OTU4-BC") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service-OCH-OTU4-BC') + self.assertEqual(response['services'][0]['connection-type'], 'infrastructure') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') + time.sleep(1) def test_030_check_otn_topo_otu4_links(self): - response = test_utils.get_otn_topo_request() - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - nb_links = len(res['network'][0]['ietf-network-topology:link']) - self.assertEqual(nb_links, 4) + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 4) listLinkId = ['OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK1', 'OTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1', 'OTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK2toSPDR-SC1-XPDR1-XPDR1-NETWORK1', 'OTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK2'] - for link in res['network'][0]['ietf-network-topology:link']: + for link in response['network'][0]['ietf-network-topology:link']: self.assertIn(link['link-id'], listLinkId) self.assertEqual( link['transportpce-networkutils:otn-link-type'], 'OTU4') @@ -496,62 +495,56 @@ class TransportPCEtesting(unittest.TestCase): self.assertIn( link['org-openroadm-common-network:opposite-link'], listLinkId) + # test service-create for ODU4 service from spdrA to spdrC via spdrB + def test_031_create_ODU4_service(self): - # pylint: disable=line-too-long - self.cr_serv_sample_data["input"]["service-name"] = "service-ODU4-ABC" - self.cr_serv_sample_data["input"]["service-a-end"]["node-id"] = "SPDR-SA1" - self.cr_serv_sample_data["input"]["service-a-end"]["clli"] = "NodeSA" - self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "ODU" - del self.cr_serv_sample_data["input"]["service-a-end"]["otu-service-rate"] - self.cr_serv_sample_data["input"]["service-a-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" - self.cr_serv_sample_data["input"]["service-z-end"]["node-id"] = "SPDR-SC1" - self.cr_serv_sample_data["input"]["service-z-end"]["clli"] = "NodeSC" - self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "ODU" - del self.cr_serv_sample_data["input"]["service-z-end"]["otu-service-rate"] - self.cr_serv_sample_data["input"]["service-z-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4" - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1" - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" - - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service-ODU4-ABC" + self.cr_serv_input_data["service-a-end"]["node-id"] = "SPDR-SA1" + self.cr_serv_input_data["service-a-end"]["clli"] = "NodeSA" + self.cr_serv_input_data["service-a-end"]["service-format"] = "ODU" + del self.cr_serv_input_data["service-a-end"]["otu-service-rate"] + self.cr_serv_input_data["service-a-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" + self.cr_serv_input_data["service-z-end"]["node-id"] = "SPDR-SC1" + self.cr_serv_input_data["service-z-end"]["clli"] = "NodeSC" + self.cr_serv_input_data["service-z-end"]["service-format"] = "ODU" + del self.cr_serv_input_data["service-z-end"]["otu-service-rate"] + self.cr_serv_input_data["service-z-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" + + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_032_get_ODU4_service_ABC(self): - response = test_utils.get_service_list_request( - "services/service-ODU4-ABC") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service-ODU4-ABC') - self.assertEqual( - res['services'][0]['connection-type'], 'infrastructure') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-ODU4-ABC") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service-ODU4-ABC') + self.assertEqual(response['services'][0]['connection-type'], 'infrastructure') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') + time.sleep(1) def test_033_check_interface_ODU4_spdra(self): - response = test_utils.check_netconf_node_request( - "SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP1-CFP0', 'type': 'org-openroadm-interfaces:otnOdu', 'supporting-port': 'CP1-CFP0-P1'} - # SAPI/DAPI are added in the Otu4 renderer input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP', 'rate': 'org-openroadm-otn-common-types:ODU4', 'expected-dapi': 'H/OelLynehI=', @@ -559,64 +552,59 @@ class TransportPCEtesting(unittest.TestCase): 'tx-dapi': 'AMf1n5hK6Xkk', 'tx-sapi': 'H/OelLynehI='} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], **input_dict_2), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] - ) + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) 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/XPDR1-NETWORK1-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']) + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu']) + + response2 = test_utils_rfc8040.check_node_attribute2_request( + 'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-ODU4', 'org-openroadm-otn-odu-interfaces:odu') + self.assertEqual(response2['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-odu-interfaces:odu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-odu-interfaces:odu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-odu-interfaces:odu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-odu-interfaces:odu']['expected-dapi']) def test_034_check_interface_ODU4_spdrc(self): - response = test_utils.check_netconf_node_request( - "SPDR-SC1", "interface/XPDR1-NETWORK1-ODU4") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP1-CFP0', 'type': 'org-openroadm-interfaces:otnOdu', 'supporting-port': 'CP1-CFP0-P1'} - # SAPI/DAPI are added in the Otu4 renderer input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP', 'rate': 'org-openroadm-otn-common-types:ODU4', 'expected-dapi': 'AMf1n5hK6Xkk', 'expected-sapi': 'H/OelLynehI=', 'tx-dapi': 'H/OelLynehI=', 'tx-sapi': 'AMf1n5hK6Xkk'} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], **input_dict_2), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] - ) + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) 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/XPDR1-NETWORK1-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']) + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu']) + + response2 = test_utils_rfc8040.check_node_attribute2_request( + 'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU4', 'org-openroadm-otn-odu-interfaces:odu') + self.assertEqual(response2['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-odu-interfaces:odu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-odu-interfaces:odu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-odu-interfaces:odu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-odu-interfaces:odu']['expected-dapi']) def test_035_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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP5-CFP', @@ -626,20 +614,18 @@ class TransportPCEtesting(unittest.TestCase): 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP', 'rate': 'org-openroadm-otn-common-types:ODU4', 'monitoring-mode': 'monitored'} - - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) self.assertDictEqual(dict(input_dict_2, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) + **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) self.assertNotIn('opu', - dict.keys(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])) + dict.keys(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])) def test_036_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) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP6-CFP', @@ -650,40 +636,35 @@ class TransportPCEtesting(unittest.TestCase): 'rate': 'org-openroadm-otn-common-types:ODU4', 'monitoring-mode': 'monitored'} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) self.assertDictEqual(dict(input_dict_2, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) + **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) self.assertNotIn('opu', - dict.keys(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])) + dict.keys(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])) def test_037_check_ODU4_connection_spdrb(self): - response = test_utils.check_netconf_node_request( - "SPDR-SB1", - "odu-connection/XPDR2-NETWORK1-ODU4-x-XPDR2-NETWORK2-ODU4") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'odu-connection', 'XPDR2-NETWORK1-ODU4-x-XPDR2-NETWORK2-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = { - 'connection-name': - 'XPDR2-NETWORK1-ODU4-x-XPDR2-NETWORK2-ODU4', + 'connection-name': 'XPDR2-NETWORK1-ODU4-x-XPDR2-NETWORK2-ODU4', 'direction': 'bidirectional' } - self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]), - res['odu-connection'][0]) + self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]), + response['odu-connection'][0]) self.assertDictEqual({'dst-if': 'XPDR2-NETWORK2-ODU4'}, - res['odu-connection'][0]['destination']) + response['odu-connection'][0]['destination']) self.assertDictEqual({'src-if': 'XPDR2-NETWORK1-ODU4'}, - res['odu-connection'][0]['source']) + response['odu-connection'][0]['source']) def test_038_check_otn_topo_links(self): - response = test_utils.get_otn_topo_request() - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - nb_links = len(res['network'][0]['ietf-network-topology:link']) - self.assertEqual(nb_links, 6) - for link in res['network'][0]['ietf-network-topology:link']: + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 6) + for link in response['network'][0]['ietf-network-topology:link']: if 'OTU4' in link['link-id']: self.assertEqual( link['org-openroadm-otn-network-topology:available-bandwidth'], 0) @@ -705,9 +686,9 @@ class TransportPCEtesting(unittest.TestCase): self.fail("this link should not exist") def test_039_check_otn_topo_tp(self): - response = test_utils.get_otn_topo_request() - res = response.json() - for node in res['network'][0]['node']: + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + for node in response['network'][0]['node']: if node['node-id'] == 'SPDR-SA1-XPDR1' or node['node-id'] == 'SPDR-SC1-XPDR1': tpList = node['ietf-network-topology:termination-point'] for tp in tpList: @@ -719,64 +700,57 @@ class TransportPCEtesting(unittest.TestCase): self.assertEqual(xpdrTpPortConAt['odtu-tpn-pool'][0]['odtu-type'], 'org-openroadm-otn-common-types:ODTU4.ts-Allocated') + # test service-create for 10GE service from spdr to spdr + def test_040_create_10GE_service(self): - self.cr_serv_sample_data["input"]["service-name"] = "service1-10GE" - self.cr_serv_sample_data["input"]["connection-type"] = "service" - self.cr_serv_sample_data["input"]["service-a-end"]["service-rate"] = "10" - self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "Ethernet" - del self.cr_serv_sample_data["input"]["service-a-end"]["odu-service-rate"] - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" - self.cr_serv_sample_data["input"]["service-z-end"]["service-rate"] = "10" - self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "Ethernet" - del self.cr_serv_sample_data["input"]["service-z-end"]["odu-service-rate"] - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service1-10GE" + self.cr_serv_input_data["connection-type"] = "service" + self.cr_serv_input_data["service-a-end"]["service-rate"] = "10" + self.cr_serv_input_data["service-a-end"]["service-format"] = "Ethernet" + del self.cr_serv_input_data["service-a-end"]["odu-service-rate"] + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" + self.cr_serv_input_data["service-z-end"]["service-rate"] = "10" + self.cr_serv_input_data["service-z-end"]["service-format"] = "Ethernet" + del self.cr_serv_input_data["service-z-end"]["odu-service-rate"] + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_041_get_10GE_service1(self): - response = test_utils.get_service_list_request( - "services/service1-10GE") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service1-10GE') - self.assertEqual( - res['services'][0]['connection-type'], 'service') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1-10GE") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service1-10GE') + self.assertEqual(response['services'][0]['connection-type'], 'service') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') + time.sleep(1) def test_042_check_interface_10GE_CLIENT_spdra(self): - response = test_utils.check_netconf_node_request( - "SPDR-SA1", "interface/XPDR1-CLIENT1-ETHERNET10G") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR1-CLIENT1-ETHERNET10G') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP1-SFP4', 'type': 'org-openroadm-interfaces:ethernetCsmacd', 'supporting-port': 'CP1-SFP4-P1' } - self.assertDictEqual(dict(input_dict, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual( - {'speed': 10000}, - res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']) + self.assertDictEqual(dict(input_dict, **response['interface'][0]), + response['interface'][0]) + self.assertEqual(10000, response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed']) def test_043_check_interface_ODU2E_CLIENT_spdra(self): - response = test_utils.check_netconf_node_request( - "SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR1-CLIENT1-ODU2e') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP1-SFP4', @@ -792,28 +766,32 @@ class TransportPCEtesting(unittest.TestCase): 'tx-dapi': 'BcwI5xz79t8=', 'tx-sapi': 'B68VWipZAU0='} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(input_dict_2, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + **input_dict_2), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + ) self.assertDictEqual( {'payload-type': '03', 'exp-payload-type': '03'}, - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu']) - response2 = test_utils.check_netconf_node_request( - "SPDR-SC1", "interface/XPDR1-CLIENT1-ODU2e") - 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']) + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu']) + + response2 = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR1-CLIENT1-ODU2e') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-dapi']) def test_044_check_interface_ODU2E_NETWORK_spdra(self): - response = test_utils.check_netconf_node_request( - "SPDR-SA1", "interface/XPDR1-NETWORK1-ODU2e") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU2e') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP1-CFP0', @@ -826,59 +804,53 @@ class TransportPCEtesting(unittest.TestCase): 'monitoring-mode': 'monitored'} input_dict_3 = {'trib-port-number': 1} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(input_dict_2, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + **input_dict_2), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + ) self.assertDictEqual(dict(input_dict_3, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][ - 'parent-odu-allocation']), - 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'] + **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + ['parent-odu-allocation']), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']) + self.assertIn(1, response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'] ['trib-slots']) def test_045_check_ODU2E_connection_spdra(self): - response = test_utils.check_netconf_node_request( - "SPDR-SA1", - "odu-connection/XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'odu-connection', 'XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = { 'connection-name': 'XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e', 'direction': 'bidirectional' } - - self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]), - res['odu-connection'][0]) + self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]), + response['odu-connection'][0]) self.assertDictEqual({'dst-if': 'XPDR1-NETWORK1-ODU2e'}, - res['odu-connection'][0]['destination']) + response['odu-connection'][0]['destination']) self.assertDictEqual({'src-if': 'XPDR1-CLIENT1-ODU2e'}, - res['odu-connection'][0]['source']) + response['odu-connection'][0]['source']) def test_046_check_interface_10GE_CLIENT_spdrc(self): - response = test_utils.check_netconf_node_request( - "SPDR-SC1", "interface/XPDR1-CLIENT1-ETHERNET10G") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR1-CLIENT1-ETHERNET10G') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP1-SFP4', 'type': 'org-openroadm-interfaces:ethernetCsmacd', 'supporting-port': 'CP1-SFP4-P1' } - self.assertDictEqual(dict(input_dict, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual( - {'speed': 10000}, - res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']) + self.assertDictEqual(dict(input_dict, **response['interface'][0]), + response['interface'][0]) + self.assertEqual(10000, response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed']) def test_047_check_interface_ODU2E_CLIENT_spdrc(self): - response = test_utils.check_netconf_node_request( - "SPDR-SC1", "interface/XPDR1-CLIENT1-ODU2e") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR1-CLIENT1-ODU2e') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP1-SFP4', @@ -894,28 +866,32 @@ class TransportPCEtesting(unittest.TestCase): 'tx-dapi': 'B68VWipZAU0=', 'tx-sapi': 'BcwI5xz79t8='} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(input_dict_2, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + **input_dict_2), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + ) self.assertDictEqual( {'payload-type': '03', 'exp-payload-type': '03'}, - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu']) - response2 = test_utils.check_netconf_node_request( - "SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e") - 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']) + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu']) + + response2 = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR1-CLIENT1-ODU2e') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-dapi']) def test_048_check_interface_ODU2E_NETWORK_spdrc(self): - response = test_utils.check_netconf_node_request( - "SPDR-SC1", "interface/XPDR1-NETWORK1-ODU2e") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-ODU2e') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP1-CFP0', @@ -928,47 +904,40 @@ class TransportPCEtesting(unittest.TestCase): 'monitoring-mode': 'monitored'} input_dict_3 = {'trib-port-number': 1} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(input_dict_2, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + **input_dict_2), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + ) self.assertDictEqual(dict(input_dict_3, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][ - 'parent-odu-allocation']), - 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']) + **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + ['parent-odu-allocation']), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']) + self.assertIn(1, response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'] + ['trib-slots']) def test_049_check_ODU2E_connection_spdrc(self): - response = test_utils.check_netconf_node_request( - "SPDR-SC1", - "odu-connection/XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'odu-connection', 'XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = { 'connection-name': 'XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e', 'direction': 'bidirectional' } - - self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]), - res['odu-connection'][0]) + self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]), + response['odu-connection'][0]) self.assertDictEqual({'dst-if': 'XPDR1-NETWORK1-ODU2e'}, - res['odu-connection'][0]['destination']) + response['odu-connection'][0]['destination']) self.assertDictEqual({'src-if': 'XPDR1-CLIENT1-ODU2e'}, - res['odu-connection'][0]['source']) + response['odu-connection'][0]['source']) def test_050_check_otn_topo_links(self): - response = test_utils.get_otn_topo_request() - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - nb_links = len(res['network'][0]['ietf-network-topology:link']) - self.assertEqual(nb_links, 6) - for link in res['network'][0]['ietf-network-topology:link']: + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 6) + for link in response['network'][0]['ietf-network-topology:link']: linkId = link['link-id'] if (linkId in ('ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1', 'ODTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1')): @@ -978,9 +947,9 @@ class TransportPCEtesting(unittest.TestCase): link['org-openroadm-otn-network-topology:used-bandwidth'], 10000) def test_051_check_otn_topo_tp(self): - response = test_utils.get_otn_topo_request() - res = response.json() - for node in res['network'][0]['node']: + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + for node in response['network'][0]['node']: if node['node-id'] == 'SPDR-SA1-XPDR1' or node['node-id'] == 'SPDR-SC1-XPDR1': tpList = node['ietf-network-topology:termination-point'] for tp in tpList: @@ -996,49 +965,47 @@ class TransportPCEtesting(unittest.TestCase): 1, xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']) def test_052_delete_10GE_service(self): - response = test_utils.service_delete_request("service1-10GE") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1-10GE" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_053_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']), 3) - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_request() + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['service-list']['services']), 3) + time.sleep(1) def test_054_check_no_ODU2e_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']) + response = test_utils_rfc8040.check_node_request("SPDR-SA1") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertNotIn(['odu-connection'][0], response['org-openroadm-device']) time.sleep(1) def test_055_check_no_interface_ODU2E_NETWORK_spdra(self): - response = test_utils.check_netconf_node_request( - "SPDR-SA1", "interface/XPDR1-NETWORK1-ODU2e") - self.assertEqual(response.status_code, requests.codes.conflict) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU2e') + self.assertEqual(response['status_code'], requests.codes.conflict) def test_056_check_no_interface_ODU2E_CLIENT_spdra(self): - response = test_utils.check_netconf_node_request( - "SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e") - self.assertEqual(response.status_code, requests.codes.conflict) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR1-CLIENT1-ODU2e') + self.assertEqual(response['status_code'], requests.codes.conflict) def test_057_check_no_interface_10GE_CLIENT_spdra(self): - response = test_utils.check_netconf_node_request( - "SPDR-SA1", "interface/XPDR1-CLIENT1-ETHERNET10G") - self.assertEqual(response.status_code, requests.codes.conflict) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR1-CLIENT1-ETHERNET10G') + self.assertEqual(response['status_code'], requests.codes.conflict) def test_058_check_otn_topo_links(self): - response = test_utils.get_otn_topo_request() - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - nb_links = len(res['network'][0]['ietf-network-topology:link']) - self.assertEqual(nb_links, 6) - for link in res['network'][0]['ietf-network-topology:link']: + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 6) + for link in response['network'][0]['ietf-network-topology:link']: linkId = link['link-id'] if (linkId in ('ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1', 'ODTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1')): @@ -1048,9 +1015,9 @@ class TransportPCEtesting(unittest.TestCase): link['org-openroadm-otn-network-topology:used-bandwidth'], 0) def test_059_check_otn_topo_tp(self): - response = test_utils.get_otn_topo_request() - res = response.json() - for node in res['network'][0]['node']: + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + for node in response['network'][0]['node']: if (node['node-id'] == 'SPDR-SA1-XPDR1' or node['node-id'] == 'SPDR-SC1-XPDR1'): tpList = node['ietf-network-topology:termination-point'] for tp in tpList: @@ -1061,52 +1028,52 @@ class TransportPCEtesting(unittest.TestCase): len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 80) def test_060_delete_ODU4_service(self): - response = test_utils.service_delete_request("service-ODU4-ABC") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-ODU4-ABC" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_061_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) + response = test_utils_rfc8040.get_ordm_serv_list_request() + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['service-list']['services']), 2) + time.sleep(1) def test_062_check_no_interface_ODU4_spdra(self): - response = test_utils.check_netconf_node_request( - "SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4") - self.assertEqual(response.status_code, requests.codes.conflict) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.conflict) def test_063_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) - response = test_utils.check_netconf_node_request( - "SPDR-SB1", "interface/XPDR2-NETWORK2-ODU4") - self.assertEqual(response.status_code, requests.codes.conflict) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.conflict) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-ODU4') + self.assertEqual(response['status_code'], requests.codes.conflict) def test_064_check_no_ODU4_connection_spdrb(self): - response = test_utils.check_netconf_node_request("SPDR-SB1", "") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertNotIn(['odu-connection'][0], res['org-openroadm-device']) + response = test_utils_rfc8040.check_node_request("SPDR-SB1") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertNotIn(['odu-connection'][0], response['org-openroadm-device']) time.sleep(1) def test_065_check_no_interface_ODU4_spdrc(self): - response = test_utils.check_netconf_node_request( - "SPDR-SC1", "interface/XPDR1-NETWORK1-ODU4") - self.assertEqual(response.status_code, requests.codes.conflict) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.conflict) def test_066_check_otn_topo_links(self): self.test_030_check_otn_topo_otu4_links() def test_067_check_otn_topo_tp(self): - response = test_utils.get_otn_topo_request() - res = response.json() - for node in res['network'][0]['node']: + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + for node in response['network'][0]['node']: if node['node-id'] == 'SPDR-SA1-XPDR1' or node['node-id'] == 'SPDR-SC1-XPDR1': tpList = node['ietf-network-topology:termination-point'] for tp in tpList: @@ -1118,53 +1085,46 @@ class TransportPCEtesting(unittest.TestCase): # test service-create for ODU4 service from spdrA to spdrB def test_068_create_ODU4_service_AB(self): - # pylint: disable=line-too-long - self.cr_serv_sample_data["input"]["service-name"] = "service-ODU4-AB" - self.cr_serv_sample_data["input"]["connection-type"] = "infrastructure" - self.cr_serv_sample_data["input"]["service-a-end"]["service-rate"] = "100" - self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "ODU" - self.cr_serv_sample_data["input"]["service-a-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" - self.cr_serv_sample_data["input"]["service-z-end"]["node-id"] = "SPDR-SB1" - self.cr_serv_sample_data["input"]["service-z-end"]["clli"] = "NodeSB" - self.cr_serv_sample_data["input"]["service-a-end"]["service-rate"] = "100" - self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "ODU" - self.cr_serv_sample_data["input"]["service-z-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4" - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" - - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service-ODU4-AB" + self.cr_serv_input_data["connection-type"] = "infrastructure" + self.cr_serv_input_data["service-a-end"]["service-rate"] = "100" + self.cr_serv_input_data["service-a-end"]["service-format"] = "ODU" + self.cr_serv_input_data["service-a-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" + self.cr_serv_input_data["service-z-end"]["node-id"] = "SPDR-SB1" + self.cr_serv_input_data["service-z-end"]["clli"] = "NodeSB" + self.cr_serv_input_data["service-a-end"]["service-rate"] = "100" + self.cr_serv_input_data["service-z-end"]["service-format"] = "ODU" + self.cr_serv_input_data["service-z-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1" + + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_069_get_ODU4_service_AB(self): - response = test_utils.get_service_list_request( - "services/service-ODU4-AB") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service-ODU4-AB') - self.assertEqual( - res['services'][0]['connection-type'], 'infrastructure') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-ODU4-AB") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service-ODU4-AB') + self.assertEqual(response['services'][0]['connection-type'], 'infrastructure') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') + time.sleep(1) def test_070_check_interface_ODU4_spdra(self): - response = test_utils.check_netconf_node_request( - "SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP1-CFP0', @@ -1178,29 +1138,32 @@ class TransportPCEtesting(unittest.TestCase): 'tx-dapi': 'X+8cRNi+HbE=', 'tx-sapi': 'H/OelLynehI='} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], **input_dict_2), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] ) 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-SB1", "interface/XPDR2-NETWORK1-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']) + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu']) + + response2 = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-dapi']) def test_071_check_interface_ODU4_spdrb_N1(self): - response = test_utils.check_netconf_node_request( - "SPDR-SB1", "interface/XPDR2-NETWORK1-ODU4") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP1-CFP0', @@ -1214,66 +1177,66 @@ class TransportPCEtesting(unittest.TestCase): 'tx-dapi': 'H/OelLynehI=', 'tx-sapi': 'X+8cRNi+HbE='} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], **input_dict_2), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] ) 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/XPDR1-NETWORK1-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']) + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu']) + response2 = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-dapi']) # test service-create for ODU4 service from spdrB to spdrC def test_072_create_ODU4_service_BC(self): - # pylint: disable=line-too-long - self.cr_serv_sample_data["input"]["service-name"] = "service-ODU4-BC" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2" - self.cr_serv_sample_data["input"]["service-z-end"]["node-id"] = "SPDR-SC1" - self.cr_serv_sample_data["input"]["service-z-end"]["clli"] = "NodeSC" - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1" - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" - - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service-ODU4-BC" + self.cr_serv_input_data["service-a-end"]["node-id"] = "SPDR-SB1" + self.cr_serv_input_data["service-a-end"]["clli"] = "NodeSB" + self.cr_serv_input_data["service-a-end"]["service-format"] = "ODU" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2" + self.cr_serv_input_data["service-z-end"]["node-id"] = "SPDR-SC1" + self.cr_serv_input_data["service-z-end"]["clli"] = "NodeSC" + self.cr_serv_input_data["service-a-end"]["service-format"] = "ODU" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1" + + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_073_get_ODU4_service_AB(self): - response = test_utils.get_service_list_request( - "services/service-ODU4-BC") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertEqual( - res['services'][0]['administrative-state'], 'inService') - self.assertEqual( - res['services'][0]['service-name'], 'service-ODU4-BC') - self.assertEqual( - res['services'][0]['connection-type'], 'infrastructure') - self.assertEqual( - res['services'][0]['lifecycle-state'], 'planned') - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-ODU4-BC") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(response['services'][0]['administrative-state'], 'inService') + self.assertEqual(response['services'][0]['service-name'], 'service-ODU4-BC') + self.assertEqual(response['services'][0]['connection-type'], 'infrastructure') + self.assertEqual(response['services'][0]['lifecycle-state'], 'planned') + time.sleep(1) def test_074_check_interface_ODU4_spdrb_N2(self): - response = test_utils.check_netconf_node_request( - "SPDR-SB1", "interface/XPDR2-NETWORK2-ODU4") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP1-CFP0', @@ -1287,29 +1250,31 @@ class TransportPCEtesting(unittest.TestCase): 'tx-dapi': 'AMf1n5hK6Xkk', 'tx-sapi': 'X+8cRNi+HbI='} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], **input_dict_2), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] ) 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/XPDR1-NETWORK1-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']) + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu']) + response2 = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-dapi']) def test_075_check_interface_ODU4_spdrc(self): - response = test_utils.check_netconf_node_request( - "SPDR-SC1", "interface/XPDR1-NETWORK1-ODU4") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP1-CFP0', @@ -1322,48 +1287,57 @@ class TransportPCEtesting(unittest.TestCase): 'expected-sapi': 'X+8cRNi+HbI=', 'tx-dapi': 'X+8cRNi+HbI=', 'tx-sapi': 'AMf1n5hK6Xkk'} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) - self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) + self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'], **input_dict_2), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'] ) 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-SB1", "interface/XPDR2-NETWORK2-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']) + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu']) + response2 = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-ODU4') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-dapi']) + self.assertEqual(input_dict_2['tx-sapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-sapi']) + self.assertEqual(input_dict_2['tx-dapi'], + response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-dapi']) + # test service-create for 10GE service from spdr to spdr + def test_076_create_10GE_service_ABC(self): - # pylint: disable=line-too-long - self.cr_serv_sample_data["input"]["service-name"] = "service1-10GE" - self.cr_serv_sample_data["input"]["connection-type"] = "service" - self.cr_serv_sample_data["input"]["service-a-end"]["node-id"] = "SPDR-SA1" - self.cr_serv_sample_data["input"]["service-a-end"]["clli"] = "NodeSA" - self.cr_serv_sample_data["input"]["service-a-end"]["service-rate"] = "10" - self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "Ethernet" - del self.cr_serv_sample_data["input"]["service-a-end"]["odu-service-rate"] - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1" - self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1" - self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" - self.cr_serv_sample_data["input"]["service-z-end"]["service-rate"] = "10" - self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "Ethernet" - del self.cr_serv_sample_data["input"]["service-z-end"]["odu-service-rate"] - self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" - self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" - response = test_utils.service_create_request(self.cr_serv_sample_data) - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.cr_serv_input_data["service-name"] = "service1-10GE" + self.cr_serv_input_data["connection-type"] = "service" + self.cr_serv_input_data["service-a-end"]["node-id"] = "SPDR-SA1" + self.cr_serv_input_data["service-a-end"]["clli"] = "NodeSA" + self.cr_serv_input_data["service-a-end"]["service-rate"] = "10" + self.cr_serv_input_data["service-a-end"]["service-format"] = "Ethernet" + del self.cr_serv_input_data["service-a-end"]["odu-service-rate"] + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1" + self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1" + self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" + self.cr_serv_input_data["service-z-end"]["node-id"] = "SPDR-SC1" + self.cr_serv_input_data["service-z-end"]["clli"] = "NodeSC" + self.cr_serv_input_data["service-z-end"]["service-rate"] = "10" + self.cr_serv_input_data["service-z-end"]["service-format"] = "Ethernet" + del self.cr_serv_input_data["service-z-end"]["odu-service-rate"] + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1" + self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1" + self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-create', + self.cr_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('PCE calculation in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_077_check_configuration_spdra_spdrc(self): @@ -1377,10 +1351,9 @@ class TransportPCEtesting(unittest.TestCase): self.test_049_check_ODU2E_connection_spdrc() def test_078_check_interface_ODU2E_NETWORK1_spdrb(self): - response = test_utils.check_netconf_node_request( - "SPDR-SB1", "interface/XPDR2-NETWORK1-ODU2e") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU2e') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU2e', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP1-CFP0', @@ -1393,23 +1366,22 @@ class TransportPCEtesting(unittest.TestCase): 'monitoring-mode': 'monitored'} input_dict_3 = {'trib-port-number': 1} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) self.assertDictEqual(dict(input_dict_2, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) + **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) self.assertDictEqual(dict(input_dict_3, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][ + **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][ 'parent-odu-allocation']), - 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'] + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']) + self.assertIn(1, response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'] ['trib-slots']) def test_079_check_interface_ODU2E_NETWORK2_spdrb(self): - response = test_utils.check_netconf_node_request( - "SPDR-SB1", "interface/XPDR2-NETWORK2-ODU2e") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-ODU2e') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = {'name': 'XPDR2-NETWORK2-ODU2e', 'administrative-state': 'inService', 'supporting-circuit-pack-name': 'CP1-CFP0', @@ -1422,44 +1394,40 @@ class TransportPCEtesting(unittest.TestCase): 'monitoring-mode': 'monitored'} input_dict_3 = {'trib-port-number': 1} - self.assertDictEqual(dict(input_dict_1, **res['interface'][0]), - res['interface'][0]) + self.assertDictEqual(dict(input_dict_1, **response['interface'][0]), + response['interface'][0]) self.assertDictEqual(dict(input_dict_2, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), - res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) + **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']), + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']) self.assertDictEqual(dict(input_dict_3, - **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][ + **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][ 'parent-odu-allocation']), - 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'] + response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']) + self.assertIn(1, response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'] ['trib-slots']) def test_080_check_ODU2E_connection_spdrb(self): - response = test_utils.check_netconf_node_request( - "SPDR-SB1", - "odu-connection/XPDR2-NETWORK1-ODU2e-x-XPDR2-NETWORK2-ODU2e") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'odu-connection', 'XPDR2-NETWORK1-ODU2e-x-XPDR2-NETWORK2-ODU2e') + self.assertEqual(response['status_code'], requests.codes.ok) input_dict_1 = { 'connection-name': 'XPDR2-NETWORK1-ODU2e-x-XPDR2-NETWORK2-ODU2e', 'direction': 'bidirectional' } - self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]), - res['odu-connection'][0]) + self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]), + response['odu-connection'][0]) self.assertDictEqual({'dst-if': 'XPDR2-NETWORK2-ODU2e'}, - res['odu-connection'][0]['destination']) + response['odu-connection'][0]['destination']) self.assertDictEqual({'src-if': 'XPDR2-NETWORK1-ODU2e'}, - res['odu-connection'][0]['source']) + response['odu-connection'][0]['source']) def test_081_check_otn_topo_links(self): - response = test_utils.get_otn_topo_request() - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - nb_links = len(res['network'][0]['ietf-network-topology:link']) - self.assertEqual(nb_links, 8) - for link in res['network'][0]['ietf-network-topology:link']: + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 8) + for link in response['network'][0]['ietf-network-topology:link']: linkId = link['link-id'] if (linkId in ('ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK1', 'ODTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1', @@ -1474,19 +1442,20 @@ class TransportPCEtesting(unittest.TestCase): self.test_051_check_otn_topo_tp() def test_083_delete_10GE_service(self): - response = test_utils.service_delete_request("service1-10GE") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1-10GE" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_084_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']), 4) - time.sleep(2) + response = test_utils_rfc8040.get_ordm_serv_list_request() + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['service-list']['services']), 4) + time.sleep(1) def test_085_check_configuration_spdra(self): self.test_054_check_no_ODU2e_connection_spdra() @@ -1495,29 +1464,26 @@ class TransportPCEtesting(unittest.TestCase): self.test_057_check_no_interface_10GE_CLIENT_spdra() def test_086_check_no_ODU2e_connection_spdrb(self): - response = test_utils.check_netconf_node_request("SPDR-SB1", "") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - self.assertNotIn(['odu-connection'][0], res['org-openroadm-device']) + response = test_utils_rfc8040.check_node_request("SPDR-SB1") + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertNotIn(['odu-connection'][0], response['org-openroadm-device']) time.sleep(1) def test_087_check_no_interface_ODU2E_NETWORK1_spdrb(self): - response = test_utils.check_netconf_node_request( - "SPDR-SB1", "interface/XPDR2-NETWORK1-ODU2e") - self.assertEqual(response.status_code, requests.codes.conflict) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU2e') + self.assertEqual(response['status_code'], requests.codes.conflict) def test_088_check_no_interface_ODU2E_NETWORK2_spdrb(self): - response = test_utils.check_netconf_node_request( - "SPDR-SB1", "interface/XPDR2-NETWORK2-ODU2e") - self.assertEqual(response.status_code, requests.codes.conflict) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-ODU2e') + self.assertEqual(response['status_code'], requests.codes.conflict) def test_089_check_otn_topo_links(self): - response = test_utils.get_otn_topo_request() - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - nb_links = len(res['network'][0]['ietf-network-topology:link']) - self.assertEqual(nb_links, 8) - for link in res['network'][0]['ietf-network-topology:link']: + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 8) + for link in response['network'][0]['ietf-network-topology:link']: linkId = link['link-id'] if (linkId in ('ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK1', 'ODTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1', @@ -1532,19 +1498,23 @@ class TransportPCEtesting(unittest.TestCase): self.test_059_check_otn_topo_tp() def test_091_delete_ODU4_service_AB(self): - response = test_utils.service_delete_request("service-ODU4-AB") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-ODU4-AB" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_092_delete_ODU4_service_BC(self): - response = test_utils.service_delete_request("service-ODU4-BC") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-ODU4-BC" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_093_check_global_config(self): @@ -1557,96 +1527,98 @@ class TransportPCEtesting(unittest.TestCase): self.test_067_check_otn_topo_tp() def test_094_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() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-OCH-OTU4-AB" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_095_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() + self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-OCH-OTU4-BC" + response = test_utils_rfc8040.transportpce_api_rpc_request( + 'org-openroadm-service', 'service-delete', + self.del_serv_input_data) + self.assertEqual(response['status_code'], requests.codes.ok) self.assertIn('Renderer service delete in progress', - res['output']['configuration-response-common']['response-message']) + response['output']['configuration-response-common']['response-message']) time.sleep(self.WAITING) def test_096_get_no_service(self): - response = test_utils.get_service_list_request("") - self.assertEqual(response.status_code, requests.codes.conflict) - res = response.json() - self.assertIn( - {"error-type": "application", "error-tag": "data-missing", - "error-message": "Request could not be completed because the relevant data model content does not exist"}, - res['errors']['error']) + response = test_utils_rfc8040.get_ordm_serv_list_request() + self.assertEqual(response['status_code'], requests.codes.conflict) + self.assertIn(response['service-list'], ( + { + "error-type": "protocol", + "error-tag": "data-missing", + "error-message": + "Request could not be completed because the relevant data " + "model content does not exist" + }, { + "error-type": "application", + "error-tag": "data-missing", + "error-message": + "Request could not be completed because the relevant data " + "model content does not exist" + })) time.sleep(1) def test_097_check_no_interface_OTU4_spdra(self): - response = test_utils.check_netconf_node_request( - "SPDR-SA1", "interface/XPDR1-NETWORK1-OTU") - self.assertEqual(response.status_code, requests.codes.conflict) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-OTU') + self.assertEqual(response['status_code'], requests.codes.conflict) def test_098_check_no_interface_OCH_spdra(self): - response = test_utils.check_netconf_node_request( - "SPDR-SA1", "interface/XPDR1-NETWORK1-1") - self.assertEqual(response.status_code, requests.codes.conflict) + response = test_utils_rfc8040.check_node_attribute_request( + 'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-1') + self.assertEqual(response['status_code'], requests.codes.conflict) def test_099_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]) + response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + self.assertNotIn('ietf-network-topology:link', response['network'][0]) def test_100_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) - res = response.json() - links = res['network'][0]['ietf-network-topology:link'] + response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + links = response['network'][0]['ietf-network-topology:link'] for link in links: - if (link["org-openroadm-common-network:link-type"] == "XPONDER-OUTPUT" or - link["org-openroadm-common-network:link-type"] == "XPONDER-INPUT"): - link_name = link["link-id"] - response = test_utils.delete_request(url+link_name) - self.assertEqual(response.status_code, requests.codes.ok) + if link["org-openroadm-common-network:link-type"] in ('XPONDER-OUTPUT', 'XPONDER-INPUT'): + response = test_utils_rfc8040.del_ietf_network_link_request( + 'openroadm-topology', link['link-id'], 'config') + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) def test_101_check_openroadm_topology(self): - response = test_utils.get_ordm_topo_request("") - self.assertEqual(response.status_code, requests.codes.ok) - res = response.json() - links = res['network'][0]['ietf-network-topology:link'] + response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config') + self.assertEqual(response['status_code'], requests.codes.ok) + links = response['network'][0]['ietf-network-topology:link'] self.assertEqual(28, len(links), 'Topology should contain 28 links') def test_102_disconnect_spdrA(self): - response = test_utils.unmount_device("SPDR-SA1") - self.assertEqual(response.status_code, requests.codes.ok, - test_utils.CODE_SHOULD_BE_200) + response = test_utils_rfc8040.unmount_device("SPDR-SA1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) def test_103_disconnect_spdrC(self): - response = test_utils.unmount_device("SPDR-SC1") - self.assertEqual(response.status_code, requests.codes.ok, - test_utils.CODE_SHOULD_BE_200) + response = test_utils_rfc8040.unmount_device("SPDR-SC1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) def test_104_disconnect_spdrB(self): - response = test_utils.unmount_device("SPDR-SB1") - self.assertEqual(response.status_code, requests.codes.ok, - test_utils.CODE_SHOULD_BE_200) + response = test_utils_rfc8040.unmount_device("SPDR-SB1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) def test_105_disconnect_roadmA(self): - response = test_utils.unmount_device("ROADM-A1") - self.assertEqual(response.status_code, requests.codes.ok, - test_utils.CODE_SHOULD_BE_200) + response = test_utils_rfc8040.unmount_device("ROADM-A1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) def test_106_disconnect_roadmB(self): - response = test_utils.unmount_device("ROADM-B1") - self.assertEqual(response.status_code, requests.codes.ok, - test_utils.CODE_SHOULD_BE_200) + response = test_utils_rfc8040.unmount_device("ROADM-B1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) def test_107_disconnect_roadmC(self): - response = test_utils.unmount_device("ROADM-C1") - self.assertEqual(response.status_code, requests.codes.ok, - test_utils.CODE_SHOULD_BE_200) + response = test_utils_rfc8040.unmount_device("ROADM-C1") + self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content)) if __name__ == "__main__": diff --git a/tests/transportpce_tests/common/test_utils_rfc8040.py b/tests/transportpce_tests/common/test_utils_rfc8040.py index e83a284a2..17ef51d23 100644 --- a/tests/transportpce_tests/common/test_utils_rfc8040.py +++ b/tests/transportpce_tests/common/test_utils_rfc8040.py @@ -108,7 +108,6 @@ def delete_request(url): def post_request(url, data): if data: - print(json.dumps(data)) return requests.request( "POST", url.format(RESTCONF_BASE_URL), data=json.dumps(data), @@ -282,7 +281,7 @@ def mount_device(node: str, sim: str): 'netconf-node-topology:tcp-only': 'false', 'netconf-node-topology:pass-through': {}}]} response = put_request(url[RESTCONF_VERSION].format('{}', node), body) - if wait_until_log_contains(TPCE_LOG, re.escape('Triggering notification stream NETCONF for node ' + node), 180): + if wait_until_log_contains(TPCE_LOG, 'Triggering notification stream NETCONF for node ' + node, 180): print('Node ' + node + ' correctly added to tpce topology', end='... ', flush=True) else: print('Node ' + node + ' still not added to tpce topology', end='... ', flush=True) -- 2.36.6