sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEPortMappingTesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(10)
def test_01_rdm_device_connection(self):
- response = test_utils_rfc8040.mount_device("ROADMA01", ('roadma', self.NODE_VERSION))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("ROADMA01", ('roadma', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_rdm_device_connected(self):
- response = test_utils_rfc8040.check_device_connection("ROADMA01")
+ response = test_utils.check_device_connection("ROADMA01")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['connection-status'], 'connected')
time.sleep(10)
def test_03_rdm_portmapping_info(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADMA01", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("ROADMA01", "node-info", None)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(
{'node-type': 'rdm',
time.sleep(3)
def test_04_rdm_portmapping_DEG1_TTP_TXRX(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADMA01", "mapping", "DEG1-TTP-TXRX")
+ response = test_utils.get_portmapping_node_attr("ROADMA01", "mapping", "DEG1-TTP-TXRX")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': 'L1', 'supporting-circuit-pack-name': '2/0',
response['mapping'])
def test_05_rdm_portmapping_SRG1_PP7_TXRX(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADMA01", "mapping", "SRG1-PP7-TXRX")
+ response = test_utils.get_portmapping_node_attr("ROADMA01", "mapping", "SRG1-PP7-TXRX")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': 'C7', 'supporting-circuit-pack-name': '4/0',
response['mapping'])
def test_06_rdm_portmapping_SRG3_PP1_TXRX(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADMA01", "mapping", "SRG3-PP1-TXRX")
+ response = test_utils.get_portmapping_node_attr("ROADMA01", "mapping", "SRG3-PP1-TXRX")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': 'C1', 'supporting-circuit-pack-name': '5/0',
response['mapping'])
def test_07_xpdr_device_connection(self):
- 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)
+ response = test_utils.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_08_xpdr_device_connected(self):
- response = test_utils_rfc8040.check_device_connection("XPDRA01")
+ response = test_utils.check_device_connection("XPDRA01")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['connection-status'], 'connected')
time.sleep(10)
def test_09_xpdr_portmapping_info(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDRA01", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("XPDRA01", "node-info", None)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(
{'node-type': 'xpdr',
time.sleep(3)
def test_10_xpdr_portmapping_NETWORK1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDRA01", "mapping", "XPDR1-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDRA01", "mapping", "XPDR1-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
response['mapping'])
def test_11_xpdr_portmapping_NETWORK2(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDRA01", "mapping", "XPDR1-NETWORK2")
+ response = test_utils.get_portmapping_node_attr("XPDRA01", "mapping", "XPDR1-NETWORK2")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/2-PLUG-NET',
response['mapping'])
def test_12_xpdr_portmapping_CLIENT1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDRA01", "mapping", "XPDR1-CLIENT1")
+ response = test_utils.get_portmapping_node_attr("XPDRA01", "mapping", "XPDR1-CLIENT1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': 'C1',
response['mapping'])
def test_13_xpdr_portmapping_CLIENT2(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDRA01", "mapping", "XPDR1-CLIENT2")
+ response = test_utils.get_portmapping_node_attr("XPDRA01", "mapping", "XPDR1-CLIENT2")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': 'C2',
response['mapping'])
def test_14_xpdr_portmapping_CLIENT3(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDRA01", "mapping", "XPDR1-CLIENT3")
+ response = test_utils.get_portmapping_node_attr("XPDRA01", "mapping", "XPDR1-CLIENT3")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': 'C3', 'xponder-type': 'tpdr',
response['mapping'])
def test_15_xpdr_portmapping_CLIENT4(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDRA01", "mapping", "XPDR1-CLIENT4")
+ response = test_utils.get_portmapping_node_attr("XPDRA01", "mapping", "XPDR1-CLIENT4")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': 'C4', 'xponder-type': 'tpdr',
response['mapping'])
def test_16_xpdr_device_disconnection(self):
- response = test_utils_rfc8040.unmount_device("XPDRA01")
+ response = test_utils.unmount_device("XPDRA01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_17_xpdr_device_disconnected(self):
- response = test_utils_rfc8040.check_device_connection("XPDRA01")
+ response = test_utils.check_device_connection("XPDRA01")
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['connection-status']['error-type'], ('protocol', 'application'))
self.assertEqual(response['connection-status']['error-tag'], 'data-missing')
'Request could not be completed because the relevant data model content does not exist')
def test_18_xpdr_device_not_connected(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDRA01", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("XPDRA01", "node-info", None)
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['node-info']['error-type'], ('protocol', 'application'))
self.assertEqual(response['node-info']['error-tag'], 'data-missing')
'Request could not be completed because the relevant data model content does not exist')
def test_19_rdm_device_disconnection(self):
- response = test_utils_rfc8040.unmount_device("ROADMA01")
+ response = test_utils.unmount_device("ROADMA01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_20_rdm_device_disconnected(self):
- response = test_utils_rfc8040.check_device_connection("ROADMA01")
+ response = test_utils.check_device_connection("ROADMA01")
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['connection-status']['error-type'], ('protocol', 'application'))
self.assertEqual(response['connection-status']['error-tag'], 'data-missing')
'Request could not be completed because the relevant data model content does not exist')
def test_21_rdm_device_not_connected(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADMA01", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("ROADMA01", "node-info", None)
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['node-info']['error-type'], ('protocol', 'application'))
self.assertEqual(response['node-info']['error-tag'], 'data-missing')
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEtesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
# Connect the ROADMA
def test_01_connect_rdm(self):
- response = test_utils_rfc8040.mount_device("ROADMA01", ('roadma', self.NODE_VERSION))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("ROADMA01", ('roadma', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
# Verify the termination points of the ROADMA
def test_02_compare_Openroadm_topology_portmapping_rdm(self):
- resTopo = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ resTopo = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(resTopo['status_code'], requests.codes.ok)
for node in resTopo['network'][0]['node']:
nodeId = node['node-id']
nodeMapId = nodeId.split("-")[0]
- response = test_utils_rfc8040.get_portmapping_node_attr(nodeMapId, "node-info", None)
+ response = test_utils.get_portmapping_node_attr(nodeMapId, "node-info", None)
self.assertEqual(response['status_code'], requests.codes.ok)
for tp in node['ietf-network-topology:termination-point']:
tpId = tp['tp-id']
if (not "CP" in tpId) and (not "CTP" in tpId):
- response2 = test_utils_rfc8040.get_portmapping_node_attr(nodeMapId, "mapping", tpId)
+ response2 = test_utils.get_portmapping_node_attr(nodeMapId, "mapping", tpId)
self.assertEqual(response2['status_code'], requests.codes.ok)
# Disconnect the ROADMA
def test_03_disconnect_rdm(self):
- response = test_utils_rfc8040.unmount_device("ROADMA01")
+ response = test_utils.unmount_device("ROADMA01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
# #Connect the XPDRA
def test_04_connect_xpdr(self):
- 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)
+ response = test_utils.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
# #Verify the termination points related to XPDR
def test_05_compare_Openroadm_topology_portmapping_xpdr(self):
# Disconnect the XPDRA
def test_06_disconnect_device(self):
- response = test_utils_rfc8040.unmount_device("XPDRA01")
+ response = test_utils.unmount_device("XPDRA01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCETopologyTesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION),
- ('roadmb', cls.NODE_VERSION), ('roadmc', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('xpdra', 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_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(5)
def test_01_connect_ROADMA(self):
- response = test_utils_rfc8040.mount_device("ROADMA01", ('roadma', self.NODE_VERSION))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("ROADMA01", ('roadma', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_getClliNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['network'][0]['node'][0]['node-id'], 'NodeA')
self.assertEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
def test_03_getOpenRoadmNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['network'][0]['node'][0]['node-id'], 'ROADMA01')
self.assertEqual(response['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
self.assertEqual(response['network'][0]['node'][0]['org-openroadm-network:model'], '2')
def test_04_getLinks_OpenroadmTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
# Tests related to links
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 10)
self.assertEqual(len(link), 0)
def test_05_getNodes_OpenRoadmTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 4)
listNode = ['ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
self.assertEqual(len(listNode), 0)
def test_06_connect_XPDRA(self):
- 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)
+ response = test_utils.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_07_getClliNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['network'][0]['node'][0]['node-id'], 'NodeA')
self.assertEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
def test_08_getOpenRoadmNetwork(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 2)
for node in response['network'][0]['node']:
def test_09_getNodes_OpenRoadmTopology(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 5)
listNode = ['XPDRA01-XPDR1', 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
# Connect the tail XPDRA to ROADMA and vice versa
def test_10_connect_tail_xpdr_rdm(self):
# Connect the tail: XPDRA to ROADMA
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
def test_11_connect_tail_rdm_xpdr(self):
# Connect the tail: ROADMA to XPDRA
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_12_getLinks_OpenRoadmTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 12)
check_list = {'EXPRESS-LINK': ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
self.assertEqual(len(link), 0)
def test_13_connect_ROADMC(self):
- response = test_utils_rfc8040.mount_device("ROADMC01", ('roadmc', self.NODE_VERSION))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("ROADMC01", ('roadmc', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_14_omsAttributes_ROADMA_ROADMC(self):
# Config ROADMA01-ROADMC01 oms-attributes
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
def test_16_getClliNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
listNode = ['NodeA', 'NodeC']
for node in response['network'][0]['node']:
self.assertEqual(len(listNode), 0)
def test_17_getOpenRoadmNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 3)
listNode = ['XPDRA01', 'ROADMA01', 'ROADMC01']
self.assertEqual(len(listNode), 0)
def test_18_getROADMLinkOpenRoadmTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 20)
check_list = {'EXPRESS-LINK': ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
self.assertEqual(len(link), 0)
def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 20)
R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
def test_20_getNodes_OpenRoadmTopology(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 8)
listNode = ['XPDRA01-XPDR1',
self.assertEqual(len(listNode), 0)
def test_21_connect_ROADMB(self):
- response = test_utils_rfc8040.mount_device("ROADMB01", ('roadmb', self.NODE_VERSION))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("ROADMB01", ('roadmb', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_22_omsAttributes_ROADMA_ROADMB(self):
# Config ROADMA01-ROADMB01 oms-attributes
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
def test_26_getClliNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
listNode = ['NodeA', 'NodeB', 'NodeC']
for node in response['network'][0]['node']:
self.assertEqual(len(listNode), 0)
def test_27_verifyDegree(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
listR2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
self.assertEqual(len(listR2RLink), 0)
def test_28_verifyOppositeLinkTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 34)
for link in response['network'][0]['ietf-network-topology:link']:
link_dest = link['destination']['dest-node']
oppLink_id = link['org-openroadm-common-network:opposite-link']
# Find the opposite link
- res_oppLink = test_utils_rfc8040.get_ietf_network_link_request('openroadm-topology', oppLink_id, 'config')
+ res_oppLink = test_utils.get_ietf_network_link_request('openroadm-topology', oppLink_id, 'config')
self.assertEqual(res_oppLink['status_code'], requests.codes.ok)
self.assertEqual(res_oppLink['link']['org-openroadm-common-network:opposite-link'], link_id)
self.assertEqual(res_oppLink['link']['source']['source-node'], link_dest)
self.assertEqual(oppLink_type, CHECK_DICT[link_type])
def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
def test_30_disconnect_ROADMB(self):
# Delete in the topology-netconf
- response = test_utils_rfc8040.unmount_device("ROADMB01")
+ response = test_utils.unmount_device("ROADMB01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
# Delete in the clli-network
- response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeB', 'config')
+ response = test_utils.del_ietf_network_node_request('clli-network', 'NodeB', 'config')
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_31_disconnect_ROADMC(self):
- response = test_utils_rfc8040.unmount_device("ROADMC01")
+ response = test_utils.unmount_device("ROADMC01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
# Delete in the clli-network
- response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeC', 'config')
+ response = test_utils.del_ietf_network_node_request('clli-network', 'NodeC', 'config')
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_32_getNodes_OpenRoadmTopology(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 5)
listNode = ['XPDRA01-XPDR1', 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
self.assertNotEqual(node['node-id'], 'ROADMC01-DEG2')
def test_33_getOpenRoadmNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 2)
for node in response['network'][0]['node']:
self.assertNotEqual(node['node-id'], 'ROADMB01')
def test_34_getClliNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 1)
self.assertNotEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeC')
def test_35_disconnect_XPDRA(self):
- response = test_utils_rfc8040.unmount_device("XPDRA01")
+ response = test_utils.unmount_device("XPDRA01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_36_getClliNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 1)
self.assertEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
def test_37_getOpenRoadmNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 1)
self.assertNotEqual(response['network'][0]['node'][0]['node-id'], 'XPDRA01')
def test_38_getNodes_OpenRoadmTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 4)
listNode = ['ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
def test_39_disconnect_ROADM_XPDRA_link(self):
# Link-1
- response = test_utils_rfc8040.del_ietf_network_link_request(
+ response = test_utils.del_ietf_network_link_request(
'openroadm-topology',
'XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX',
'config')
# Link-2
- response2 = test_utils_rfc8040.del_ietf_network_link_request(
+ response2 = test_utils.del_ietf_network_link_request(
'openroadm-topology',
'ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1',
'config')
self.assertIn(response2.status_code, (requests.codes.ok, requests.codes.no_content))
def test_40_getLinks_OpenRoadmTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 16)
check_list = {'EXPRESS-LINK': ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
self.assertNotEqual(link['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
def test_41_disconnect_ROADMA(self):
- response = test_utils_rfc8040.unmount_device("ROADMA01")
+ response = test_utils.unmount_device("ROADMA01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
# Delete in the clli-network
- response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeA', 'config')
+ response = test_utils.del_ietf_network_node_request('clli-network', 'NodeA', 'config')
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_42_getClliNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertNotIn('node', response['network'][0])
def test_43_getOpenRoadmNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertNotIn('node', response['network'][0])
def test_44_check_roadm2roadm_link_persistence(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertNotIn('node', response['network'][0])
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 6)
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCERendererTesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(10)
def test_01_rdm_device_connected(self):
- response = test_utils_rfc8040.mount_device("ROADMA01", ('roadma', self.NODE_VERSION))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("ROADMA01", ('roadma', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_xpdr_device_connected(self):
- 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)
+ response = test_utils.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_rdm_portmapping(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADMA01", None, None)
+ response = test_utils.get_portmapping_node_attr("ROADMA01", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': 'L1', 'supporting-circuit-pack-name': '2/0',
response['nodes'][0]['mapping'])
def test_04_xpdr_portmapping(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDRA01", None, None)
+ response = test_utils.get_portmapping_node_attr("XPDRA01", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
response['nodes'][0]['mapping'])
def test_05_service_path_create(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'service_test',
self.assertIn('Interfaces created successfully for nodes: ROADMA01', response['output']['result'])
def test_06_service_path_create_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADMA01", "interface", "DEG1-TTP-TXRX-713:720")
+ response = test_utils.check_node_attribute_request("ROADMA01", "interface", "DEG1-TTP-TXRX-713:720")
self.assertEqual(response['status_code'], requests.codes.ok)
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
response['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
def test_07_service_path_create_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADMA01", "interface", "SRG1-PP7-TXRX-713:720")
+ response = test_utils.check_node_attribute_request("ROADMA01", "interface", "SRG1-PP7-TXRX-713:720")
self.assertEqual(response['status_code'], requests.codes.ok)
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
response['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
def test_08_service_path_create_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"ROADMA01", "roadm-connections", "SRG1-PP7-TXRX-DEG1-TTP-TXRX-713:720")
self.assertEqual(response['status_code'], requests.codes.ok)
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual({'dst-if': 'DEG1-TTP-TXRX-713:720'}, response['roadm-connections'][0]['destination'])
def test_09_service_path_create_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDRA01", "interface", "XPDR1-NETWORK1-713:720")
+ response = test_utils.check_node_attribute_request("XPDRA01", "interface", "XPDR1-NETWORK1-713:720")
self.assertEqual(response['status_code'], requests.codes.ok)
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
self.assertEqual(float(intf['transmit-power']), -5)
def test_10_service_path_create_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDRA01", "interface", "XPDR1-NETWORK1-OTU")
+ response = test_utils.check_node_attribute_request("XPDRA01", "interface", "XPDR1-NETWORK1-OTU")
self.assertEqual(response['status_code'], requests.codes.ok)
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
response['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
def test_11_service_path_create_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDRA01", "interface", "XPDR1-NETWORK1-ODU")
+ response = test_utils.check_node_attribute_request("XPDRA01", "interface", "XPDR1-NETWORK1-ODU")
self.assertEqual(response['status_code'], requests.codes.ok)
# the 2 following statements replace self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_12_service_path_create_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDRA01", "interface", "XPDR1-CLIENT1-ETHERNET")
+ response = test_utils.check_node_attribute_request("XPDRA01", "interface", "XPDR1-CLIENT1-ETHERNET")
self.assertEqual(response['status_code'], requests.codes.ok)
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
def test_13_service_path_create_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDRA01", "circuit-packs", "1%2F0%2F1-PLUG-NET")
+ response = test_utils.check_node_attribute_request("XPDRA01", "circuit-packs", "1%2F0%2F1-PLUG-NET")
# FIXME: https://jira.opendaylight.org/browse/TRNSPRTPCE-591
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('not-reserved-inuse', response['circuit-packs'][0]["equipment-state"])
def test_14_service_path_delete(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'service_test',
self.assertDictEqual(response['output'], {'result': 'Request processed', 'success': True})
def test_15_service_path_delete_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADMA01", "interface", "DEG1-TTP-TXRX-713:720")
+ response = test_utils.check_node_attribute_request("ROADMA01", "interface", "DEG1-TTP-TXRX-713:720")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_16_service_path_delete_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADMA01", "interface", "SRG1-PP7-TXRX-713:720")
+ response = test_utils.check_node_attribute_request("ROADMA01", "interface", "SRG1-PP7-TXRX-713:720")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_17_service_path_delete_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"ROADMA01", "roadm-connections", "SRG1-PP7-TXRX-DEG1-TTP-TXRX-713:720")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_18_service_path_delete_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDRA01", "interface", "XPDR1-NETWORK1-713:720")
+ response = test_utils.check_node_attribute_request("XPDRA01", "interface", "XPDR1-NETWORK1-713:720")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_19_service_path_delete_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDRA01", "interface", "XPDR1-NETWORK1-OTU")
+ response = test_utils.check_node_attribute_request("XPDRA01", "interface", "XPDR1-NETWORK1-OTU")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_20_service_path_delete_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDRA01", "interface", "XPDR1-NETWORK1-ODU")
+ response = test_utils.check_node_attribute_request("XPDRA01", "interface", "XPDR1-NETWORK1-ODU")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_21_service_path_delete_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDRA01", "interface", "XPDR1-CLIENT1-ETHERNET")
+ response = test_utils.check_node_attribute_request("XPDRA01", "interface", "XPDR1-CLIENT1-ETHERNET")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_22_service_path_delete_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDRA01", "circuit-packs", "1%2F0%2F1-PLUG-NET")
+ response = test_utils.check_node_attribute_request("XPDRA01", "circuit-packs", "1%2F0%2F1-PLUG-NET")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual('not-reserved-available', response["circuit-packs"][0]['equipment-state'])
def test_23_rdm_device_disconnected(self):
- response = test_utils_rfc8040.unmount_device("ROADMA01")
+ response = test_utils.unmount_device("ROADMA01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_24_xpdr_device_disconnected(self):
- response = test_utils_rfc8040.unmount_device("XPDRA01")
+ response = test_utils.unmount_device("XPDRA01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportOlmTesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- 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)])
+ 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)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(1)
def test_01_xpdrA_device_connected(self):
- 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)
+ response = test_utils.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_xpdrC_device_connected(self):
- 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)
+ response = test_utils.mount_device("XPDRC01", ('xpdrc', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_rdmA_device_connected(self):
- 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)
+ 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)
def test_04_rdmC_device_connected(self):
- 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)
+ 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)
def test_05_connect_xprdA_to_roadmA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_06_connect_roadmA_to_xpdrA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_07_connect_xprdC_to_roadmC(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_08_connect_roadmC_to_xpdrC(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_09_create_OTS_ROADMA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADMA01',
self.assertEqual(response['status_code'], requests.codes.ok)
def test_10_create_OTS_ROADMC(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADMC01',
self.assertEqual(response['status_code'], requests.codes.ok)
def test_11_get_PM_ROADMA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'get-pm',
{
'node-id': 'ROADMA01',
}, response['output']['measurements'])
def test_12_get_PM_ROADMC(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'get-pm',
{
'node-id': 'ROADMC01',
}, response['output']['measurements'])
def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'calculate-spanloss-base',
{
'src-type': 'link',
time.sleep(5)
def test_14_calculate_span_loss_base_all(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'calculate-spanloss-base',
{
'src-type': 'all'
time.sleep(5)
def test_15_get_OTS_DEG1_TTP_TXRX_ROADMA(self):
- response = test_utils_rfc8040.check_node_attribute2_request(
+ response = test_utils.check_node_attribute2_request(
'ROADMA01', 'interface', 'OTS-DEG1-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 5.7)
self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 15.1)
- # FIXME test_utils_rfc8040.check_node_attribute2_request retrives values in config DS
+ # FIXME test_utils.check_node_attribute2_request retrives values in config DS
# but values are different (6 and 15) in nonconfig/operational DS and should not
# Honeynode simulator bug ?
# Reopen similar issues found in RSPN tests at TRNSPRTPCE-591
def test_16_get_OTS_DEG2_TTP_TXRX_ROADMC(self):
- response = test_utils_rfc8040.check_node_attribute2_request(
+ response = test_utils.check_node_attribute2_request(
'ROADMC01', 'interface', 'OTS-DEG2-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 15.1)
self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 5.7)
def test_17_servicePath_create_AToZ(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'test',
time.sleep(10)
def test_18_servicePath_create_ZToA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'test',
time.sleep(10)
def test_19_service_power_setup_XPDRA_XPDRC(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'service-power-setup',
{
'service-name': 'test',
self.assertIn('Success', response['output']['result'])
def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
- response = test_utils_rfc8040.check_node_attribute2_request(
+ response = test_utils.check_node_attribute2_request(
'XPDRA01', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), 0)
self.assertEqual(int(response['org-openroadm-optical-channel-interfaces:och']['wavelength-number']), 1)
def test_21_get_roadmconnection_ROADMA(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'ROADMA01', 'roadm-connections', 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -3.3)
def test_22_get_roadmconnection_ROADMC(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'ROADMC01', 'roadm-connections', 'DEG2-TTP-TXRX-SRG1-PP1-TXRX-761:768')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("power", response['roadm-connections'][0]['opticalControlMode'])
def test_23_service_power_setup_XPDRC_XPDRA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'service-power-setup',
{
'service-name': 'test',
self.assertIn('Success', response['output']['result'])
def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
- response = test_utils_rfc8040.check_node_attribute2_request(
+ response = test_utils.check_node_attribute2_request(
'XPDRC01', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), 0)
self.assertEqual(int(response['org-openroadm-optical-channel-interfaces:och']['wavelength-number']), 1)
def test_25_get_roadmconnection_ROADMC(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'ROADMC01', 'roadm-connections', 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -0.63)
def test_26_service_power_turndown_XPDRA_XPDRC(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'service-power-turndown',
{
'service-name': 'test',
self.assertIn('Success', response['output']['result'])
def test_27_get_roadmconnection_ROADMA(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'ROADMA01', 'roadm-connections', 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -60)
def test_28_get_roadmconnection_ROADMC(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'ROADMC01', 'roadm-connections', 'DEG2-TTP-TXRX-SRG1-PP1-TXRX-761:768')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
def test_29_servicePath_delete_AToZ(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'test',
time.sleep(10)
def test_30_servicePath_delete_ZToA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'test',
#"""to test case where SRG where the xpdr is connected to has no optical range data"""
def test_31_connect_xprdA_to_roadmA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_32_connect_roadmA_to_xpdrA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_33_servicePath_create_AToZ(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'test2',
time.sleep(10)
def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
- response = test_utils_rfc8040.check_node_attribute2_request(
+ response = test_utils.check_node_attribute2_request(
'XPDRA01', 'interface', 'XPDR1-NETWORK2-753:760', 'org-openroadm-optical-channel-interfaces:och')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
self.assertEqual(int(response['org-openroadm-optical-channel-interfaces:och']['wavelength-number']), 2)
def test_35_servicePath_delete_AToZ(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'test2',
time.sleep(10)
def test_36_xpdrA_device_disconnected(self):
- response = test_utils_rfc8040.unmount_device("XPDRA01")
+ response = test_utils.unmount_device("XPDRA01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_37_xpdrC_device_disconnected(self):
- response = test_utils_rfc8040.unmount_device("XPDRC01")
+ response = test_utils.unmount_device("XPDRC01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_38_calculate_span_loss_current(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'calculate-spanloss-current',
None)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(5)
def test_39_rdmA_device_disconnected(self):
- response = test_utils_rfc8040.unmount_device("ROADMA01")
+ response = test_utils.unmount_device("ROADMA01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_40_rdmC_device_disconnected(self):
- response = test_utils_rfc8040.unmount_device("ROADMC01")
+ response = test_utils.unmount_device("ROADMC01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEFulltesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- 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)])
+ 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)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self): # instruction executed before each test method
# connect netconf devices
def test_01_connect_xpdrA(self):
- 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)
+ response = test_utils.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_connect_xpdrC(self):
- 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)
+ response = test_utils.mount_device("XPDRC01", ('xpdrc', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_connect_rdmA(self):
- 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)
+ 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)
def test_04_connect_rdmC(self):
- 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)
+ 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)
def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request("ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX",
- data)
+ response = test_utils.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):
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request("ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX",
- data)
+ response = test_utils.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_input_data["service-name"] = "service1"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_12_get_eth_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1")
+ response = test_utils.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')
time.sleep(1)
def test_13_check_xc1_ROADMA(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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
time.sleep(1)
def test_14_check_xc1_ROADMC(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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
time.sleep(1)
def test_15_check_topo_XPDRA(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDRA01-XPDR1', 'config')
+ response = test_utils.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:
time.sleep(1)
def test_16_check_topo_ROADMA_SRG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-SRG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-SRG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_17_check_topo_ROADMA_DEG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-DEG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-DEG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
def test_22_create_eth_service2(self):
self.cr_serv_input_data["service-name"] = "service2"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_23_get_eth_service2(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service2")
+ response = test_utils.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')
time.sleep(1)
def test_24_check_xc2_ROADMA(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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
time.sleep(1)
def test_25_check_topo_XPDRA(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDRA01-XPDR1', 'config')
+ response = test_utils.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:
time.sleep(1)
def test_26_check_topo_ROADMA_SRG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-SRG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-SRG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_27_check_topo_ROADMA_DEG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-DEG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-DEG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
# creation service test on a non-available resource
def test_28_create_eth_service3(self):
self.cr_serv_input_data["service-name"] = "service3"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_29_delete_eth_service3(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service3"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_30_delete_eth_service1(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_31_delete_eth_service2(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service2"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_32_check_no_xc_ROADMA(self):
- response = test_utils_rfc8040.check_node_request("ROADMA01")
+ response = test_utils.check_node_request("ROADMA01")
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_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDRA01-XPDR1', 'config')
+ response = test_utils.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:
time.sleep(1)
def test_34_check_topo_ROADMA_SRG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-SRG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-SRG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_35_check_topo_ROADMA_DEG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-DEG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-DEG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_37_get_oc_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1")
+ response = test_utils.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')
time.sleep(1)
def test_38_check_xc1_ROADMA(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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
time.sleep(1)
def test_39_check_xc1_ROADMC(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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.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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_41_get_oc_service2(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service2")
+ response = test_utils.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')
time.sleep(2)
def test_42_check_xc2_ROADMA(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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
def test_44_delete_oc_service1(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_45_delete_oc_service2(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service2"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_46_get_no_oc_services(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['service-list'], (
{
time.sleep(1)
def test_47_get_no_xc_ROADMA(self):
- response = test_utils_rfc8040.check_node_request("ROADMA01")
+ response = test_utils.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)
self.test_30_delete_eth_service1()
def test_50_loop_create_oc_service(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1")
+ response = test_utils.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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
time.sleep(5)
self.test_44_delete_oc_service1()
def test_51_disconnect_XPDRA(self):
- response = test_utils_rfc8040.unmount_device("XPDRA01")
+ response = test_utils.unmount_device("XPDRA01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_52_disconnect_XPDRC(self):
- response = test_utils_rfc8040.unmount_device("XPDRC01")
+ response = test_utils.unmount_device("XPDRC01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_53_disconnect_ROADMA(self):
- response = test_utils_rfc8040.unmount_device("ROADMA01")
+ response = test_utils.unmount_device("ROADMA01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_54_disconnect_ROADMC(self):
- response = test_utils_rfc8040.unmount_device("ROADMC01")
+ response = test_utils.unmount_device("ROADMC01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEPortMappingTesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION),
- ('spdra', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION),
+ ('spdra', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(1)
def test_01_rdm_device_connection(self):
- 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)
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_rdm_device_connected(self):
- response = test_utils_rfc8040.check_device_connection("ROADM-A1")
+ response = test_utils.check_device_connection("ROADM-A1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['connection-status'], 'connected')
def test_03_rdm_portmapping_info(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("ROADM-A1", "node-info", None)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(
{'node-type': 'rdm',
response['node-info'])
def test_04_rdm_portmapping_DEG1_TTP_TXRX(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", "mapping", "DEG1-TTP-TXRX")
+ response = test_utils.get_portmapping_node_attr("ROADM-A1", "mapping", "DEG1-TTP-TXRX")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': 'L1', 'supporting-circuit-pack-name': '1/0',
response['mapping'])
def test_05_rdm_portmapping_DEG2_TTP_TXRX_with_ots_oms(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", "mapping", "DEG2-TTP-TXRX")
+ response = test_utils.get_portmapping_node_attr("ROADM-A1", "mapping", "DEG2-TTP-TXRX")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': 'L1', 'supporting-circuit-pack-name': '2/0',
response['mapping'])
def test_06_rdm_portmapping_SRG1_PP3_TXRX(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", "mapping", "SRG1-PP3-TXRX")
+ response = test_utils.get_portmapping_node_attr("ROADM-A1", "mapping", "SRG1-PP3-TXRX")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': 'C3', 'supporting-circuit-pack-name': '3/0',
response['mapping'])
def test_07_rdm_portmapping_SRG3_PP1_TXRX(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", "mapping", "SRG3-PP1-TXRX")
+ response = test_utils.get_portmapping_node_attr("ROADM-A1", "mapping", "SRG3-PP1-TXRX")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': 'C1', 'supporting-circuit-pack-name': '5/0',
response['mapping'])
def test_08_xpdr_device_connection(self):
- 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)
+ 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)
def test_09_xpdr_device_connected(self):
- response = test_utils_rfc8040.check_device_connection("XPDR-A1")
+ response = test_utils.check_device_connection("XPDR-A1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['connection-status'], 'connected')
def test_10_xpdr_portmapping_info(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A1", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("XPDR-A1", "node-info", None)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(
{'node-type': 'xpdr',
response['node-info'])
def test_11_xpdr_portmapping_NETWORK1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A1", "mapping", "XPDR1-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A1", "mapping", "XPDR1-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supported-interface-capability': ['org-openroadm-port-types:if-OCH'],
response['mapping'])
def test_12_xpdr_portmapping_XPDR2_NETWORK1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A1", "mapping", "XPDR1-NETWORK2")
+ response = test_utils.get_portmapping_node_attr("XPDR-A1", "mapping", "XPDR1-NETWORK2")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supported-interface-capability': ['org-openroadm-port-types:if-OCH'],
response['mapping'])
def test_13_xpdr_portmapping_XPDR1_CLIENT1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A1", "mapping", "XPDR1-CLIENT1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A1", "mapping", "XPDR1-CLIENT1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supported-interface-capability': ['org-openroadm-port-types:if-100GE'],
response['mapping'])
def test_14_xpdr_portmapping_XPDR1_CLIENT2(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A1", "mapping", "XPDR1-CLIENT2")
+ response = test_utils.get_portmapping_node_attr("XPDR-A1", "mapping", "XPDR1-CLIENT2")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supported-interface-capability': ['org-openroadm-port-types:if-100GE'],
response['mapping'])
def test_15_spdr_device_connection(self):
- response = test_utils_rfc8040.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_16_spdr_device_connected(self):
- response = test_utils_rfc8040.check_device_connection("SPDR-SA1")
+ response = test_utils.check_device_connection("SPDR-SA1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['connection-status'], 'connected')
def test_17_spdr_portmapping_info(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", "node-info", None)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(
{'node-type': 'xpdr',
response['node-info'])
def test_18_spdr_switching_pool_1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", "switching-pool-lcp", "1")
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", "switching-pool-lcp", "1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("blocking",
response['switching-pool-lcp'][0]['switching-pool-type'])
response['switching-pool-lcp'][0]['non-blocking-list'])
def test_19_spdr_switching_pool_2(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", "switching-pool-lcp", "2")
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", "switching-pool-lcp", "2")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("non-blocking",
response['switching-pool-lcp'][0]['switching-pool-type'])
response['switching-pool-lcp'][0]['non-blocking-list'])
def test_20_spdr_switching_pool_3(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", "switching-pool-lcp", "3")
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", "switching-pool-lcp", "3")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("blocking",
response['switching-pool-lcp'][0]['switching-pool-type'])
response['switching-pool-lcp'][0]['non-blocking-list'])
def test_21_spdr_portmapping_mappings(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", None, None)
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(18, len(response['nodes'][0]['mapping']))
def test_22_spdr_portmapping_XPDR1_CLIENT1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR1-CLIENT1")
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR1-CLIENT1")
self.assertEqual(response['status_code'], requests.codes.ok)
expected_subset_response = {
"logical-connection-point": "XPDR1-CLIENT1",
self.assertEqual(sorted(response['mapping'][0]['supported-interface-capability']), expected_sorted_list)
def test_23_spdr_portmapping_XPDR1_NETWORK1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR1-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR1-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{"logical-connection-point": "XPDR1-NETWORK1",
response['mapping'])
def test_24_spdr_portmapping_XPDR2_CLIENT2(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR2-CLIENT2")
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR2-CLIENT2")
self.assertEqual(response['status_code'], requests.codes.ok)
expected_subset_response = {
'logical-connection-point': 'XPDR2-CLIENT2',
self.assertEqual(sorted(response['mapping'][0]['supported-interface-capability']), expected_sorted_list)
def test_25_spdr_portmapping_XPDR2_NETWORK2(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR2-NETWORK2")
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR2-NETWORK2")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{"logical-connection-point": "XPDR2-NETWORK2",
response['mapping'])
def test_26_spdr_portmapping_XPDR3_CLIENT3(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR3-CLIENT3")
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR3-CLIENT3")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{"logical-connection-point": "XPDR3-CLIENT3",
response['mapping'])
def test_27_spdr_portmapping_XPDR3_NETWORK1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR3-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR3-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{"logical-connection-point": "XPDR3-NETWORK1",
response['mapping'])
def test_28_spdr_device_disconnection(self):
- response = test_utils_rfc8040.unmount_device("SPDR-SA1")
+ response = test_utils.unmount_device("SPDR-SA1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_29_xpdr_device_disconnected(self):
- response = test_utils_rfc8040.check_device_connection("SPDR-SA1")
+ response = test_utils.check_device_connection("SPDR-SA1")
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['connection-status']['error-type'], ('protocol', 'application'))
self.assertEqual(response['connection-status']['error-tag'], 'data-missing')
'Request could not be completed because the relevant data model content does not exist')
def test_30_xpdr_device_disconnection(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A1")
+ response = test_utils.unmount_device("XPDR-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_31_xpdr_device_disconnected(self):
- response = test_utils_rfc8040.check_device_connection("XPDR-A1")
+ response = test_utils.check_device_connection("XPDR-A1")
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['connection-status']['error-type'], ('protocol', 'application'))
self.assertEqual(response['connection-status']['error-tag'], 'data-missing')
'Request could not be completed because the relevant data model content does not exist')
def test_32_xpdr_device_not_connected(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A1", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("XPDR-A1", "node-info", None)
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['node-info']['error-type'], ('protocol', 'application'))
self.assertEqual(response['node-info']['error-tag'], 'data-missing')
'Request could not be completed because the relevant data model content does not exist')
def test_33_rdm_device_disconnection(self):
- response = test_utils_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_34_rdm_device_disconnected(self):
- response = test_utils_rfc8040.check_device_connection("ROADM-A1")
+ response = test_utils.check_device_connection("ROADM-A1")
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['connection-status']['error-type'], ('protocol', 'application'))
self.assertEqual(response['connection-status']['error-tag'], 'data-missing')
'Request could not be completed because the relevant data model content does not exist')
def test_35_rdm_device_not_connected(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("ROADM-A1", "node-info", None)
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['node-info']['error-type'], ('protocol', 'application'))
self.assertEqual(response['node-info']['error-tag'], 'data-missing')
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEtesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
# Connect the ROADMA
def test_01_connect_rdm(self):
- 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)
+ 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)
# Verify the termination points of the ROADMA
def test_02_compareOpenroadmTopologyPortMapping_rdm(self):
- resTopo = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ resTopo = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(resTopo['status_code'], requests.codes.ok)
nbMapCumul = 0
nbMappings = 0
print("nodeId={}".format(nodeId))
nodeMapId = nodeId.split("-")[0] + "-" + nodeId.split("-")[1]
print("nodeMapId={}".format(nodeMapId))
- response = test_utils_rfc8040.get_portmapping_node_attr(nodeMapId, "node-info", None)
+ response = test_utils.get_portmapping_node_attr(nodeMapId, "node-info", None)
self.assertEqual(response['status_code'], requests.codes.ok)
- responseMapList = test_utils_rfc8040.get_portmapping_node_attr(nodeMapId, None, None)
+ responseMapList = test_utils.get_portmapping_node_attr(nodeMapId, None, None)
nbMappings = len(responseMapList['nodes'][0]['mapping']) - nbMapCumul
nbMapCurrent = 0
for tp in node['ietf-network-topology:termination-point']:
tpId = tp['tp-id']
if (not "CP" in tpId) and (not "CTP" in tpId):
- responseMap = test_utils_rfc8040.get_portmapping_node_attr(nodeMapId, "mapping", tpId)
+ responseMap = test_utils.get_portmapping_node_attr(nodeMapId, "mapping", tpId)
self.assertEqual(responseMap['status_code'], requests.codes.ok)
if responseMap['status_code'] == requests.codes.ok:
nbMapCurrent += 1
# Disconnect the ROADMA
def test_03_disconnect_rdm(self):
- response = test_utils_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
# #Connect the XPDRA
def test_04_connect_xpdr(self):
- 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)
+ 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)
# #Verify the termination points related to XPDR
def test_05_compareOpenroadmTopologyPortMapping_xpdr(self):
# Disconnect the XPDRA
def test_06_disconnect_device(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A1")
+ response = test_utils.unmount_device("XPDR-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEtesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION),
- ('roadmb', cls.NODE_VERSION), ('roadmc', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('xpdra', 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_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(5)
def test_01_connect_ROADM_A1(self):
- 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)
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_getClliNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
logging.info(response)
self.assertEqual(response['network'][0]['node'][0]['node-id'], 'NodeA')
self.assertEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
def test_03_getOpenRoadmNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['network'][0]['node'][0]['node-id'], 'ROADM-A1')
self.assertEqual(response['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
def test_04_getLinks_OpenroadmTopology(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 10)
check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
def test_05_getNodes_OpenRoadmTopology(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 4)
listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
self.assertEqual(len(listNode), 0)
def test_06_connect_XPDRA(self):
- 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)
+ 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)
def test_07_getClliNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['network'][0]['node'][0]['node-id'], 'NodeA')
self.assertEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
def test_08_getOpenRoadmNetwork(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
nbNode = len(response['network'][0]['node'])
self.assertEqual(nbNode, 2)
def test_09_getNodes_OpenRoadmTopology(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 5)
listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
# Connect the tail XPDRA to ROADMA and vice versa
def test_10_connect_tail_xpdr_rdm(self):
# Connect the tail: XPDRA to ROADMA
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_11_connect_tail_rdm_xpdr(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
def test_12_getLinks_OpenRoadmTopology(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 12)
check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
self.assertEqual(len(link), 0)
def test_13_connect_ROADMC(self):
- 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)
+ response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_14_omsAttributes_ROADMA_ROADMC(self):
# Config ROADMA-ROADMC oms-attributes
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.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_16_getClliNetwork(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
listNode = ['NodeA', 'NodeC']
for node in response['network'][0]['node']:
def test_17_getOpenRoadmNetwork(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
nbNode = len(response['network'][0]['node'])
self.assertEqual(nbNode, 3)
def test_18_getROADMLinkOpenRoadmTopology(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 20)
check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
self.assertEqual(len(link), 0)
def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 20)
R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
def test_20_getNodes_OpenRoadmTopology(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 8)
listNode = ['XPDR-A1-XPDR1',
self.assertEqual(len(listNode), 0)
def test_21_connect_ROADMB(self):
- response = test_utils_rfc8040.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_22_omsAttributes_ROADMA_ROADMB(self):
# Config ROADM-A1-ROADM-B1 oms-attributes
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.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_26_getClliNetwork(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
listNode = ['NodeA', 'NodeB', 'NodeC']
for node in response['network'][0]['node']:
self.assertEqual(len(listNode), 0)
def test_27_verifyDegree(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
listR2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
self.assertEqual(len(listR2RLink), 0)
def test_28_verifyOppositeLinkTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 30)
for link in response['network'][0]['ietf-network-topology:link']:
link_dest = link['destination']['dest-node']
oppLink_id = link['org-openroadm-common-network:opposite-link']
# Find the opposite link
- res_oppLink = test_utils_rfc8040.get_ietf_network_link_request('openroadm-topology', oppLink_id, 'config')
+ res_oppLink = test_utils.get_ietf_network_link_request('openroadm-topology', oppLink_id, 'config')
self.assertEqual(res_oppLink['status_code'], requests.codes.ok)
self.assertEqual(res_oppLink['link']['org-openroadm-common-network:opposite-link'], link_id)
self.assertEqual(res_oppLink['link']['source']['source-node'], link_dest)
self.assertEqual(oppLink_type, CHECK_DICT[link_type])
def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
def test_30_disconnect_ROADMB(self):
# Delete in the topology-netconf
- response = test_utils_rfc8040.unmount_device("ROADM-B1")
+ response = test_utils.unmount_device("ROADM-B1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
# Delete in the clli-network
- response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeB', 'config')
+ response = test_utils.del_ietf_network_node_request('clli-network', 'NodeB', 'config')
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_31_disconnect_ROADMC(self):
# Delete in the topology-netconf
- response = test_utils_rfc8040.unmount_device("ROADM-C1")
+ response = test_utils.unmount_device("ROADM-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
# Delete in the clli-network
- response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeC', 'config')
+ response = test_utils.del_ietf_network_node_request('clli-network', 'NodeC', 'config')
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_32_getNodes_OpenRoadmTopology(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 5)
listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
self.assertNotEqual(node['node-id'], 'ROADM-C1-DEG2')
def test_33_getOpenRoadmNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
nbNode = len(response['network'][0]['node'])
self.assertEqual(nbNode, 2)
self.assertNotEqual(node['node-id'], 'ROADM-B1')
def test_34_getClliNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 1)
self.assertNotEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeC')
def test_35_disconnect_XPDRA(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A1")
+ response = test_utils.unmount_device("XPDR-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_36_getClliNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 1)
self.assertEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
def test_37_getOpenRoadmNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 1)
self.assertNotEqual(response['network'][0]['node'][0]['node-id'], 'XPDR-A1')
def test_38_getNodes_OpenRoadmTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 4)
listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
def test_39_disconnect_ROADM_XPDRA_link(self):
# Link-1
- response = test_utils_rfc8040.del_ietf_network_link_request(
+ response = test_utils.del_ietf_network_link_request(
'openroadm-topology',
'XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX',
'config')
# Link-2
- response2 = test_utils_rfc8040.del_ietf_network_link_request(
+ response2 = test_utils.del_ietf_network_link_request(
'openroadm-topology',
'ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1',
'config')
self.assertIn(response2.status_code, (requests.codes.ok, requests.codes.no_content))
def test_40_getLinks_OpenRoadmTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 16)
check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
self.assertNotEqual(link['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
def test_41_disconnect_ROADMA(self):
- response = test_utils_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
# Delete in the clli-network
- response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeA', 'config')
+ response = test_utils.del_ietf_network_node_request('clli-network', 'NodeA', 'config')
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_42_getClliNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertNotIn('node', response['network'][0])
def test_43_getOpenRoadmNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertNotIn('node', response['network'][0])
def test_44_check_roadm2roadm_link_persistence(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertNotIn('node', response['network'][0])
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 6)
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEtesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('spdra', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('spdra', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(5)
def test_01_connect_SPDR_SA1(self):
- response = test_utils_rfc8040.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
time.sleep(10)
- response = test_utils_rfc8040.check_device_connection("SPDR-SA1")
+ response = test_utils.check_device_connection("SPDR-SA1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['connection-status'], 'connected')
def test_02_getClliNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
logging.info(response)
self.assertEqual(response['network'][0]['node'][0]['node-id'], 'NodeSA')
self.assertEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeSA')
def test_03_getOpenRoadmNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['network'][0]['node'][0]['node-id'], 'SPDR-SA1')
self.assertEqual(response['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
self.assertEqual(response['network'][0]['node'][0]['org-openroadm-network:ip'], '1.2.3.4')
def test_04_getLinks_OpenroadmTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertNotIn('ietf-network-topology:link', response['network'][0])
def test_05_getNodes_OpenRoadmTopology(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('node', response['network'][0])
self.assertEqual(len(response['network'][0]['node']), 3)
self.assertEqual(len(listNode), 0)
def test_06_getLinks_OtnTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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_07_getNodes_OtnTopology(self):
# pylint: disable=redundant-unittest-assert
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.get_ietf_network_request('otn-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 3)
listNode = ['SPDR-SA1-XPDR1', 'SPDR-SA1-XPDR2', 'SPDR-SA1-XPDR3']
self.assertEqual(len(listNode), 0)
def test_08_disconnect_SPDR_SA1(self):
- response = test_utils_rfc8040.unmount_device("SPDR-SA1")
+ response = test_utils.unmount_device("SPDR-SA1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_09_getClliNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
+ response = test_utils.get_ietf_network_request('clli-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 1)
self.assertEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeSA')
def test_10_getOpenRoadmNetwork(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-network', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertNotIn('node', response['network'][0])
def test_11_getNodes_OpenRoadmTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertNotIn('node', response['network'][0])
def test_12_getNodes_OtnTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.get_ietf_network_request('otn-topology', 'config')
self.assertNotIn('node', response['network'][0])
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEPortMappingTesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('roadmd', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('roadmd', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(10)
def test_01_rdm_device_connection(self):
- response = test_utils_rfc8040.mount_device("ROADM-D1", ('roadmd', self.NODE_VERSION))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("ROADM-D1", ('roadmd', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_rdm_device_connected(self):
- response = test_utils_rfc8040.check_device_connection("ROADM-D1")
+ response = test_utils.check_device_connection("ROADM-D1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['connection-status'], 'connected')
time.sleep(10)
def test_03_rdm_portmapping_info(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-D1", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("ROADM-D1", "node-info", None)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(
{'node-type': 'rdm',
def test_04_rdm_deg1_lcp(self):
# pylint: disable=line-too-long
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-D1", "mc-capabilities", "DEG1-TTP")
+ response = test_utils.get_portmapping_node_attr("ROADM-D1", "mc-capabilities", "DEG1-TTP")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(response['mc-capabilities'],
[[{'mc-node-name': 'DEG1-TTP', 'center-freq-granularity': '6.25', 'slot-width-granularity': '12.5'}],
def test_05_rdm_deg2_lcp(self):
# pylint: disable=line-too-long
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-D1", "mc-capabilities", "DEG2-TTP")
+ response = test_utils.get_portmapping_node_attr("ROADM-D1", "mc-capabilities", "DEG2-TTP")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(response['mc-capabilities'],
[[{'mc-node-name': 'DEG2-TTP', 'center-freq-granularity': '6.25', 'slot-width-granularity': '12.5'}],
def test_06_rdm_srg1_lcp(self):
# pylint: disable=line-too-long
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-D1", "mc-capabilities", "SRG1-PP")
+ response = test_utils.get_portmapping_node_attr("ROADM-D1", "mc-capabilities", "SRG1-PP")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(response['mc-capabilities'],
[[{'mc-node-name': 'SRG1-PP', 'center-freq-granularity': '6.25', 'slot-width-granularity': '12.5'}],
# Renderer interface creations
def test_07_device_renderer(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'modulation-format': 'dp-qpsk',
# Get Degree MC interface and check
def test_08_degree_mc_interface(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADM-D1", "interface", "DEG1-TTP-TXRX-mc-749:763")
+ response = test_utils.check_node_attribute_request("ROADM-D1", "interface", "DEG1-TTP-TXRX-mc-749:763")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertDictEqual(
dict({"name": "DEG1-TTP-TXRX-mc-749:763",
# get DEG-NMC interface and check
def test_09_degree_nmc_interface(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADM-D1", "interface", "DEG1-TTP-TXRX-nmc-749:763")
+ response = test_utils.check_node_attribute_request("ROADM-D1", "interface", "DEG1-TTP-TXRX-nmc-749:763")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertDictEqual(
dict({"name": "DEG1-TTP-TXRX-nmc-749:763",
# get SRG-NMC interface
def test_10_srg_nmc_interface(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADM-D1", "interface", "SRG1-PP1-TXRX-nmc-749:763")
+ response = test_utils.check_node_attribute_request("ROADM-D1", "interface", "SRG1-PP1-TXRX-nmc-749:763")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(
dict({"name": "SRG1-PP1-TXRX-nmc-749:763",
# Create ROADM-connection
def test_11_roadm_connection(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"ROADM-D1", "roadm-connections", "SRG1-PP1-TXRX-DEG1-TTP-TXRX-749:763")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("SRG1-PP1-TXRX-DEG1-TTP-TXRX-749:763",
# delete ROADM connection
def test_12_delete_roadm_connection(self):
- response = test_utils_rfc8040.del_node_attribute_request(
+ response = test_utils.del_node_attribute_request(
"ROADM-D1", "roadm-connections", "SRG1-PP1-TXRX-DEG1-TTP-TXRX-749:763")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
time.sleep(3)
# Delete NMC SRG interface
def test_13_delete_srg_interface(self):
- response = test_utils_rfc8040.del_node_attribute_request("ROADM-D1", "interface", "SRG1-PP1-TXRX-nmc-749:763")
+ response = test_utils.del_node_attribute_request("ROADM-D1", "interface", "SRG1-PP1-TXRX-nmc-749:763")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
time.sleep(3)
# Delete NMC Degree interface
def test_14_delete_degree_interface(self):
- response = test_utils_rfc8040.del_node_attribute_request("ROADM-D1", "interface", "DEG1-TTP-TXRX-nmc-749:763")
+ response = test_utils.del_node_attribute_request("ROADM-D1", "interface", "DEG1-TTP-TXRX-nmc-749:763")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
time.sleep(3)
# Delete MC Degree interface
def test_15_delete_degree_interface(self):
- response = test_utils_rfc8040.del_node_attribute_request("ROADM-D1", "interface", "DEG1-TTP-TXRX-mc-749:763")
+ response = test_utils.del_node_attribute_request("ROADM-D1", "interface", "DEG1-TTP-TXRX-mc-749:763")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
time.sleep(3)
def test_16_disconnect_ROADM_D1(self):
- response = test_utils_rfc8040.unmount_device("ROADM-D1")
+ response = test_utils.unmount_device("ROADM-D1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCERendererTesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def test_01_rdm_device_connected(self):
- 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)
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_xpdr_device_connected(self):
- 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)
+ 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)
def test_03_rdm_portmapping(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", None, None)
+ response = test_utils.get_portmapping_node_attr("ROADM-A1", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supporting-port': 'L1', 'supporting-circuit-pack-name': '1/0',
response['nodes'][0]['mapping'])
def test_04_xpdr_portmapping(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A1", None, None)
+ response = test_utils.get_portmapping_node_attr("XPDR-A1", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supported-interface-capability': ['org-openroadm-port-types:if-OCH'],
response['nodes'][0]['mapping'])
def test_05_service_path_create(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'service_test',
self.assertIn('Interfaces created successfully for nodes: ROADM-A1', response['output']['result'])
def test_06_service_path_create_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADM-A1", "interface", "DEG1-TTP-TXRX-nmc-713:720")
+ response = test_utils.check_node_attribute_request("ROADM-A1", "interface", "DEG1-TTP-TXRX-nmc-713:720")
self.assertEqual(response['status_code'], requests.codes.ok)
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
self.assertEqual(float(nmcctp['width']), 40)
def test_07_service_path_create_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADM-A1", "interface", "DEG1-TTP-TXRX-mc-713:720")
+ response = test_utils.check_node_attribute_request("ROADM-A1", "interface", "DEG1-TTP-TXRX-mc-713:720")
self.assertEqual(response['status_code'], requests.codes.ok)
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
self.assertEqual(float(mcttp['max-freq']), 195.825)
def test_08_service_path_create_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADM-A1", "interface", "SRG1-PP3-TXRX-nmc-713:720")
+ response = test_utils.check_node_attribute_request("ROADM-A1", "interface", "SRG1-PP3-TXRX-nmc-713:720")
self.assertEqual(response['status_code'], requests.codes.ok)
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
# -mc supporting interfaces must not be created for SRG, only degrees
def test_09_service_path_create_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADM-A1", "interface", "SRG1-PP3-TXRX-mc-713:720")
+ response = test_utils.check_node_attribute_request("ROADM-A1", "interface", "SRG1-PP3-TXRX-mc-713:720")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_10_service_path_create_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"ROADM-A1", "roadm-connections", "SRG1-PP3-TXRX-DEG1-TTP-TXRX-713:720")
self.assertEqual(response['status_code'], requests.codes.ok)
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual({'dst-if': 'DEG1-TTP-TXRX-nmc-713:720'}, response['roadm-connections'][0]['destination'])
def test_11_service_path_create_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-NETWORK1-713:720")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-NETWORK1-713:720")
self.assertEqual(response['status_code'], requests.codes.ok)
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
self.assertEqual(float(intf['transmit-power']), -5)
def test_12_service_path_create_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-NETWORK1-OTU")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-NETWORK1-OTU")
self.assertEqual(response['status_code'], requests.codes.ok)
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
response['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
def test_13_service_path_create_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-NETWORK1-ODU4")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-NETWORK1-ODU4")
self.assertEqual(response['status_code'], requests.codes.ok)
# the 2 following statements replace self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_14_service_path_create_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-CLIENT1-ETHERNET")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-CLIENT1-ETHERNET")
self.assertEqual(response['status_code'], requests.codes.ok)
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
def test_15_service_path_create_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "circuit-packs", "1%2F0%2F1-PLUG-NET")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "circuit-packs", "1%2F0%2F1-PLUG-NET")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('not-reserved-inuse', response['circuit-packs'][0]['equipment-state'])
# FIXME: https://jira.opendaylight.org/browse/TRNSPRTPCE-591
def test_16_service_path_create_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "circuit-packs", "1%2F0%2F1-PLUG-CLIENT")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "circuit-packs", "1%2F0%2F1-PLUG-CLIENT")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('not-reserved-inuse', response['circuit-packs'][0]['equipment-state'])
# FIXME: https://jira.opendaylight.org/browse/TRNSPRTPCE-591
def test_17_service_path_delete(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'service_test',
self.assertDictEqual(response['output'], {'result': 'Request processed', 'success': True})
def test_18_service_path_delete_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADM-A1", "interface", "DEG1-TTP-TXRX-mc-713:720")
+ response = test_utils.check_node_attribute_request("ROADM-A1", "interface", "DEG1-TTP-TXRX-mc-713:720")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_19_service_path_delete_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADM-A1", "interface", "DEG1-TTP-TXRX-nmc-713:720")
+ response = test_utils.check_node_attribute_request("ROADM-A1", "interface", "DEG1-TTP-TXRX-nmc-713:720")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_20_service_path_delete_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADM-A1", "interface", "SRG1-PP3-TXRX-mc-713:720")
+ response = test_utils.check_node_attribute_request("ROADM-A1", "interface", "SRG1-PP3-TXRX-mc-713:720")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_21_service_path_delete_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("ROADM-A1", "interface", "SRG1-PP3-TXRX-nmc-713:720")
+ response = test_utils.check_node_attribute_request("ROADM-A1", "interface", "SRG1-PP3-TXRX-nmc-713:720")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_22_service_path_delete_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"ROADM-A1", "interface", "SRG1-PP3-TXRX-DEG1-TTP-TXRX-713:720")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_23_service_path_delete_rdm_check(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"ROADM-A1", "roadm-connections", "SRG1-PP3-TXRX-DEG1-TTP-TXRX-713:720")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_24_service_path_delete_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-NETWORK1-713:720")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-NETWORK1-713:720")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_25_service_path_delete_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-NETWORK1-OTU")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-NETWORK1-OTU")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_26_service_path_delete_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-NETWORK1-ODU")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-NETWORK1-ODU")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_27_service_path_delete_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-CLIENT1-ETHERNET")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "interface", "XPDR1-CLIENT1-ETHERNET")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_28_service_path_delete_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "circuit-packs", "1%2F0%2F1-PLUG-NET")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "circuit-packs", "1%2F0%2F1-PLUG-NET")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual('not-reserved-available', response["circuit-packs"][0]['equipment-state'])
def test_29_service_path_delete_xpdr_check(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "circuit-packs", "1%2F0%2F1-PLUG-CLIENT")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "circuit-packs", "1%2F0%2F1-PLUG-CLIENT")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual('not-reserved-available', response["circuit-packs"][0]['equipment-state'])
def test_30_rdm_device_disconnected(self):
- response = test_utils_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_31_xpdr_device_disconnected(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A1")
+ response = test_utils.unmount_device("XPDR-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEtesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('spdra', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('spdra', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(5)
def test_01_connect_SPDR_SA1(self):
- response = test_utils_rfc8040.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
time.sleep(10)
- response = test_utils_rfc8040.check_device_connection("SPDR-SA1")
+ response = test_utils.check_device_connection("SPDR-SA1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['connection-status'], 'connected')
def test_02_get_portmapping_CLIENT4(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR1-CLIENT4")
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR1-CLIENT4")
self.assertEqual(response['status_code'], requests.codes.ok)
res_mapping = response['mapping'][0]
self.assertEqual('CP1-SFP4-P1', res_mapping['supporting-port'])
self.assertIn('org-openroadm-port-types:if-10GE', res_mapping['supported-interface-capability'])
def test_03_get_portmapping_NETWORK1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR1-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR1-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
self.NETWORK1_CHECK_DICT,
response['mapping'])
def test_04_service_path_create_OCH_OTU4(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'service_test',
'och-interface-id': ['XPDR1-NETWORK1-761:768']}, response['output']['node-interface'])
def test_05_get_portmapping_NETWORK1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR1-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR1-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.NETWORK1_CHECK_DICT["supporting-otu4"] = "XPDR1-NETWORK1-OTU"
self.assertIn(
response['mapping'])
def test_06_check_interface_och(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-761:768")
+ response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-761:768")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertDictEqual(dict(response['interface'][0], **{'name': 'XPDR1-NETWORK1-761:768',
self.assertEqual(float(intf['transmit-power']), -5)
def test_07_check_interface_OTU(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-OTU")
+ response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-OTU")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
'administrative-state': 'inService',
response['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
def test_08_otn_service_path_create_ODU4(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'otn-service-path',
{
'service-name': 'service_ODU4',
'odu-interface-id': ['XPDR1-NETWORK1-ODU4']}, response['output']['node-interface'])
def test_09_get_portmapping_NETWORK1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR1-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("SPDR-SA1", "mapping", "XPDR1-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.NETWORK1_CHECK_DICT["supporting-odu4"] = "XPDR1-NETWORK1-ODU4"
self.NETWORK1_CHECK_DICT["supporting-otu4"] = "XPDR1-NETWORK1-OTU"
response['mapping'])
def test_10_check_interface_ODU4(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-ODU4")
+ response = test_utils.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', 'supporting-interface': 'XPDR1-NETWORK1-OTU',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_11_otn_service_path_create_10GE(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'otn-service-path',
{
'service-name': 'service1',
self.assertIn('XPDR1-CLIENT4-ODU2e', response['output']['node-interface'][0]['odu-interface-id'])
def test_12_check_interface_10GE_CLIENT(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-CLIENT4-ETHERNET10G")
+ response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-CLIENT4-ETHERNET10G")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict = {'name': 'XPDR1-CLIENT4-ETHERNET10G',
'administrative-state': 'inService',
self.assertEqual(10000, response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'])
def test_13_check_interface_ODU2E_CLIENT(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"SPDR-SA1", "interface", "XPDR1-CLIENT4-ODU2e")
self.assertEqual(response['status_code'], requests.codes.ok)
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_14_check_interface_ODU2E_NETWORK(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
'parent-odu-allocation']['trib-slots'])
def test_15_check_ODU2E_connection(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"SPDR-SA1", "odu-connection", "XPDR1-CLIENT4-ODU2e-x-XPDR1-NETWORK1-ODU2e")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {
response['odu-connection'][0]['source'])
def test_16_otn_service_path_delete_10GE(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'otn-service-path',
{
'service-name': 'service1',
self.assertTrue(response['output']['success'])
def test_17_check_no_ODU2E_connection(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"SPDR-SA1", "odu-connection", "XPDR1-CLIENT4-ODU2e-x-XPDR1-NETWORK1-ODU2e")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_18_check_no_interface_ODU2E_NETWORK(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"SPDR-SA1", "interface", "XPDR1-NETWORK1-ODU2e")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_19_check_no_interface_ODU2E_CLIENT(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"SPDR-SA1", "interface", "XPDR1-CLIENT4-ODU2e")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_20_check_no_interface_10GE_CLIENT(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-CLIENT4-ETHERNET10G")
+ response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-CLIENT4-ETHERNET10G")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_21_otn_service_path_delete_ODU4(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'otn-service-path',
{
'service-name': 'service_ODU4',
self.assertTrue(response['output']['success'])
def test_22_check_no_interface_ODU4(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-ODU4")
+ response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-ODU4")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_23_service_path_delete_OCH_OTU4(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'service_test',
self.assertTrue(response['output']['success'])
def test_24_check_no_interface_OTU4(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-OTU")
+ response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-OTU")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_25_check_no_interface_OCH(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-1")
+ response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-1")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_26_disconnect_SPDR_SA1(self):
- response = test_utils_rfc8040.unmount_device("SPDR-SA1")
+ response = test_utils.unmount_device("SPDR-SA1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEtesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('spdra', cls.NODE_VERSION),
- ('spdrc', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('spdra', cls.NODE_VERSION),
+ ('spdrc', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(5)
def test_01_connect_SPDR_SA1(self):
- response = test_utils_rfc8040.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
+ response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
self.assertEqual(response.status_code, requests.codes.created,
- test_utils_rfc8040.CODE_SHOULD_BE_201)
+ test_utils.CODE_SHOULD_BE_201)
time.sleep(10)
- response = test_utils_rfc8040.check_device_connection("SPDR-SA1")
+ response = test_utils.check_device_connection("SPDR-SA1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['connection-status'], 'connected')
def test_02_connect_SPDR_SC1(self):
- response = test_utils_rfc8040.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
+ response = test_utils.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
self.assertEqual(response.status_code, requests.codes.created,
- test_utils_rfc8040.CODE_SHOULD_BE_201)
+ test_utils.CODE_SHOULD_BE_201)
time.sleep(10)
- response = test_utils_rfc8040.check_device_connection("SPDR-SC1")
+ response = test_utils.check_device_connection("SPDR-SC1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['connection-status'], 'connected')
def test_03_service_create_OTU4(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-renderer', 'service-implementation-request',
{
'service-name': 'SPDRA-SPDRC-OTU4-ODU4',
# Test OCH-OTU interfaces on SPDR-A1
def test_04_check_interface_och(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-761:768")
+ response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-761:768")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-761:768',
'administrative-state': 'inService',
self.assertEqual(float(intf['transmit-power']), -5)
def test_05_check_interface_OTU(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-OTU")
+ response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-OTU")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
'administrative-state': 'inService',
# Test OCH-OTU interfaces on SPDR-C1
def test_06_check_interface_och(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-761:768")
+ response = test_utils.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-761:768")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
'administrative-state': 'inService',
self.assertEqual(float(intf['transmit-power']), -5)
def test_07_check_interface_OTU(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-OTU")
+ response = test_utils.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-OTU")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
'administrative-state': 'inService',
# Test creation of ODU4 service
def test_08_service_create_ODU4(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-renderer', 'service-implementation-request',
{
'service-name':
# Test ODU4 interfaces on SPDR-A1 and SPDR-C1
def test_09_check_interface_ODU4(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-ODU4")
+ response = test_utils.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',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_10_check_interface_ODU4(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-ODU4")
+ response = test_utils.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',
# Test creation of 10G service
def test_11_service_create_10GE(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-renderer', 'service-implementation-request',
{
'service-name': 'SPDRA-SPDRC-10G',
# Test the interfaces on SPDR-A1
def test_12_check_interface_10GE_CLIENT(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-CLIENT1-ETHERNET10G")
+ response = test_utils.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',
self.assertEqual(response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'], 10000)
def test_13_check_interface_ODU2E_CLIENT(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_14_check_ODU2E_connection(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"SPDR-SA1",
"odu-connection", "XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e")
self.assertEqual(response['status_code'], requests.codes.ok)
response['odu-connection'][0]['source'])
def test_15_check_interface_ODU2E_NETWORK(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
# Test the interfaces on SPDR-C1
def test_16_check_interface_ODU2E_NETWORK(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
'parent-odu-allocation']['trib-slots'])
def test_17_check_interface_10GE_CLIENT(self):
- response = test_utils_rfc8040.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-CLIENT1-ETHERNET10G")
+ response = test_utils.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',
self.assertEqual(response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'], 10000)
def test_18_check_interface_ODU2E_CLIENT(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_19_check_ODU2E_connection(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"SPDR-SC1",
"odu-connection", "XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e")
self.assertEqual(response['status_code'], requests.codes.ok)
response['odu-connection'][0]['source'])
def test_20_check_interface_ODU2E_NETWORK(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
# TODO: Delete interfaces (SPDR-A1, SPDR-C1)
def test_21_disconnect_SPDR_SA1(self):
- response = test_utils_rfc8040.unmount_device("SPDR-SA1")
+ response = test_utils.unmount_device("SPDR-SA1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_22_disconnect_SPDR_SC1(self):
- response = test_utils_rfc8040.unmount_device("SPDR-SC1")
+ response = test_utils.unmount_device("SPDR-SC1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportOlmTesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- 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)])
+ 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)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(1)
def test_01_xpdrA_device_connected(self):
- 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)
+ 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)
def test_02_xpdrC_device_connected(self):
- 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)
+ 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)
def test_03_rdmA_device_connected(self):
- 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)
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_04_rdmC_device_connected(self):
- 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)
+ response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_05_connect_xprdA_to_roadmA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_06_connect_roadmA_to_xpdrA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_07_connect_xprdC_to_roadmC(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_08_connect_roadmC_to_xpdrC(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_09_create_OTS_ROADMA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADM-A1',
self.assertEqual(response['status_code'], requests.codes.ok)
def test_10_create_OTS_ROADMC(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADM-C1',
self.assertEqual(response['status_code'], requests.codes.ok)
def test_11_get_PM_ROADMA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'get-pm',
{
'node-id': 'ROADM-A1',
}, response['output']['measurements'])
def test_12_get_PM_ROADMC(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'get-pm',
{
'node-id': 'ROADM-C1',
}, response['output']['measurements'])
def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'calculate-spanloss-base',
{
'src-type': 'link',
time.sleep(5)
def test_14_calculate_span_loss_base_all(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'calculate-spanloss-base',
{
'src-type': 'all'
time.sleep(5)
def test_15_get_OTS_DEG2_TTP_TXRX_ROADMA(self):
- response = test_utils_rfc8040.check_node_attribute2_request(
+ response = test_utils.check_node_attribute2_request(
'ROADM-A1', 'interface', 'OTS-DEG2-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 17.6)
self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 25.7)
def test_16_get_OTS_DEG1_TTP_TXRX_ROADMC(self):
- response = test_utils_rfc8040.check_node_attribute2_request(
+ response = test_utils.check_node_attribute2_request(
'ROADM-C1', 'interface', 'OTS-DEG1-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 25.7)
self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 17.6)
def test_17_servicePath_create_AToZ(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'test',
time.sleep(10)
def test_18_servicePath_create_ZToA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'test',
time.sleep(10)
def test_19_service_power_setup_XPDRA_XPDRC(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'service-power-setup',
{
'service-name': 'test',
self.assertIn('Success', response['output']['result'])
def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
- response = test_utils_rfc8040.check_node_attribute2_request(
+ response = test_utils.check_node_attribute2_request(
'XPDR-A1', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['frequency']), 196.1)
def test_21_get_roadmconnection_ROADMA(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'ROADM-A1', 'roadm-connections', 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), 0.21)
def test_22_get_roadmconnection_ROADMC(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'ROADM-C1', 'roadm-connections', 'DEG1-TTP-TXRX-SRG1-PP1-TXRX-761:768')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("power", response['roadm-connections'][0]['opticalControlMode'])
def test_23_service_power_setup_XPDRC_XPDRA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'service-power-setup',
{
'service-name': 'test',
self.assertIn('Success', response['output']['result'])
def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
- response = test_utils_rfc8040.check_node_attribute2_request(
+ response = test_utils.check_node_attribute2_request(
'XPDR-C1', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['frequency']), 196.1)
def test_25_get_roadmconnection_ROADMC(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'ROADM-C1', 'roadm-connections', 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), 2.0)
def test_26_service_power_turndown_XPDRA_XPDRC(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'service-power-turndown',
{
'service-name': 'test',
self.assertIn('Success', response['output']['result'])
def test_27_get_roadmconnection_ROADMA(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'ROADM-A1', 'roadm-connections', 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -60)
def test_28_get_roadmconnection_ROADMC(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'ROADM-C1', 'roadm-connections', 'DEG1-TTP-TXRX-SRG1-PP1-TXRX-761:768')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
def test_29_servicePath_delete_AToZ(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'test',
time.sleep(10)
def test_30_servicePath_delete_ZToA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'test',
#"""to test case where SRG where the xpdr is connected to has no optical range data"""
def test_31_connect_xprdA_to_roadmA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_32_connect_roadmA_to_xpdrA(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_33_servicePath_create_AToZ(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'test2',
time.sleep(10)
def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
- response = test_utils_rfc8040.check_node_attribute2_request(
+ response = test_utils.check_node_attribute2_request(
'XPDR-A1', 'interface', 'XPDR1-NETWORK2-753:760', 'org-openroadm-optical-channel-interfaces:och')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
# self.assertEqual(2, response['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
def test_35_servicePath_delete_AToZ(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'test2',
time.sleep(10)
def test_36_xpdrA_device_disconnected(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A1")
+ response = test_utils.unmount_device("XPDR-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_37_xpdrC_device_disconnected(self):
- response = test_utils_rfc8040.unmount_device("XPDR-C1")
+ response = test_utils.unmount_device("XPDR-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_38_calculate_span_loss_current(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'calculate-spanloss-current',
None)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(5)
def test_39_rdmA_device_disconnected(self):
- response = test_utils_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_40_rdmC_device_disconnected(self):
- response = test_utils_rfc8040.unmount_device("ROADM-C1")
+ response = test_utils.unmount_device("ROADM-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEtesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('spdra', cls.NODE_VERSION),
- ('roadma', cls.NODE_VERSION),
- ('roadmc', cls.NODE_VERSION),
- ('spdrc', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('spdra', cls.NODE_VERSION),
+ ('roadma', cls.NODE_VERSION),
+ ('roadmc', cls.NODE_VERSION),
+ ('spdrc', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(5)
def test_01_connect_spdrA(self):
- response = test_utils_rfc8040.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
+ response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_connect_spdrC(self):
- response = test_utils_rfc8040.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
+ response = test_utils.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_connect_rdmA(self):
- response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_04_connect_rdmC(self):
- response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
+ response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_05_connect_sprdA_1_N1_to_roadmA_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_06_connect_roadmA_PP1_to_spdrA_1_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_07_connect_sprdC_1_N1_to_roadmC_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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)
def test_08_connect_roadmC_PP1_to_spdrC_1_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.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 OCH-OTU4 service from spdr to spdr
def test_11_check_otn_topology(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.get_ietf_network_request('otn-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 6)
self.assertNotIn('ietf-network-topology:link', response['network'][0])
def test_12_create_OCH_OTU4_service(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_13_get_OCH_OTU4_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request(
+ response = test_utils.get_ordm_serv_list_attr_request(
"services", "service1-OCH-OTU4")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(
# Check correct configuration of devices
def test_14_check_interface_och_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-761:768')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-761:768',
float(response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['transmit-power']))
def test_15_check_interface_OTU4_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-OTU')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
response['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
def test_16_check_interface_och_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-761:768')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-761:768',
float(response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['transmit-power']))
def test_17_check_interface_OTU4_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-OTU')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
response['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
def test_18_check_no_interface_ODU4_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU4')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_19_check_openroadm_topo_spdra(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'SPDR-SA1-XPDR1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'SPDR-SA1-XPDR1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
ele = response['node']['ietf-network-topology:termination-point'][0]
self.assertEqual('XPDR1-NETWORK1', ele['tp-id'])
float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['width']))
def test_20_check_openroadm_topo_ROADMA_SRG(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
self.assertNotIn('avail-freq-maps', dict.keys(ele))
def test_21_check_openroadm_topo_ROADMA_DEG(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
def test_22_check_otn_topo_otu4_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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-SC1-XPDR1-XPDR1-NETWORK1',
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"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_24_get_ODU4_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request(
+ response = test_utils.get_ordm_serv_list_attr_request(
"services", "service1-ODU4")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(
response['services'][0]['lifecycle-state'], 'planned')
def test_25_check_interface_ODU4_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_26_check_interface_ODU4_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_27_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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.fail("this link should not exist")
def test_28_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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'] in ('SPDR-SA1-XPDR1', 'SPDR-SC1-XPDR1'):
self.cr_serv_input_data["service-z-end"]["ethernet-encoding"] = "10GBASE-R"
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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_30_get_10GE_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request(
+ response = test_utils.get_ordm_serv_list_attr_request(
"services", "service1-10GE")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(
response['services'][0]['lifecycle-state'], 'planned')
def test_31_check_interface_10GE_CLIENT_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR1-CLIENT1-ETHERNET10G')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'])
def test_32_check_interface_ODU2E_CLIENT_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_33_check_interface_ODU2E_NETWORK_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
['trib-slots'])
def test_34_check_ODU2E_connection_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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 = {
response['odu-connection'][0]['source'])
def test_35_check_interface_10GE_CLIENT_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SC1', 'interface', 'XPDR1-CLIENT1-ETHERNET10G')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'])
def test_36_check_interface_ODU2E_CLIENT_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_37_check_interface_ODU2E_NETWORK_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
'parent-odu-allocation']['trib-slots'])
def test_38_check_ODU2E_connection_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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 = {
response['odu-connection'][0]['source'])
def test_39_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
link['org-openroadm-otn-network-topology:used-bandwidth'], 10000)
def test_40_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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'] in ('SPDR-SA1-XPDR1', 'SPDR-SC1-XPDR1'):
def test_41_delete_10GE_service(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1-10GE"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_42_check_service_list(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['service-list']['services']), 2)
def test_43_check_no_ODU2e_connection_spdra(self):
- response = test_utils_rfc8040.check_node_request("SPDR-SA1")
+ response = test_utils.check_node_request("SPDR-SA1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertNotIn(['odu-connection'][0], response['org-openroadm-device'])
def test_44_check_no_interface_ODU2E_NETWORK_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU2e-service1')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_45_check_no_interface_ODU2E_CLIENT_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR1-CLIENT1-ODU2e-service1')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_46_check_no_interface_10GE_CLIENT_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR1-CLIENT1-ETHERNET10G')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_47_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
def test_48_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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'] in ('SPDR-SA1-XPDR1', 'SPDR-SC1-XPDR1'):
def test_49_delete_ODU4_service(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1-ODU4"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_50_check_service_list(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['service-list']['services']), 1)
def test_51_check_no_interface_ODU4_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU4')
self.assertEqual(response['status_code'], requests.codes.conflict)
self.test_22_check_otn_topo_otu4_links()
def test_53_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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'] in ('SPDR-SA1-XPDR1', 'SPDR-SC1-XPDR1'):
def test_54_delete_OCH_OTU4_service(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1-OCH-OTU4"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_55_get_no_service(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_56_check_no_interface_OTU4_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-OTU')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_57_check_no_interface_OCH_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-1')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_58_getLinks_OtnTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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_59_check_openroadm_topo_spdra(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'SPDR-SA1-XPDR1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'SPDR-SA1-XPDR1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
tp = response['node']['ietf-network-topology:termination-point'][0]
self.assertEqual('XPDR1-NETWORK1', tp['tp-id'])
tp['org-openroadm-network-topology:xpdr-network-attributes']))
def test_60_check_openroadm_topo_ROADMA_SRG(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(3)
def test_61_check_openroadm_topo_ROADMA_DEG(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(3)
def test_62_connect_sprdA_3_N1_to_roadmA_PP2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-xpdr-rdm-links',
{'links-input': {'xpdr-node': 'SPDR-SA1', 'xpdr-num': '3', 'network-num': '1',
'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
self.assertEqual(response['status_code'], requests.codes.ok)
def test_63_connect_roadmA_PP2_to_spdrA_3_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-rdm-xpdr-links',
{'links-input': {'xpdr-node': 'SPDR-SA1', 'xpdr-num': '3', 'network-num': '1',
'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
self.assertEqual(response['status_code'], requests.codes.ok)
def test_64_connect_sprdC_3_N1_to_roadmC_PP2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-xpdr-rdm-links',
{'links-input': {'xpdr-node': 'SPDR-SC1', 'xpdr-num': '3', 'network-num': '1',
'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
self.assertEqual(response['status_code'], requests.codes.ok)
def test_65_connect_roadmC_PP2_to_spdrC_3_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-rdm-xpdr-links',
{'links-input': {'xpdr-node': 'SPDR-SC1', 'xpdr-num': '3', 'network-num': '1',
'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR3"
self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR3-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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_67_get_OCH_OTU4_service2(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request(
+ response = test_utils.get_ordm_serv_list_attr_request(
"services", "service2-OCH-OTU4")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(
self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR3"
self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR3-NETWORK1"
del self.cr_serv_input_data["service-z-end"]["otu-service-rate"]
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_69_get_ODU4_service2(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request(
+ response = test_utils.get_ordm_serv_list_attr_request(
"services", "service2-ODU4")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(
self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR3-CLIENT1"
self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR3"
self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR3-CLIENT1"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_71_get_1GE_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request(
+ response = test_utils.get_ordm_serv_list_attr_request(
"services", "service1-1GE")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(
response['services'][0]['lifecycle-state'], 'planned')
def test_72_check_interface_1GE_CLIENT_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR3-CLIENT1-ETHERNET1G')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict = {'name': 'XPDR3-CLIENT1-ETHERNET1G',
response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'])
def test_73_check_interface_ODU0_CLIENT_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR3-CLIENT1-ODU0')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR3-CLIENT1-ODU0',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_74_check_interface_ODU0_NETWORK_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR3-NETWORK1-ODU0')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR3-NETWORK1-ODU0',
['trib-slots'])
def test_75_check_ODU0_connection_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'odu-connection', 'XPDR3-CLIENT1-ODU0-x-XPDR3-NETWORK1-ODU0')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {
response['odu-connection'][0]['source'])
def test_76_check_interface_1GE_CLIENT_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SC1', 'interface', 'XPDR3-CLIENT1-ETHERNET1G')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict = {'name': 'XPDR3-CLIENT1-ETHERNET1G',
response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'])
def test_77_check_interface_ODU0_CLIENT_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SC1', 'interface', 'XPDR3-CLIENT1-ODU0')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR3-CLIENT1-ODU0',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_78_check_interface_ODU0_NETWORK_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SC1', 'interface', 'XPDR3-NETWORK1-ODU0')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR3-NETWORK1-ODU0',
'parent-odu-allocation']['trib-slots'])
def test_79_check_ODU0_connection_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SC1', 'odu-connection', 'XPDR3-CLIENT1-ODU0-x-XPDR3-NETWORK1-ODU0')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {
response['odu-connection'][0]['source'])
def test_80_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
link['org-openroadm-otn-network-topology:used-bandwidth'], 1000)
def test_81_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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'] in ('SPDR-SA1-XPDR3', 'SPDR-SC1-XPDR3'):
def test_82_delete_1GE_service(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1-1GE"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_83_check_service_list(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['service-list']['services']), 2)
def test_84_check_no_ODU0_connection_spdra(self):
- response = test_utils_rfc8040.check_node_request("SPDR-SA1")
+ response = test_utils.check_node_request("SPDR-SA1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertNotIn(['odu-connection'][0], response['org-openroadm-device'])
def test_85_check_no_interface_ODU0_NETWORK_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR3-NETWORK1-ODU0-service1')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_86_check_no_interface_ODU0_CLIENT_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR3-CLIENT1-ODU0-service1')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_87_check_no_interface_10GE_CLIENT_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR3-CLIENT1-ETHERNET1G')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_88_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
def test_89_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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'] in ('SPDR-SA1-XPDR3', 'SPDR-SC1-XPDR3'):
def test_90_delete_ODU4_service(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service2-ODU4"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_91_delete_OCH_OTU4_service(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service2-OCH-OTU4"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_92_disconnect_xponders_from_roadm(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.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'):
- response = test_utils_rfc8040.del_ietf_network_link_request(
+ response = test_utils.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_93_check_openroadm_topology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(18,
len(response['network'][0]['ietf-network-topology:link']),
'Topology should contain 18 links')
def test_94_disconnect_spdrA(self):
- response = test_utils_rfc8040.unmount_device("SPDR-SA1")
+ response = test_utils.unmount_device("SPDR-SA1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_95_disconnect_spdrC(self):
- response = test_utils_rfc8040.unmount_device("SPDR-SC1")
+ response = test_utils.unmount_device("SPDR-SC1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_96_disconnect_roadmA(self):
- response = test_utils_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_97_disconnect_roadmC(self):
- response = test_utils_rfc8040.unmount_device("ROADM-C1")
+ response = test_utils.unmount_device("ROADM-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEFulltesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- 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)])
+ 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)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self): # instruction executed before each test method
print("execution of {}".format(self.id().split(".")[-1]))
def test_01_connect_xpdrA(self):
- 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)
+ 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)
def test_02_connect_xpdrC(self):
- 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)
+ 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)
def test_03_connect_rdmA(self):
- 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)
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_04_connect_rdmC(self):
- 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)
+ response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_07_connect_xprdC_xpdr1_N1_to_roadmC_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_08_connect_roadmC_PP1_to_xpdrC_xprd1_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_09_connect_xprdA_N2_to_roadmA_PP2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_10_connect_roadmA_PP2_to_xpdrA_N2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_11_connect_xprdC_xpdr2_N1_to_roadmC_PP2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_12_connect_roadmC_PP2_to_xpdrC_xpdr2_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX",
- data)
+ response = test_utils.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):
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX",
- data)
+ response = test_utils.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_input_data["service-name"] = "service2"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_16_get_eth_service2(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service2")
+ response = test_utils.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')
time.sleep(1)
def test_17_check_xc1_ROADMA(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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
time.sleep(1)
def test_18_check_xc1_ROADMC(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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
time.sleep(1)
def test_19_check_topo_XPDRA(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDR-A1-XPDR1', 'config')
+ response = test_utils.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:
time.sleep(1)
def test_20_check_topo_ROADMA_SRG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_21_check_topo_ROADMA_DEG2(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_23_get_eth_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1")
+ response = test_utils.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')
time.sleep(1)
def test_24_check_xc1_ROADMA(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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
time.sleep(1)
def test_25_check_topo_XPDRA(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDR-A1-XPDR1', 'config')
+ response = test_utils.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:
time.sleep(1)
def test_26_check_topo_ROADMA_SRG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_27_check_topo_ROADMA_DEG2(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
# creation service test on a non-available resource
def test_28_create_eth_service3(self):
self.cr_serv_input_data["service-name"] = "service3"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
# add a test that check the openroadm-service-list still only contains 2 elements
def test_29_delete_eth_service3(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service3"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_30_delete_eth_service1(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_31_delete_eth_service2(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service2"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_32_check_no_xc_ROADMA(self):
- response = test_utils_rfc8040.check_node_request("ROADM-A1")
+ response = test_utils.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_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDR-A1-XPDR1', 'config')
+ response = test_utils.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:
time.sleep(1)
def test_34_check_topo_ROADMA_SRG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_35_check_topo_ROADMA_DEG2(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_37_get_oc_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1")
+ response = test_utils.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')
time.sleep(1)
def test_38_check_xc1_ROADMA(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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
time.sleep(1)
def test_39_check_xc1_ROADMC(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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.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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_41_get_oc_service2(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service2")
+ response = test_utils.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')
time.sleep(1)
def test_42_check_xc2_ROADMA(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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
time.sleep(1)
def test_43_check_topo_ROADMA(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
def test_44_delete_oc_service1(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_45_delete_oc_service2(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service2"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_46_get_no_oc_services(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['service-list'], (
{
time.sleep(1)
def test_47_get_no_xc_ROADMA(self):
- response = test_utils_rfc8040.check_node_request("ROADM-A1")
+ response = test_utils.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)
self.test_44_delete_oc_service1()
def test_50_loop_create_eth_service(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1")
+ response = test_utils.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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
time.sleep(5)
self.test_31_delete_eth_service2()
def test_51_disconnect_XPDRA(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A1")
+ response = test_utils.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_rfc8040.unmount_device("XPDR-C1")
+ response = test_utils.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_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.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_rfc8040.unmount_device("ROADM-C1")
+ response = test_utils.unmount_device("ROADM-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEtesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- 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)])
+ 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)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(2)
def test_001_connect_spdrA(self):
- response = test_utils_rfc8040.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
+ response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_002_connect_spdrB(self):
- response = test_utils_rfc8040.mount_device("SPDR-SB1", ('spdrb', self.NODE_VERSION))
+ response = test_utils.mount_device("SPDR-SB1", ('spdrb', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_003_connect_spdrC(self):
- response = test_utils_rfc8040.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
+ response = test_utils.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_004_connect_rdmA(self):
- response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_005_connect_rdmB(self):
- response = test_utils_rfc8040.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION))
+ response = test_utils.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_006_connect_rdmC(self):
- response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
+ response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_007_connect_sprdA_2_N1_to_roadmA_PP3(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_008_connect_roadmA_PP3_to_spdrA_2_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_009_connect_sprdC_2_N1_to_roadmC_PP3(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_010_connect_roadmC_PP3_to_spdrC_2_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_011_connect_sprdB_2_N1_to_roadmB_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_012_connect_roadmB_PP1_to_spdrB_2_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_013_connect_sprdB_2_N2_to_roadmB_PP2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_014_connect_roadmB_PP2_to_spdrB_2_N2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX",
- data)
+ response = test_utils.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):
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX",
- data)
+ response = test_utils.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):
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX",
- data)
+ response = test_utils.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):
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX",
- data)
+ response = test_utils.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_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADM-A1',
response["output"]["result"])
def test_020_create_OTS_ROADMB_DEG1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADM-B1',
response["output"]["result"])
def test_021_create_OTS_ROADMB_DEG2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADM-B1',
response["output"]["result"])
def test_022_create_OTS_ROADMC_DEG2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADM-C1',
response["output"]["result"])
def test_023_calculate_span_loss_base_all(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'calculate-spanloss-base',
{
'src-type': 'all'
time.sleep(5)
def test_024_check_otn_topology(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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],
# test service-create for OCH-OTU4 service from spdrA to spdrB
def test_025_create_OCH_OTU4_service_AB(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_026_get_OCH_OTU4_service_AB(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-OCH-OTU4-AB")
+ response = test_utils.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')
# Check correct configuration of devices
def test_027_check_interface_och_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
float(response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['transmit-power']))
def test_028_check_interface_OTU4_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
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(
+ response2 = test_utils.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-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-dapi'])
def test_029_check_interface_och_spdrB(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
float(response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['transmit-power']))
def test_030_check_interface_OTU4_spdrB(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
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(
+ response2 = test_utils.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-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-dapi'])
def test_031_check_no_interface_ODU4_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR2-NETWORK1-ODU4')
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['interface'], (
}))
def test_032_check_openroadm_topo_spdra(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'SPDR-SA1-XPDR2', 'config')
+ response = test_utils.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'])
time.sleep(1)
def test_033_check_openroadm_topo_ROADMA_SRG(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_034_check_openroadm_topo_ROADMA_DEG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_035_check_otn_topo_otu4_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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',
# test service-create for OCH-OTU4 service from spdrB to spdrC
-
def test_036_create_OCH_OTU4_service_BC(self):
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-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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_037_get_OCH_OTU4_service_BC(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-OCH-OTU4-BC")
+ response = test_utils.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')
# Check correct configuration of devices
def test_038_check_interface_och_spdrB(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
float(response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['transmit-power']))
def test_039_check_interface_OTU4_spdrB(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
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(
+ response2 = test_utils.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-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-dapi'])
def test_040_check_interface_och_spdrC(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
float(response['interface'][0]['org-openroadm-optical-channel-interfaces:och']['transmit-power']))
def test_041_check_interface_OTU4_spdrC(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
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(
+ response2 = test_utils.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-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-dapi'])
def test_042_check_no_interface_ODU4_spdrB(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU4')
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['interface'], (
}))
def test_043_check_openroadm_topo_spdrB(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'SPDR-SB1-XPDR2', 'config')
+ response = test_utils.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
time.sleep(1)
def test_044_check_openroadm_topo_ROADMB_SRG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-SRG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-SRG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_045_check_openroadm_topo_ROADMB_DEG2(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-DEG2', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-DEG2', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_046_check_otn_topo_otu4_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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',
# test service-create for 100GE service from spdrA to spdrC via spdrB
+
def test_047_create_100GE_service_ABC(self):
self.cr_serv_input_data["service-name"] = "service-100GE-ABC"
self.cr_serv_input_data["connection-type"] = "service"
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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_048_get_100GE_service_ABC(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-100GE-ABC")
+ response = test_utils.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')
time.sleep(1)
def test_049_check_interface_100GE_CLIENT_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR2-CLIENT1-ETHERNET')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict = {'name': 'XPDR2-CLIENT1-ETHERNET',
self.assertEqual('off', response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['fec'])
def test_050_check_interface_ODU4_CLIENT_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
{'payload-type': '21', 'exp-payload-type': '21'},
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
- response2 = test_utils_rfc8040.check_node_attribute_request(
+ response2 = test_utils.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']['expected-dapi'])
def test_051_check_interface_ODU4_NETWORK_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
dict.keys(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
def test_052_check_ODU4_connection_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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 = {
response['odu-connection'][0]['source'])
def test_053_check_interface_100GE_CLIENT_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SC1', 'interface', 'XPDR2-CLIENT1-ETHERNET')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict = {'name': 'XPDR2-CLIENT1-ETHERNET',
self.assertEqual('off', response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['fec'])
def test_054_check_interface_ODU4_CLIENT_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
{'payload-type': '21', 'exp-payload-type': '21'},
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
- response2 = test_utils_rfc8040.check_node_attribute_request(
+ response2 = test_utils.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']['expected-dapi'])
def test_055_check_interface_ODU4_NETWORK_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
dict.keys(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
def test_056_check_ODU4_connection_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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 = {
response['odu-connection'][0]['source'])
def test_057_check_interface_ODU4_NETWORK1_spdrb(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
dict.keys(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
def test_058_check_interface_ODU4_NETWORK2_spdrb(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
dict.keys(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
def test_059_check_ODU4_connection_spdrb(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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 = {
response['odu-connection'][0]['source'])
def test_060_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
def test_061_delete_service_100GE_ABC(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-100GE-ABC"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_062_check_service_list(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.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_rfc8040.check_node_request("SPDR-SA1")
+ response = test_utils.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_rfc8040.check_node_attribute_request(
+ response = test_utils.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_rfc8040.check_node_attribute_request(
+ response = test_utils.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_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR2-CLIENT1-ETHERNET')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_068_delete_OCH_OTU4_service_AB(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-OCH-OTU4-AB"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_069_delete_OCH_OTU4_service_BC(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-OCH-OTU4-BC"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_070_get_no_service(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['service-list'], (
{
time.sleep(1)
def test_071_check_no_interface_OTU4_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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_rfc8040.check_node_attribute_request(
+ response = test_utils.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_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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_rfc8040.get_ietf_network_node_request('openroadm-topology', 'SPDR-SA1-XPDR2', 'config')
+ response = test_utils.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'])
time.sleep(1)
def test_075_check_openroadm_topo_ROADMB_SRG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-SRG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-SRG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_076_check_openroadm_topo_ROADMB_DEG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-DEG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-DEG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_077_check_openroadm_topo_ROADMB_DEG2(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-DEG2', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-B1-DEG2', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_078_disconnect_xponders_from_roadm(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.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'])):
- response = test_utils_rfc8040.del_ietf_network_link_request(
+ response = test_utils.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_rfc8040.unmount_device("SPDR-SB1")
+ response = test_utils.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_rfc8040.unmount_device("ROADM-B1")
+ response = test_utils.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):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.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']):
- response = test_utils_rfc8040.del_ietf_network_link_request(
+ response = test_utils.del_ietf_network_link_request(
'openroadm-topology', link['link-id'], 'config')
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX",
- data)
+ response = test_utils.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):
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX",
- data)
+ response = test_utils.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):
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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_085_get_OCH_OTU4_service_AC(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-OCH-OTU4-AC")
+ response = test_utils.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.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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_087_get_100GE_service_AC(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-100GE-AC")
+ response = test_utils.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')
time.sleep(1)
def test_088_check_interface_OTU4_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
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(
+ response2 = test_utils.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-dapi'], response2['org-openroadm-otn-otu-interfaces:otu']['expected-dapi'])
def test_089_check_interface_OTU4_spdrC(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
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(
+ response2 = test_utils.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.test_056_check_ODU4_connection_spdrc()
def test_092_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
def test_093_delete_100GE_service_AC(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-100GE-AC"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_094_check_service_list(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['service-list']['services']), 1)
time.sleep(1)
self.test_066_check_no_interface_100GE_CLIENT_spdra()
def test_096_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
def test_097_disconnect_xponders_from_roadm(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.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'):
- response = test_utils_rfc8040.del_ietf_network_link_request(
+ response = test_utils.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_rfc8040.unmount_device("SPDR-SA1")
+ response = test_utils.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_rfc8040.unmount_device("SPDR-SC1")
+ response = test_utils.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_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.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_rfc8040.unmount_device("ROADM-C1")
+ response = test_utils.unmount_device("ROADM-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEtesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- 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)])
+ 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)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(2)
def test_001_connect_spdrA(self):
- response = test_utils_rfc8040.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
+ response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_002_connect_spdrB(self):
- response = test_utils_rfc8040.mount_device("SPDR-SB1", ('spdrb', self.NODE_VERSION))
+ response = test_utils.mount_device("SPDR-SB1", ('spdrb', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_003_connect_spdrC(self):
- response = test_utils_rfc8040.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
+ response = test_utils.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_004_connect_rdmA(self):
- response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_005_connect_rdmB(self):
- response = test_utils_rfc8040.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION))
+ response = test_utils.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_006_connect_rdmC(self):
- response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
+ response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_007_connect_sprdA_1_N1_to_roadmA_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_008_connect_roadmA_PP1_to_spdrA_1_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_009_connect_sprdC_1_N1_to_roadmC_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_010_connect_roadmC_PP1_to_spdrC_1_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_011_connect_sprdB_2_N1_to_roadmB_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_012_connect_roadmB_PP1_to_spdrB_2_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_013_connect_sprdB_2_N2_to_roadmB_PP2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_014_connect_roadmB_PP2_to_spdrB_2_N2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX",
- data)
+ response = test_utils.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):
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX",
- data)
+ response = test_utils.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):
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX",
- data)
+ response = test_utils.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):
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX",
- data)
+ response = test_utils.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_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADM-A1',
response["output"]["result"])
def test_020_create_OTS_ROADMB_DEG1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADM-B1',
response["output"]["result"])
def test_021_create_OTS_ROADMB_DEG2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADM-B1',
response["output"]["result"])
def test_022_create_OTS_ROADMC_DEG2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADM-C1',
response["output"]["result"])
def test_023_calculate_span_loss_base_all(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'calculate-spanloss-base',
{
'src-type': 'all'
time.sleep(5)
def test_024_check_otn_topology(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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],
# test service-create for OCH-OTU4 service from spdrA to spdrB
def test_025_create_OCH_OTU4_service_AB(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_026_get_OCH_OTU4_service_AB(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-OCH-OTU4-AB")
+ response = test_utils.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')
time.sleep(1)
def test_027_check_otn_topo_otu4_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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',
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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_029_get_OCH_OTU4_service_BC(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-OCH-OTU4-BC")
+ response = test_utils.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')
time.sleep(1)
def test_030_check_otn_topo_otu4_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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',
# test service-create for ODU4 service from spdrA to spdrC via spdrB
+
def test_031_create_ODU4_service(self):
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-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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_032_get_ODU4_service_ABC(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-ODU4-ABC")
+ response = test_utils.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')
time.sleep(1)
def test_033_check_interface_ODU4_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
{'payload-type': '21', 'exp-payload-type': '21'},
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
- response2 = test_utils_rfc8040.check_node_attribute2_request(
+ response2 = test_utils.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-dapi'], response2['org-openroadm-otn-odu-interfaces:odu']['expected-dapi'])
def test_034_check_interface_ODU4_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
{'payload-type': '21', 'exp-payload-type': '21'},
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
- response2 = test_utils_rfc8040.check_node_attribute2_request(
+ response2 = test_utils.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-dapi'], response2['org-openroadm-otn-odu-interfaces:odu']['expected-dapi'])
def test_035_check_interface_ODU4_NETWORK1_spdrb(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
dict.keys(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
def test_036_check_interface_ODU4_NETWORK2_spdrb(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
dict.keys(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
def test_037_check_ODU4_connection_spdrb(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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 = {
response['odu-connection'][0]['source'])
def test_038_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
self.fail("this link should not exist")
def test_039_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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':
# test service-create for 10GE service from spdr to spdr
+
def test_040_create_10GE_service(self):
self.cr_serv_input_data["service-name"] = "service1-10GE"
self.cr_serv_input_data["connection-type"] = "service"
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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_041_get_10GE_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1-10GE")
+ response = test_utils.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')
time.sleep(1)
def test_042_check_interface_10GE_CLIENT_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SA1', 'interface', 'XPDR1-CLIENT1-ETHERNET10G')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
self.assertEqual(10000, response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'])
def test_043_check_interface_ODU2E_CLIENT_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
{'payload-type': '03', 'exp-payload-type': '03'},
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
- response2 = test_utils_rfc8040.check_node_attribute_request(
+ response2 = test_utils.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']['expected-dapi'])
def test_044_check_interface_ODU2E_NETWORK_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
['trib-slots'])
def test_045_check_ODU2E_connection_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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 = {
response['odu-connection'][0]['source'])
def test_046_check_interface_10GE_CLIENT_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SC1', 'interface', 'XPDR1-CLIENT1-ETHERNET10G')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
self.assertEqual(10000, response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'])
def test_047_check_interface_ODU2E_CLIENT_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
{'payload-type': '03', 'exp-payload-type': '03'},
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
- response2 = test_utils_rfc8040.check_node_attribute_request(
+ response2 = test_utils.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']['expected-dapi'])
def test_048_check_interface_ODU2E_NETWORK_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
['trib-slots'])
def test_049_check_ODU2E_connection_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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 = {
response['odu-connection'][0]['source'])
def test_050_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
link['org-openroadm-otn-network-topology:used-bandwidth'], 10000)
def test_051_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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':
def test_052_delete_10GE_service(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1-10GE"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_053_check_service_list(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.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_rfc8040.check_node_request("SPDR-SA1")
+ response = test_utils.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_rfc8040.check_node_attribute_request(
+ response = test_utils.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_rfc8040.check_node_attribute_request(
+ response = test_utils.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_rfc8040.check_node_attribute_request(
+ response = test_utils.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_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
def test_059_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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'):
def test_060_delete_ODU4_service(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-ODU4-ABC"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_061_check_service_list(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.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_rfc8040.check_node_attribute_request(
+ response = test_utils.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_rfc8040.check_node_attribute_request(
+ response = test_utils.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(
+ response = test_utils.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_rfc8040.check_node_request("SPDR-SB1")
+ response = test_utils.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_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-ODU4')
self.assertEqual(response['status_code'], requests.codes.conflict)
self.test_030_check_otn_topo_otu4_links()
def test_067_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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':
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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_069_get_ODU4_service_AB(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-ODU4-AB")
+ response = test_utils.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')
time.sleep(1)
def test_070_check_interface_ODU4_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
{'payload-type': '21', 'exp-payload-type': '21'},
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
- response2 = test_utils_rfc8040.check_node_attribute_request(
+ response2 = test_utils.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']['expected-dapi'])
def test_071_check_interface_ODU4_spdrb_N1(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
self.assertDictEqual(
{'payload-type': '21', 'exp-payload-type': '21'},
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
- response2 = test_utils_rfc8040.check_node_attribute_request(
+ response2 = test_utils.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'],
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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_073_get_ODU4_service_AB(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-ODU4-BC")
+ response = test_utils.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')
time.sleep(1)
def test_074_check_interface_ODU4_spdrb_N2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
self.assertDictEqual(
{'payload-type': '21', 'exp-payload-type': '21'},
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
- response2 = test_utils_rfc8040.check_node_attribute_request(
+ response2 = test_utils.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']['expected-dapi'])
def test_075_check_interface_ODU4_spdrc(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
self.assertDictEqual(
{'payload-type': '21', 'exp-payload-type': '21'},
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
- response2 = test_utils_rfc8040.check_node_attribute_request(
+ response2 = test_utils.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'],
# test service-create for 10GE service from spdr to spdr
+
def test_076_create_10GE_service_ABC(self):
self.cr_serv_input_data["service-name"] = "service1-10GE"
self.cr_serv_input_data["connection-type"] = "service"
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(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.test_049_check_ODU2E_connection_spdrc()
def test_078_check_interface_ODU2E_NETWORK1_spdrb(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
['trib-slots'])
def test_079_check_interface_ODU2E_NETWORK2_spdrb(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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',
['trib-slots'])
def test_080_check_ODU2E_connection_spdrb(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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 = {
response['odu-connection'][0]['source'])
def test_081_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
def test_083_delete_10GE_service(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1-10GE"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_084_check_service_list(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['service-list']['services']), 4)
time.sleep(1)
self.test_057_check_no_interface_10GE_CLIENT_spdra()
def test_086_check_no_ODU2e_connection_spdrb(self):
- response = test_utils_rfc8040.check_node_request("SPDR-SB1")
+ response = test_utils.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_rfc8040.check_node_attribute_request(
+ response = test_utils.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_rfc8040.check_node_attribute_request(
+ response = test_utils.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_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
def test_091_delete_ODU4_service_AB(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-ODU4-AB"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_092_delete_ODU4_service_BC(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-ODU4-BC"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_094_delete_OCH_OTU4_service_AB(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-OCH-OTU4-AB"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_095_delete_OCH_OTU4_service_BC(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-OCH-OTU4-BC"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_096_get_no_service(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['service-list'], (
{
time.sleep(1)
def test_097_check_no_interface_OTU4_spdra(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.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_rfc8040.check_node_attribute_request(
+ response = test_utils.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_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.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'):
- response = test_utils_rfc8040.del_ietf_network_link_request(
+ response = test_utils.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_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.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_rfc8040.unmount_device("SPDR-SA1")
+ response = test_utils.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_rfc8040.unmount_device("SPDR-SC1")
+ response = test_utils.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_rfc8040.unmount_device("SPDR-SB1")
+ response = test_utils.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_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.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_rfc8040.unmount_device("ROADM-B1")
+ response = test_utils.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_rfc8040.unmount_device("ROADM-C1")
+ response = test_utils.unmount_device("ROADM-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCE400GPortMappingTesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra2', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('xpdra2', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(1)
def test_01_xpdr_device_connection(self):
- response = test_utils_rfc8040.mount_device("XPDR-A2",
- ('xpdra2', self.NODE_VERSION))
+ response = test_utils.mount_device("XPDR-A2",
+ ('xpdra2', self.NODE_VERSION))
self.assertEqual(response.status_code, requests.codes.created,
- test_utils_rfc8040.CODE_SHOULD_BE_201)
+ test_utils.CODE_SHOULD_BE_201)
# Check if the node appears in the ietf-network topology
def test_02_xpdr_device_connected(self):
- response = test_utils_rfc8040.check_device_connection("XPDR-A2")
+ response = test_utils.check_device_connection("XPDR-A2")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['connection-status'], 'connected')
# Check node info in the port-mappings
def test_03_xpdr_portmapping_info(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "node-info", None)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(
{'node-type': 'xpdr',
# Check the if-capabilities and the other details for network
def test_04_tpdr_portmapping_NETWORK1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR1-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR1-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supported-interface-capability':
response['mapping'])
def test_05_tpdr_portmapping_CLIENT1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR1-CLIENT1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR1-CLIENT1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supported-interface-capability': ['org-openroadm-port-types:if-400GE'],
# Check the port-mapping for the switch-client and switch-network port-quals
def test_06_mpdr_portmapping_NETWORK1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn(
{'supported-interface-capability':
response['mapping'])
def test_07_mpdr_portmapping_CLIENT1(self):
- res = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-CLIENT1")
+ res = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-CLIENT1")
self.assertEqual(res['status_code'], requests.codes.ok)
self.assertIn('org-openroadm-port-types:if-100GE-ODU4',
res['mapping'][0]['supported-interface-capability'])
# Added test to check mc-capability-profile for a transponder
def test_08_check_mccapprofile(self):
- res = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mc-capabilities", "XPDR-mcprofile")
+ res = test_utils.get_portmapping_node_attr("XPDR-A2", "mc-capabilities", "XPDR-mcprofile")
self.assertEqual(res['status_code'], requests.codes.ok)
self.assertEqual(res['mc-capabilities'][0]['mc-node-name'], 'XPDR-mcprofile')
self.assertEqual(float(res['mc-capabilities'][0]['center-freq-granularity']), 3.125)
self.assertEqual(float(res['mc-capabilities'][0]['slot-width-granularity']), 6.25)
def test_09_mpdr_switching_pool(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "switching-pool-lcp", "1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "switching-pool-lcp", "1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual("blocking",
response['switching-pool-lcp'][0]['switching-pool-type'])
response['switching-pool-lcp'][0]['non-blocking-list'])
def test_10_xpdr_device_disconnection(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A2")
+ response = test_utils.unmount_device("XPDR-A2")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_11_xpdr_device_disconnected(self):
- response = test_utils_rfc8040.check_device_connection("XPDR-A2")
+ response = test_utils.check_device_connection("XPDR-A2")
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['connection-status']['error-type'], ('protocol', 'application'))
self.assertEqual(response['connection-status']['error-tag'], 'data-missing')
'Request could not be completed because the relevant data model content does not exist')
def test_12_xpdr_device_not_connected(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "node-info", None)
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['node-info']['error-type'], ('protocol', 'application'))
self.assertEqual(response['node-info']['error-tag'], 'data-missing')
sys.path.append('transportpce_tests/common')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCE400GPortMappingTesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra2', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('xpdra2', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(10)
def test_01_xpdr_device_connection(self):
- response = test_utils_rfc8040.mount_device("XPDR-A2",
- ('xpdra2', self.NODE_VERSION))
+ response = test_utils.mount_device("XPDR-A2",
+ ('xpdra2', self.NODE_VERSION))
self.assertEqual(response.status_code, requests.codes.created,
- test_utils_rfc8040.CODE_SHOULD_BE_201)
+ test_utils.CODE_SHOULD_BE_201)
# Check if the node appears in the ietf-network topology
# this test has been removed, since it already exists in port-mapping
# 1a) create a OTUC2 device renderer
def test_02_service_path_create_otuc2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'service_OTUC2',
response['output']['node-interface'])
def test_03_get_portmapping_network1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.NETWORK2_CHECK_DICT["supporting-otucn"] = "XPDR2-NETWORK1-OTUC2"
self.assertIn(
def test_04_check_interface_otsi(self):
# pylint: disable=line-too-long
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-755:768")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-755:768")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-755:768',
'administrative-state': 'inService',
response['interface'][0]['org-openroadm-optical-tributary-signal-interfaces:otsi']['flexo'])
def test_05_check_interface_otsig(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-NETWORK1-OTSIGROUP-200G")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-OTSIGROUP-200G',
response['interface'][0]['org-openroadm-otsi-group-interfaces:otsi-group'])
def test_06_check_interface_otuc2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-NETWORK1-OTUC2")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-OTUC2',
# 1b) create a ODUC2 device renderer
def test_07_otn_service_path_create_oduc2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'otn-service-path',
{
'service-name': 'service_ODUC2',
'odu-interface-id': ['XPDR2-NETWORK1-ODUC2']}, response['output']['node-interface'])
def test_08_get_portmapping_network1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.NETWORK2_CHECK_DICT["supporting-oducn"] = "XPDR2-NETWORK1-ODUC2"
self.assertIn(
response['mapping'])
def test_09_check_interface_oduc2(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC2")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC2")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-ODUC2',
# 1c) create Ethernet device renderer
def test_10_otn_service_path_create_100ge(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'otn-service-path',
{
'service-name': 'service_Ethernet',
response['output']['node-interface'][0]['odu-interface-id'])
def test_11_check_interface_100ge_client(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-CLIENT1-ETHERNET-100G")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-CLIENT1-ETHERNET-100G',
response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
def test_12_check_interface_odu4_client(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-CLIENT1-ODU4")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-CLIENT1-ODU4',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_13_check_interface_odu4_network(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-NETWORK1-ODU4")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4',
['opucn-trib-slots'])
def test_14_check_odu_connection_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2",
"odu-connection", "XPDR2-CLIENT1-ODU4-x-XPDR2-NETWORK1-ODU4")
self.assertEqual(response['status_code'], requests.codes.ok)
# 1d) Delete Ethernet device interfaces
def test_15_otn_service_path_delete_100ge(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'otn-service-path',
{
'service-name': 'service_Ethernet',
self.assertIn('Request processed', response['output']['result'])
def test_16_check_no_odu_connection(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2",
"odu-connection", "XPDR2-CLIENT1-ODU4-x-XPDR2-NETWORK1-ODU4")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_17_check_no_interface_odu_network(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-NETWORK1-ODU4")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_18_check_no_interface_odu_client(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-CLIENT1-ODU4")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_19_check_no_interface_100ge_client(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-CLIENT1-ETHERNET-100G")
self.assertEqual(response['status_code'], requests.codes.conflict)
# 1e) Delete ODUC2 device interfaces
def test_20_otn_service_path_delete_oduc2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'otn-service-path',
{
'service-name': 'service_ODUC2',
del self.NETWORK2_CHECK_DICT["supporting-oducn"]
def test_21_check_no_interface_oduc2(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC2")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC2")
self.assertEqual(response['status_code'], requests.codes.conflict)
# Check if port-mapping data is updated, where the supporting-oducn is deleted
def test_21a_check_no_oduc2(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertRaises(KeyError, lambda: response["supporting-oducn"])
# 1f) Delete OTUC2 device interfaces
def test_22_service_path_delete_otuc2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'service_OTUC2',
del self.NETWORK2_CHECK_DICT["supporting-otucn"]
def test_23_check_no_interface_otuc2(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-OTUC2")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-OTUC2")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_24_check_no_interface_otsig(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-NETWORK1-OTSIGROUP-200G")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_25_check_no_interface_otsi(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-755:768")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-755:768")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_25a_check_no_otuc2(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertRaises(KeyError, lambda: response["supporting-otucn"])
# 2a) create a OTUC3 device renderer
def test_26_service_path_create_otuc3(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'service_OTUC3',
self.assertEqual(sorted(response['output']['node-interface'][0]['och-interface-id']), expected_sorted_list)
def test_27_get_portmapping_network1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.NETWORK2_CHECK_DICT["supporting-otucn"] = "XPDR2-NETWORK1-OTUC3"
self.assertIn(
def test_28_check_interface_otsi(self):
# pylint: disable=line-too-long
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-755:768")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-755:768")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-755:768',
response['interface'][0]['org-openroadm-optical-tributary-signal-interfaces:otsi']['flexo'])
def test_29_check_interface_otsig(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-NETWORK1-OTSIGROUP-300G")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-OTSIGROUP-300G',
response['interface'][0]['org-openroadm-otsi-group-interfaces:otsi-group'])
def test_30_check_interface_otuc3(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-NETWORK1-OTUC3")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-OTUC3',
# 2b) create a ODUC3 device renderer
def test_31_otn_service_path_create_oduc3(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'otn-service-path',
{
'service-name': 'service_ODUC3',
'odu-interface-id': ['XPDR2-NETWORK1-ODUC3']}, response['output']['node-interface'])
def test_32_get_portmapping_network1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.NETWORK2_CHECK_DICT["supporting-oducn"] = "XPDR2-NETWORK1-ODUC3"
self.assertIn(
response['mapping'])
def test_33_check_interface_oduc3(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC3")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC3")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-ODUC3',
# 2e) Delete ODUC3 device interfaces
def test_34_otn_service_path_delete_oduc3(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'otn-service-path',
{
'service-name': 'service_ODUC3',
del self.NETWORK2_CHECK_DICT["supporting-oducn"]
def test_35_check_no_interface_oduc3(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC3")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC3")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_35a_check_no_oduc3(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertRaises(KeyError, lambda: response["supporting-oducn"])
# 2f) Delete OTUC3 device interfaces
def test_36_service_path_delete_otuc3(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'service_OTUC3',
del self.NETWORK2_CHECK_DICT["supporting-otucn"]
def test_37_check_no_interface_otuc3(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR2-NETWORK1-OTUC3")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "interface", "XPDR2-NETWORK1-OTUC3")
self.assertIn(response['status_code'], (requests.codes.conflict, requests.codes.service_unavailable))
def test_38_check_no_interface_otsig(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A1", "interface", "XPDR2-NETWORK1-OTSIGROUP-300G")
self.assertIn(response['status_code'], (requests.codes.conflict, requests.codes.service_unavailable))
def test_39_check_no_interface_otsi(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR2-NETWORK1-755:768")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "interface", "XPDR2-NETWORK1-755:768")
self.assertIn(response['status_code'], (requests.codes.conflict, requests.codes.service_unavailable))
def test_39a_check_no_otuc3(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertRaises(KeyError, lambda: response["supporting-otucn"])
# 3a) create a OTUC4 device renderer
def test_40_service_path_create_otuc4(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'service_OTUC4',
self.assertEqual(sorted(response['output']['node-interface'][0]['och-interface-id']), expected_sorted_list)
def test_41_get_portmapping_network1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.NETWORK2_CHECK_DICT["supporting-otucn"] = "XPDR2-NETWORK1-OTUC4"
self.assertIn(
def test_42_check_interface_otsi(self):
# pylint: disable=line-too-long
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-755:768")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-755:768")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-755:768',
response['interface'][0]['org-openroadm-optical-tributary-signal-interfaces:otsi']['flexo'])
def test_43_check_interface_otsig(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-NETWORK1-OTSIGROUP-400G")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-OTSIGROUP-400G',
response['interface'][0]['org-openroadm-otsi-group-interfaces:otsi-group'])
def test_44_check_interface_otuc4(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-NETWORK1-OTUC4")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-OTUC4',
# 3b) create a ODUC4 device renderer
def test_45_otn_service_path_create_oduc3(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'otn-service-path',
{
'service-name': 'service_ODUC4',
'odu-interface-id': ['XPDR2-NETWORK1-ODUC4']}, response['output']['node-interface'])
def test_46_get_portmapping_network1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.NETWORK2_CHECK_DICT["supporting-oducn"] = "XPDR2-NETWORK1-ODUC4"
self.assertIn(
response['mapping'])
def test_47_check_interface_oduc4(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC4")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC4")
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-ODUC4',
# 3e) Delete ODUC4 device interfaces
def test_48_otn_service_path_delete_oduc4(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'otn-service-path',
{
'service-name': 'service_ODUC4',
del self.NETWORK2_CHECK_DICT["supporting-oducn"]
def test_49_check_no_interface_oduc4(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC4")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-ODUC4")
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_49a_check_no_oduc4(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertRaises(KeyError, lambda: response["supporting-oducn"])
# 3f) Delete OTUC4 device interfaces
def test_50_service_path_delete_otuc4(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'service-path',
{
'service-name': 'service_OTUC4',
del self.NETWORK2_CHECK_DICT["supporting-otucn"]
def test_51_check_no_interface_otuc4(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR2-NETWORK1-OTUC4")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "interface", "XPDR2-NETWORK1-OTUC4")
self.assertIn(response['status_code'], (requests.codes.conflict, requests.codes.service_unavailable))
def test_52_check_no_interface_otsig(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A1", "interface", "XPDR2-NETWORK1-OTSIGROUP-400G")
self.assertIn(response['status_code'], (requests.codes.conflict, requests.codes.service_unavailable))
def test_53_check_no_interface_otsi(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A1", "interface", "XPDR2-NETWORK1-755:768")
+ response = test_utils.check_node_attribute_request("XPDR-A1", "interface", "XPDR2-NETWORK1-755:768")
self.assertIn(response['status_code'], (requests.codes.conflict, requests.codes.service_unavailable))
def test_53a_check_no_otuc4(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertRaises(KeyError, lambda: response["supporting-otucn"])
# Disconnect the XPDR
def test_54_xpdr_device_disconnection(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A2")
+ response = test_utils.unmount_device("XPDR-A2")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_55_xpdr_device_disconnected(self):
- response = test_utils_rfc8040.check_device_connection("XPDR-A2")
+ response = test_utils.check_device_connection("XPDR-A2")
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['connection-status']['error-type'], ('protocol', 'application'))
self.assertEqual(response['connection-status']['error-tag'], 'data-missing')
'Request could not be completed because the relevant data model content does not exist')
def test_56_xpdr_device_not_connected(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "node-info", None)
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['node-info']['error-type'], ('protocol', 'application'))
self.assertEqual(response['node-info']['error-tag'], 'data-missing')
sys.path.append("transportpce_tests/common")
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCE400GPortMappingTesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([("xpdra2", cls.NODE_VERSION),
- ("xpdrc2", cls.NODE_VERSION)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([("xpdra2", cls.NODE_VERSION),
+ ("xpdrc2", cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(10)
def test_01_xpdr_device_connection(self):
- response = test_utils_rfc8040.mount_device("XPDR-A2",
- ("xpdra2", self.NODE_VERSION))
+ response = test_utils.mount_device("XPDR-A2",
+ ("xpdra2", self.NODE_VERSION))
self.assertEqual(response.status_code, requests.codes.created,
- test_utils_rfc8040.CODE_SHOULD_BE_201)
+ test_utils.CODE_SHOULD_BE_201)
def test_01a_xpdr_device_connection(self):
- response = test_utils_rfc8040.mount_device("XPDR-C2",
- ("xpdrc2", self.NODE_VERSION))
+ response = test_utils.mount_device("XPDR-C2",
+ ("xpdrc2", self.NODE_VERSION))
self.assertEqual(response.status_code, requests.codes.created,
- test_utils_rfc8040.CODE_SHOULD_BE_201)
+ test_utils.CODE_SHOULD_BE_201)
# Check the correct capabilities for the client ports (if-100GE, if-100GE-ODU4,
# if-OCH-OTU4-ODU4)
def test_02_check_client_capabilities(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR3-CLIENT1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR3-CLIENT1")
self.assertEqual(response["status_code"], requests.codes.ok)
self.assertEqual(
self.CLIENT_CAPABILITIES,
sorted(response["mapping"][0]["supported-interface-capability"]))
def test_03_check_client_capabilities(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-C2", "mapping", "XPDR3-CLIENT1")
+ response = test_utils.get_portmapping_node_attr("XPDR-C2", "mapping", "XPDR3-CLIENT1")
self.assertEqual(response["status_code"], requests.codes.ok)
self.assertEqual(
self.CLIENT_CAPABILITIES,
sorted(response["mapping"][0]["supported-interface-capability"]))
def test_04_100g_ofec_service_path_create(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
"transportpce-device-renderer", "service-path",
{
"service-name": "service_100GE_ofec",
for x in response["output"]["node-interface"][1].keys()})
def test_05_get_portmapping_network1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR3-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR3-NETWORK1")
self.assertEqual(response["status_code"], requests.codes.ok)
self.NETWORK1_CHECK_DICT["supporting-otucn"] = "XPDR3-NETWORK1-OTUC1"
self.NETWORK1_CHECK_DICT["lcp-hash-val"] = "FDvaQIf2Z08="
response["mapping"])
def test_06_get_portmapping_network1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-C2", "mapping", "XPDR3-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-C2", "mapping", "XPDR3-NETWORK1")
self.assertEqual(response["status_code"], requests.codes.ok)
self.NETWORK1_CHECK_DICT["supporting-otucn"] = "XPDR3-NETWORK1-OTUC1"
self.NETWORK1_CHECK_DICT["lcp-hash-val"] = "AJpkaVmZKJk5"
def test_07_check_interface_otsi(self):
# pylint: disable=line-too-long
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR3-NETWORK1-265:272")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR3-NETWORK1-265:272")
self.assertEqual(response["status_code"], requests.codes.ok)
input_dict_1 = {"name": "XPDR3-NETWORK1-265:272",
"administrative-state": "inService",
def test_08_check_interface_otsi(self):
# pylint: disable=line-too-long
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-C2", "interface", "XPDR3-NETWORK1-265:272")
+ response = test_utils.check_node_attribute_request("XPDR-C2", "interface", "XPDR3-NETWORK1-265:272")
self.assertEqual(response["status_code"], requests.codes.ok)
input_dict_1 = {"name": "XPDR3-NETWORK1-265:272",
"administrative-state": "inService",
response["interface"][0]["org-openroadm-optical-tributary-signal-interfaces:otsi"]["flexo"])
def test_09_check_interface_otsig(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR3-NETWORK1-OTSIGROUP-100G")
self.assertEqual(response["status_code"], requests.codes.ok)
input_dict_1 = {"name": "XPDR3-NETWORK1-OTSIGROUP-100G",
response["interface"][0]["org-openroadm-otsi-group-interfaces:otsi-group"])
def test_10_check_interface_otsig(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-C2", "interface", "XPDR3-NETWORK1-OTSIGROUP-100G")
self.assertEqual(response["status_code"], requests.codes.ok)
input_dict_1 = {"name": "XPDR3-NETWORK1-OTSIGROUP-100G",
response["interface"][0]["org-openroadm-otsi-group-interfaces:otsi-group"])
def test_11_check_interface_otuc1(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR3-NETWORK1-OTUC1")
self.assertEqual(response["status_code"], requests.codes.ok)
input_dict_1 = {"name": "XPDR3-NETWORK1-OTUC1",
response["interface"][0]["org-openroadm-otn-otu-interfaces:otu"])
def test_12_check_interface_otuc1(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-C2", "interface", "XPDR3-NETWORK1-OTUC1")
self.assertEqual(response["status_code"], requests.codes.ok)
input_dict_1 = {"name": "XPDR3-NETWORK1-OTUC1",
response["interface"][0]["org-openroadm-otn-otu-interfaces:otu"])
def test_13_check_interface_oduc1(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR3-NETWORK1-ODUC1")
self.assertEqual(response["status_code"], requests.codes.ok)
input_dict_1 = {"name": "XPDR3-NETWORK1-ODUC1",
response["interface"][0]["org-openroadm-otn-odu-interfaces:odu"]["opu"])
def test_14_check_interface_oduc1(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-C2", "interface", "XPDR3-NETWORK1-ODUC1")
self.assertEqual(response["status_code"], requests.codes.ok)
response["interface"][0]["org-openroadm-otn-odu-interfaces:odu"]["opu"])
def test_15_check_interface_odu4(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR3-NETWORK1-ODU4")
self.assertEqual(response["status_code"], requests.codes.ok)
# TODO: Check the trib-port numbering
def test_16_check_interface_odu4(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-C2", "interface", "XPDR3-NETWORK1-ODU4")
self.assertEqual(response["status_code"], requests.codes.ok)
# TODO: Check the trib-port numbering
def test_17_check_interface_100ge_client(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR3-CLIENT1-ETHERNET")
self.assertEqual(response["status_code"], requests.codes.ok)
input_dict_1 = {"name": "XPDR3-CLIENT1-ETHERNET-100G",
response["interface"][0]["org-openroadm-ethernet-interfaces:ethernet"])
def test_18_check_interface_100ge_client(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-C2", "interface", "XPDR3-CLIENT1-ETHERNET")
self.assertEqual(response["status_code"], requests.codes.ok)
input_dict_1 = {"name": "XPDR3-CLIENT1-ETHERNET-100G",
# Delete the service path
def test_19_service_path_delete_100ge(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
"transportpce-device-renderer", "service-path",
{
"service-name": "service_100GE_ofec",
self.assertIn("Request processed", response["output"]["result"])
def test_20_check_no_interface_100ge_client(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR3-CLIENT1-ETHERNET")
self.assertEqual(response["status_code"], requests.codes.conflict)
def test_21_check_no_interface_100ge_client(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-C2", "interface", "XPDR3-CLIENT1-ETHERNET")
self.assertEqual(response["status_code"], requests.codes.conflict)
def test_22_check_no_interface_odu4(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR3-NETWORK1-ODU4")
self.assertEqual(response["status_code"], requests.codes.conflict)
def test_23_check_no_interface_odu4(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-C2", "interface", "XPDR3-NETWORK1-ODU4")
self.assertEqual(response["status_code"], requests.codes.conflict)
def test_24_check_no_interface_otuc2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR3-NETWORK1-ODUC1")
self.assertEqual(response["status_code"], requests.codes.conflict)
def test_25_check_no_interface_otuc2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-C2", "interface", "XPDR3-NETWORK1-ODUC1")
self.assertEqual(response["status_code"], requests.codes.conflict)
# Check if port-mapping data is updated, where the supporting-otucn is deleted
def test_26_check_no_otuc1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR3-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR3-NETWORK1")
self.assertRaises(KeyError, lambda: response["supporting-otucn"])
def test_27_check_no_otuc1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-C2", "mapping", "XPDR3-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-C2", "mapping", "XPDR3-NETWORK1")
self.assertRaises(KeyError, lambda: response["supporting-otucn"])
def test_28_check_no_interface_otsig(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR3-NETWORK1-OTSIGROUP-100G")
self.assertEqual(response["status_code"], requests.codes.conflict)
def test_29_check_no_interface_otsig(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-C2", "interface", "XPDR3-NETWORK1-OTSIGROUP-100G")
self.assertEqual(response["status_code"], requests.codes.conflict)
def test_30_check_no_interface_otsi(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR3-NETWORK1-265:272")
self.assertEqual(response["status_code"], requests.codes.conflict)
def test_31_check_no_interface_otsi(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-C2", "interface", "XPDR3-NETWORK1-265:272")
self.assertEqual(response["status_code"], requests.codes.conflict)
# 200G 31.6 Gbaud mode for muxponder, with qam16
def test_32_service_path_create_otuc2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
"transportpce-device-renderer", "service-path",
{
"service-name": "service_OTUC2",
self.NETWORK1_CHECK_DICT["lcp-hash-val"] = "LY9PxYJqUbw="
def test_33_get_portmapping_network1(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertEqual(response["status_code"], requests.codes.ok)
self.NETWORK1_CHECK_DICT["supporting-otucn"] = "XPDR2-NETWORK1-OTUC2"
del self.NETWORK1_CHECK_DICT["connection-map-lcp"]
def test_34_check_interface_otsi(self):
# pylint: disable=line-too-long
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-265:272")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-265:272")
self.assertEqual(response["status_code"], requests.codes.ok)
input_dict_1 = {"name": "XPDR2-NETWORK1-265:272",
"administrative-state": "inService",
response["interface"][0]["org-openroadm-optical-tributary-signal-interfaces:otsi"]["flexo"])
def test_35_check_interface_otsig(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-NETWORK1-OTSIGROUP-200G")
self.assertEqual(response["status_code"], requests.codes.ok)
input_dict_1 = {"name": "XPDR2-NETWORK1-OTSIGROUP-200G",
response["interface"][0]["org-openroadm-otsi-group-interfaces:otsi-group"])
def test_36_check_interface_otuc2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-NETWORK1-OTUC2")
self.assertEqual(response["status_code"], requests.codes.ok)
input_dict_1 = {"name": "XPDR2-NETWORK1-OTUC2",
# as there is no change in code and are covered in test02_otn_renderer
def test_37_service_path_delete_otuc2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
"transportpce-device-renderer", "service-path",
{
"modulation-format": "dp-qam16",
del self.NETWORK1_CHECK_DICT["supporting-otucn"]
def test_38_check_no_interface_otuc2(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-OTUC2")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-OTUC2")
self.assertEqual(response["status_code"], requests.codes.conflict)
def test_39_check_no_interface_otsig(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"XPDR-A2", "interface", "XPDR2-NETWORK1-OTSIGROUP-200G")
self.assertEqual(response["status_code"], requests.codes.conflict)
def test_40_check_no_interface_otsi(self):
- response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-755:768")
+ response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-755:768")
self.assertEqual(response["status_code"], requests.codes.conflict)
def test_41_check_no_otuc2(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
self.assertRaises(KeyError, lambda: response["supporting-otucn"])
# Disconnect the XPDR
def test_42_xpdr_device_disconnection(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A2")
+ response = test_utils.unmount_device("XPDR-A2")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_43_xpdr_device_disconnected(self):
- response = test_utils_rfc8040.check_device_connection("XPDR-A2")
+ response = test_utils.check_device_connection("XPDR-A2")
self.assertEqual(response["status_code"], requests.codes.conflict)
self.assertIn(response["connection-status"]["error-type"], ("protocol", "application"))
self.assertEqual(response["connection-status"]["error-tag"], "data-missing")
"Request could not be completed because the relevant data model content does not exist")
def test_44_xpdr_device_not_connected(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-A2", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("XPDR-A2", "node-info", None)
self.assertEqual(response["status_code"], requests.codes.conflict)
self.assertIn(response["node-info"]["error-type"], ("protocol", "application"))
self.assertEqual(response["node-info"]["error-tag"], "data-missing")
"Request could not be completed because the relevant data model content does not exist")
def test_45_xpdr_device_disconnection(self):
- response = test_utils_rfc8040.unmount_device("XPDR-C2")
+ response = test_utils.unmount_device("XPDR-C2")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_46_xpdr_device_disconnected(self):
- response = test_utils_rfc8040.check_device_connection("XPDR-C2")
+ response = test_utils.check_device_connection("XPDR-C2")
self.assertEqual(response["status_code"], requests.codes.conflict)
self.assertIn(response["connection-status"]["error-type"], ("protocol", "application"))
self.assertEqual(response["connection-status"]["error-tag"], "data-missing")
"Request could not be completed because the relevant data model content does not exist")
def test_47_xpdr_device_not_connected(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-C2", "node-info", None)
+ response = test_utils.get_portmapping_node_attr("XPDR-C2", "node-info", None)
self.assertEqual(response["status_code"], requests.codes.conflict)
self.assertIn(response["node-info"]["error-type"], ("protocol", "application"))
self.assertEqual(response["node-info"]["error-tag"], "data-missing")
#!/usr/bin/env python
##############################################################################
-# Copyright (c) 2020 Orange, Inc. and others. All rights reserved.
+# Copyright (c) 2021 Orange, Inc. and others. All rights reserved.
#
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Apache License, Version 2.0
##############################################################################
# pylint: disable=no-member
-# pylint: disable=too-many-arguments
import json
import os
SIMS = simulators.SIMS
-HONEYNODE_OK_START_MSG = "Netconf SSH endpoint started successfully at 0.0.0.0"
-KARAF_OK_START_MSG = re.escape(
- "Blueprint container for bundle org.opendaylight.netconf.restconf")+".* was successfully created"
+HONEYNODE_OK_START_MSG = 'Netconf SSH endpoint started successfully at 0.0.0.0'
+KARAF_OK_START_MSG = "Blueprint container for bundle org.opendaylight.netconf.restconf.* was successfully created"
LIGHTY_OK_START_MSG = re.escape("lighty.io and RESTCONF-NETCONF started")
-ODL_LOGIN = "admin"
-ODL_PWD = "admin"
-NODES_LOGIN = "admin"
-NODES_PWD = "admin"
-URL_CONFIG_NETCONF_TOPO = "{}/config/network-topology:network-topology/topology/topology-netconf/"
-URL_CONFIG_ORDM_TOPO = "{}/config/ietf-network:networks/network/openroadm-topology/"
-URL_CONFIG_OTN_TOPO = "{}/config/ietf-network:networks/network/otn-topology/"
-URL_CONFIG_CLLI_NET = "{}/config/ietf-network:networks/network/clli-network/"
-URL_CONFIG_ORDM_NET = "{}/config/ietf-network:networks/network/openroadm-network/"
-URL_PORTMAPPING = "{}/config/transportpce-portmapping:network/nodes/"
-URL_OPER_SERV_LIST = "{}/operational/org-openroadm-service:service-list/"
-URL_OPER_SERV_PATH_LIST = "{}/operational/transportpce-service-path:service-path-list/"
-URL_GET_NBINOTIFICATIONS_PROCESS_SERV = "{}/operations/nbi-notifications:get-notifications-process-service/"
-URL_GET_NBINOTIFICATIONS_ALARM_SERV = "{}/operations/nbi-notifications:get-notifications-alarm-service/"
-URL_SERV_CREATE = "{}/operations/org-openroadm-service:service-create"
-URL_SERV_DELETE = "{}/operations/org-openroadm-service:service-delete"
-URL_SERVICE_PATH = "{}/operations/transportpce-device-renderer:service-path"
-URL_OTN_SERVICE_PATH = "{}/operations/transportpce-device-renderer:otn-service-path"
-URL_TAPI_CREATE_CONNECTIVITY = "{}/operations/tapi-connectivity:create-connectivity-service"
-URL_TAPI_DELETE_CONNECTIVITY = "{}/operations/tapi-connectivity:delete-connectivity-service"
-URL_TAPI_GET_CONNECTIVITY = "{}/operations/tapi-connectivity:get-connectivity-service-details"
-URL_CREATE_OTS_OMS = "{}/operations/transportpce-device-renderer:create-ots-oms"
-URL_PATH_COMPUTATION_REQUEST = "{}/operations/transportpce-pce:path-computation-request"
-URL_FULL_PORTMAPPING = "{}/config/transportpce-portmapping:network"
-URL_TAPI_TOPOLOGY_DETAILS = "{}/operations/tapi-topology:get-topology-details"
-URL_TAPI_NODE_DETAILS = "{}/operations/tapi-topology:get-node-details"
-URL_TAPI_NEP_DETAILS = "{}/operations/tapi-topology:get-node-edge-point-details"
-URL_TAPI_SIP_LIST = "{}/operations/tapi-common:get-service-interface-point-list"
-URL_TAPI_SERVICE_LIST = "{}/operations/tapi-connectivity:get-connectivity-service-list"
-URL_TAPI_NOTIFICATION_SUBS_SERVICE = "{}/operations/tapi-notification:create-notification-subscription-service"
-URL_TAPI_GET_NOTIFICATION_LIST = "{}/operations/tapi-notification:get-notification-list"
+ODL_LOGIN = 'admin'
+ODL_PWD = 'admin'
+NODES_LOGIN = 'admin'
+NODES_PWD = 'admin'
TYPE_APPLICATION_JSON = {'Content-Type': 'application/json', 'Accept': 'application/json'}
TYPE_APPLICATION_XML = {'Content-Type': 'application/xml', 'Accept': 'application/xml'}
CODE_SHOULD_BE_200 = 'Http status code should be 200'
CODE_SHOULD_BE_201 = 'Http status code should be 201'
+T100GE = 'Transponder 100GE'
+T0_MULTILAYER_TOPO = 'T0 - Multi-layer topology'
+T0_FULL_MULTILAYER_TOPO = 'T0 - Full Multi-layer topology'
-SIM_LOG_DIRECTORY = os.path.join(os.path.dirname(os.path.realpath(__file__)), "log")
+SIM_LOG_DIRECTORY = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'log')
process_list = []
-
-if "USE_ODL_ALT_RESTCONF_PORT" in os.environ:
- RESTCONF_BASE_URL = "http://localhost:" + os.environ['USE_ODL_ALT_RESTCONF_PORT'] + "/restconf"
+if 'USE_ODL_ALT_RESTCONF_PORT' in os.environ:
+ RESTCONF_PORT = os.environ['USE_ODL_ALT_RESTCONF_PORT']
+else:
+ RESTCONF_PORT = 8181
+
+RESTCONF_PATH_PREFIX = {'rfc8040': '/rests',
+ 'draft-bierman02': '/restconf'}
+if 'USE_ODL_RESTCONF_VERSION' in os.environ:
+ RESTCONF_VERSION = os.environ['USE_ODL_RESTCONF_VERSION']
+ if RESTCONF_VERSION not in RESTCONF_PATH_PREFIX:
+ print('unsupported RESTCONF version ' + RESTCONF_VERSION)
+ sys.exit(3)
else:
- RESTCONF_BASE_URL = "http://localhost:8181/restconf"
+ RESTCONF_VERSION = 'rfc8040'
+
+RESTCONF_BASE_URL = 'http://localhost:' + str(RESTCONF_PORT) + RESTCONF_PATH_PREFIX[RESTCONF_VERSION]
-if "USE_ODL_ALT_KARAF_INSTALL_DIR" in os.environ:
+if 'USE_ODL_ALT_KARAF_INSTALL_DIR' in os.environ:
KARAF_INSTALLDIR = os.environ['USE_ODL_ALT_KARAF_INSTALL_DIR']
else:
- KARAF_INSTALLDIR = "karaf"
+ KARAF_INSTALLDIR = 'karaf'
KARAF_LOG = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
- "..", "..", "..", KARAF_INSTALLDIR, "target", "assembly", "data", "log", "karaf.log")
+ '..', '..', '..', KARAF_INSTALLDIR, 'target', 'assembly', 'data', 'log', 'karaf.log')
-if "USE_LIGHTY" in os.environ and os.environ['USE_LIGHTY'] == 'True':
+if 'USE_LIGHTY' in os.environ and os.environ['USE_LIGHTY'] == 'True':
TPCE_LOG = 'odl-' + str(os.getpid()) + '.log'
else:
TPCE_LOG = KARAF_LOG
+#
+# Basic HTTP operations
+#
+
+
+def get_request(url):
+ return requests.request(
+ 'GET', url.format(RESTCONF_BASE_URL),
+ headers=TYPE_APPLICATION_JSON,
+ auth=(ODL_LOGIN, ODL_PWD),
+ timeout=REQUEST_TIMEOUT)
+
+
+def put_request(url, data):
+ return requests.request(
+ 'PUT', url.format(RESTCONF_BASE_URL),
+ data=json.dumps(data),
+ headers=TYPE_APPLICATION_JSON,
+ auth=(ODL_LOGIN, ODL_PWD),
+ timeout=REQUEST_TIMEOUT)
+
+
+def delete_request(url):
+ return requests.request(
+ 'DELETE', url.format(RESTCONF_BASE_URL),
+ headers=TYPE_APPLICATION_JSON,
+ auth=(ODL_LOGIN, ODL_PWD),
+ timeout=REQUEST_TIMEOUT)
+
+
+def post_request(url, data):
+ if data:
+ return requests.request(
+ "POST", url.format(RESTCONF_BASE_URL),
+ data=json.dumps(data),
+ headers=TYPE_APPLICATION_JSON,
+ auth=(ODL_LOGIN, ODL_PWD),
+ timeout=REQUEST_TIMEOUT)
+ return requests.request(
+ "POST", url.format(RESTCONF_BASE_URL),
+ headers=TYPE_APPLICATION_JSON,
+ auth=(ODL_LOGIN, ODL_PWD),
+ timeout=REQUEST_TIMEOUT)
+
+#
+# Process management
+#
+
def start_sims(sims_list):
for sim in sims_list:
- print("starting simulator " + sim[0] + " in OpenROADM device version " + sim[1] + "...")
+ print('starting simulator ' + sim[0] + ' in OpenROADM device version ' + sim[1] + '...')
log_file = os.path.join(SIM_LOG_DIRECTORY, SIMS[sim]['logfile'])
process = start_honeynode(log_file, sim)
if wait_until_log_contains(log_file, HONEYNODE_OK_START_MSG, 100):
- print("simulator for " + sim[0] + " started")
+ print('simulator for ' + sim[0] + ' started')
else:
- print("simulator for " + sim[0] + " failed to start")
+ print('simulator for ' + sim[0] + ' failed to start')
shutdown_process(process)
for pid in process_list:
shutdown_process(pid)
def start_tpce():
- print("starting OpenDaylight...")
- if "USE_LIGHTY" in os.environ and os.environ['USE_LIGHTY'] == 'True':
+ print('starting OpenDaylight...')
+ if 'USE_LIGHTY' in os.environ and os.environ['USE_LIGHTY'] == 'True':
process = start_lighty()
start_msg = LIGHTY_OK_START_MSG
else:
process = start_karaf()
start_msg = KARAF_OK_START_MSG
if wait_until_log_contains(TPCE_LOG, start_msg, time_to_wait=300):
- print("OpenDaylight started !")
+ print('OpenDaylight started !')
else:
- print("OpenDaylight failed to start !")
+ print('OpenDaylight failed to start !')
shutdown_process(process)
for pid in process_list:
shutdown_process(pid)
def start_karaf():
- print("starting KARAF TransportPCE build...")
+ print('starting KARAF TransportPCE build...')
executable = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
- "..", "..", "..", KARAF_INSTALLDIR, "target", "assembly", "bin", "karaf")
+ '..', '..', '..', KARAF_INSTALLDIR, 'target', 'assembly', 'bin', 'karaf')
with open('odl.log', 'w', encoding='utf-8') as outfile:
return subprocess.Popen(
- ["sh", executable, "server"], stdout=outfile, stderr=outfile, stdin=None)
+ ['sh', executable, 'server'], stdout=outfile, stderr=outfile, stdin=None)
def start_lighty():
- print("starting LIGHTY.IO TransportPCE build...")
+ print('starting LIGHTY.IO TransportPCE build...')
executable = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
- "..", "..", "..", "lighty", "target", "tpce",
- "clean-start-controller.sh")
+ '..', '..', '..', 'lighty', 'target', 'tpce',
+ 'clean-start-controller.sh')
with open(TPCE_LOG, 'w', encoding='utf-8') as outfile:
return subprocess.Popen(
- ["sh", executable], stdout=outfile, stderr=outfile, stdin=None)
+ ['sh', executable], stdout=outfile, stderr=outfile, stdin=None)
def install_karaf_feature(feature_name: str):
- print("installing feature " + feature_name)
+ print('installing feature ' + feature_name)
executable = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
- "..", "..", "..", KARAF_INSTALLDIR, "target", "assembly", "bin", "client")
+ '..', '..', '..', KARAF_INSTALLDIR, 'target', 'assembly', 'bin', 'client')
return subprocess.run([executable],
input='feature:install ' + feature_name + '\n feature:list | grep '
+ feature_name + ' \n logout \n',
universal_newlines=True, check=False)
-def get_request(url):
- return requests.request(
- "GET", url.format(RESTCONF_BASE_URL),
- headers=TYPE_APPLICATION_JSON,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
-
-
-def post_request(url, data):
- if data:
- print(json.dumps(data))
- return requests.request(
- "POST", url.format(RESTCONF_BASE_URL),
- data=json.dumps(data),
- headers=TYPE_APPLICATION_JSON,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
-
- return requests.request(
- "POST", url.format(RESTCONF_BASE_URL),
- headers=TYPE_APPLICATION_JSON,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
-
-
-def post_xmlrequest(url, data):
- if data:
- return requests.request(
- "POST", url.format(RESTCONF_BASE_URL),
- data=data,
- headers=TYPE_APPLICATION_XML,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
- return None
-
-
-def put_request(url, data):
- return requests.request(
- "PUT", url.format(RESTCONF_BASE_URL),
- data=json.dumps(data),
- headers=TYPE_APPLICATION_JSON,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
-
-
-def put_xmlrequest(url, data):
- return requests.request(
- "PUT", url.format(RESTCONF_BASE_URL),
- data=data,
- headers=TYPE_APPLICATION_XML,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
-
-
-def put_jsonrequest(url, data):
- return requests.request(
- "PUT", url.format(RESTCONF_BASE_URL),
- data=data,
- headers=TYPE_APPLICATION_JSON,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
-
-
-def rawput_request(url, data):
- return requests.request(
- "PUT", url.format(RESTCONF_BASE_URL),
- data=data,
- headers=TYPE_APPLICATION_JSON,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
-
-
-def rawpost_request(url, data):
- return requests.request(
- "POST", url.format(RESTCONF_BASE_URL),
- data=data,
- headers=TYPE_APPLICATION_JSON,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
-
-
-def delete_request(url):
- return requests.request(
- "DELETE", url.format(RESTCONF_BASE_URL),
- headers=TYPE_APPLICATION_JSON,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
-
-
-def mount_device(node_id, sim):
- url = URL_CONFIG_NETCONF_TOPO + "node/" + node_id
- body = {"node": [{
- "node-id": node_id,
- "netconf-node-topology:username": NODES_LOGIN,
- "netconf-node-topology:password": NODES_PWD,
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": SIMS[sim]['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- response = put_request(url, body)
- if wait_until_log_contains(TPCE_LOG, re.escape("Triggering notification stream NETCONF for node " + node_id), 180):
- print("Node " + node_id + " correctly added to tpce topology", end='... ', flush=True)
- else:
- print("Node " + node_id + " still not added to tpce topology", end='... ', flush=True)
- if response.status_code == requests.codes.ok:
- print("It was probably loaded at start-up", end='... ', flush=True)
- # TODO an else-clause to abort test would probably be nice here
- return response
-
-
-def mount_tapi_device(node_id, sim):
- url = URL_CONFIG_NETCONF_TOPO + "node/" + node_id
- body = {"node": [{
- "node-id": node_id,
- "netconf-node-topology:username": NODES_LOGIN,
- "netconf-node-topology:password": NODES_PWD,
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": SIMS[sim]['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- response = put_request(url, body)
- if wait_until_log_contains(TPCE_LOG, re.escape(f"TAPI node for or node {node_id} successfully merged"), 200):
- print("Node " + node_id + " correctly added to tpce topology", end='... ', flush=True)
- else:
- print("Node " + node_id + " still not added to tpce topology", end='... ', flush=True)
- if response.status_code == requests.codes.ok:
- print("It was probably loaded at start-up", end='... ', flush=True)
- # TODO an else-clause to abort test would probably be nice here
- return response
-
-
-def unmount_device(node_id):
- url = URL_CONFIG_NETCONF_TOPO + "node/" + node_id
- response = delete_request(url)
- if wait_until_log_contains(TPCE_LOG, re.escape("onDeviceDisConnected: " + node_id), 180):
- print("Node " + node_id + " correctly deleted from tpce topology", end='... ', flush=True)
- else:
- print("Node " + node_id + " still not deleted from tpce topology", end='... ', flush=True)
- return response
-
-
-def connect_xpdr_to_rdm_request(xpdr_node: str, xpdr_num: str, network_num: str,
- rdm_node: str, srg_num: str, termination_num: str):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
- data = {
- "networkutils:input": {
- "networkutils:links-input": {
- "networkutils:xpdr-node": xpdr_node,
- "networkutils:xpdr-num": xpdr_num,
- "networkutils:network-num": network_num,
- "networkutils:rdm-node": rdm_node,
- "networkutils:srg-num": srg_num,
- "networkutils:termination-point-num": termination_num
- }
- }
- }
- return post_request(url, data)
-
-
-def connect_rdm_to_xpdr_request(xpdr_node: str, xpdr_num: str, network_num: str,
- rdm_node: str, srg_num: str, termination_num: str):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
- data = {
- "networkutils:input": {
- "networkutils:links-input": {
- "networkutils:xpdr-node": xpdr_node,
- "networkutils:xpdr-num": xpdr_num,
- "networkutils:network-num": network_num,
- "networkutils:rdm-node": rdm_node,
- "networkutils:srg-num": srg_num,
- "networkutils:termination-point-num": termination_num
- }
- }
- }
- return post_request(url, data)
-
-
-def connect_xpdr_to_rdm_tapi_request(xpdr_node: str, xpdr_num: str, rdm_node: str, srg_num: str):
- url = "{}/operations/transportpce-tapinetworkutils:init-xpdr-rdm-tapi-link"
- data = {
- "input": {
- "xpdr-node": xpdr_node,
- "network-tp": xpdr_num,
- "rdm-node": rdm_node,
- "add-drop-tp": srg_num
- }
- }
- return post_request(url, data)
-
-
-def check_netconf_node_request(node: str, suffix: str):
- url = URL_CONFIG_NETCONF_TOPO + (
- "node/" + node + "/yang-ext:mount/org-openroadm-device:org-openroadm-device/" + suffix
- )
- return get_request(url)
-
-
-def get_netconf_oper_request(node: str):
- url = "{}/operational/network-topology:network-topology/topology/topology-netconf/node/" + node
- return get_request(url)
-
-
-def get_ordm_topo_request(suffix: str):
- url = URL_CONFIG_ORDM_TOPO + suffix
- return get_request(url)
-
-
-def add_oms_attr_request(link: str, attr):
- url = URL_CONFIG_ORDM_TOPO + (
- "ietf-network-topology:link/" + link + "/org-openroadm-network-topology:OMS-attributes/span"
- )
- return put_request(url, attr)
-
-
-def del_oms_attr_request(link: str):
- url = URL_CONFIG_ORDM_TOPO + (
- "ietf-network-topology:link/" + link + "/org-openroadm-network-topology:OMS-attributes/span"
- )
- return delete_request(url)
-
-
-def get_clli_net_request():
- return get_request(URL_CONFIG_CLLI_NET)
-
-
-def get_ordm_net_request():
- return get_request(URL_CONFIG_ORDM_NET)
-
-
-def get_otn_topo_request():
- return get_request(URL_CONFIG_OTN_TOPO)
-
-
-def del_link_request(link: str):
- url = URL_CONFIG_ORDM_TOPO + ("ietf-network-topology:link/" + link)
- return delete_request(url)
-
-
-def del_node_request(node: str):
- url = URL_CONFIG_CLLI_NET + ("node/" + node)
- return delete_request(url)
-
-
-def portmapping_request(suffix: str):
- url = URL_PORTMAPPING + suffix
- return get_request(url)
-
-
-def get_notifications_process_service_request(attr):
- return post_request(URL_GET_NBINOTIFICATIONS_PROCESS_SERV, attr)
-
-
-def get_notifications_alarm_service_request(attr):
- return post_request(URL_GET_NBINOTIFICATIONS_ALARM_SERV, attr)
-
-
-def get_service_list_request(suffix: str):
- return get_request(URL_OPER_SERV_LIST + suffix)
-
-
-def get_service_path_list_request(suffix: str):
- return get_request(URL_OPER_SERV_PATH_LIST + suffix)
-
-
-def service_create_request(attr):
- return post_request(URL_SERV_CREATE, attr)
-
-
-def service_delete_request(servicename: str,
- requestid="e3028bae-a90f-4ddd-a83f-cf224eba0e58",
- notificationurl="http://localhost:8585/NotificationServer/notify"):
- attr = {"input": {
- "sdnc-request-header": {
- "request-id": requestid,
- "rpc-action": "service-delete",
- "request-system-id": "appname",
- "notification-url": notificationurl},
- "service-delete-req-info": {
- "service-name": servicename,
- "tail-retention": "no"}}}
- return post_request(URL_SERV_DELETE, attr)
-
-
-def service_path_request(operation: str, servicename: str, wavenumber: str, nodes, centerfreq: str,
- slotwidth: int, minfreq: float, maxfreq: float, lowerslotnumber: int,
- higherslotnumber: int, modulation_format="dp-qpsk"):
- attr = {"renderer:input": {
- "renderer:service-name": servicename,
- "renderer:wave-number": wavenumber,
- "renderer:modulation-format": modulation_format,
- "renderer:operation": operation,
- "renderer:nodes": nodes,
- "renderer:center-freq": centerfreq,
- "renderer:nmc-width": slotwidth,
- "renderer:min-freq": minfreq,
- "renderer:max-freq": maxfreq,
- "renderer:lower-spectral-slot-number": lowerslotnumber,
- "renderer:higher-spectral-slot-number": higherslotnumber}}
- return post_request(URL_SERVICE_PATH, attr)
-
-
-def otn_service_path_request(operation: str, servicename: str, servicerate: str, serviceformat: str, nodes,
- eth_attr=None):
- attr = {"service-name": servicename,
- "operation": operation,
- "service-rate": servicerate,
- "service-format": serviceformat,
- "nodes": nodes}
- if eth_attr:
- attr.update(eth_attr)
- return post_request(URL_OTN_SERVICE_PATH, {"renderer:input": attr})
-
-
-def create_ots_oms_request(nodeid: str, lcp: str):
- attr = {"input": {
- "node-id": nodeid,
- "logical-connection-point": lcp}}
- return post_request(URL_CREATE_OTS_OMS, attr)
-
-
-def path_computation_request(requestid: str, servicename: str, serviceaend, servicezend,
- hardconstraints=None, softconstraints=None, metric="hop-count", other_attr=None):
- attr = {"service-name": servicename,
- "resource-reserve": "true",
- "service-handler-header": {"request-id": requestid},
- "service-a-end": serviceaend,
- "service-z-end": servicezend,
- "pce-routing-metric": metric}
- if hardconstraints:
- attr.update({"hard-constraints": hardconstraints})
- if softconstraints:
- attr.update({"soft-constraints": softconstraints})
- if other_attr:
- attr.update(other_attr)
- return post_request(URL_PATH_COMPUTATION_REQUEST, {"input": attr})
-
-
-def tapi_create_connectivity_request(topologyidorname):
- return post_request(URL_TAPI_CREATE_CONNECTIVITY, topologyidorname)
-
-
-def tapi_get_connectivity_request(serviceidorname):
- attr = {
- "input": {
- "service-id-or-name": serviceidorname}}
- return post_request(URL_TAPI_GET_CONNECTIVITY, attr)
-
-
-def tapi_delete_connectivity_request(serviceidorname):
- attr = {
- "input": {
- "service-id-or-name": serviceidorname}}
- return post_request(URL_TAPI_DELETE_CONNECTIVITY, attr)
-
-
-def tapi_get_topology_details_request(topologyidorname):
- attr = {
- "input": {
- "topology-id-or-name": topologyidorname}}
- return post_request(URL_TAPI_TOPOLOGY_DETAILS, attr)
-
-
-def tapi_get_node_details_request(topologyidorname, nodeidorname):
- attr = {
- "input": {
- "topology-id-or-name": topologyidorname,
- "node-id-or-name": nodeidorname}}
- return post_request(URL_TAPI_NODE_DETAILS, attr)
-
-
-def tapi_get_node_edge_point_details_request(topologyidorname, nodeidorname, nepidorname):
- attr = {
- "input": {
- "topology-id-or-name": topologyidorname,
- "node-id-or-name": nodeidorname,
- "ep-id-or-name": nepidorname}}
- return post_request(URL_TAPI_NEP_DETAILS, attr)
-
-
-def tapi_get_sip_details_request():
- return post_request(URL_TAPI_SIP_LIST, "")
-
-
-def tapi_get_service_list_request():
- return post_request(URL_TAPI_SERVICE_LIST, "")
-
-
-def tapi_create_notification_subscription_service_request(attr):
- return post_request(URL_TAPI_NOTIFICATION_SUBS_SERVICE, attr)
-
-
-def tapi_get_notifications_list_request(attr):
- return post_request(URL_TAPI_GET_NOTIFICATION_LIST, attr)
-
-
def shutdown_process(process):
if process is not None:
for child in psutil.Process(process.pid).children():
def start_honeynode(log_file: str, sim):
executable = os.path.join(os.path.dirname(os.path.realpath(__file__)),
- "..", "..", "honeynode", sim[1], "honeynode-simulator", "honeycomb-tpce")
+ '..', '..', 'honeynode', sim[1], 'honeynode-simulator', 'honeycomb-tpce')
sample_directory = os.path.join(os.path.dirname(os.path.realpath(__file__)),
- "..", "..", "sample_configs", "openroadm", sim[1])
+ '..', '..', 'sample_configs', 'openroadm', sim[1])
if os.path.isfile(executable):
with open(log_file, 'w', encoding='utf-8') as outfile:
return subprocess.Popen(
while True:
line = filelogs.readline()
if compiled_regexp.search(line):
- print("Pattern found!", end=' ')
+ print('Pattern found!', end=' ')
stringfound = True
break
if not line:
time.sleep(0.1)
except TimeoutError:
- print("Pattern not found after " + str(time_to_wait), end=" seconds! ", flush=True)
+ print('Pattern not found after ' + str(time_to_wait), end=' seconds! ', flush=True)
except PermissionError:
- print("Permission Error when trying to access the log file", end=" ... ", flush=True)
+ print('Permission Error when trying to access the log file', end=' ... ', flush=True)
finally:
if filefound:
filelogs.close()
else:
- print("log file does not exist or is not accessible... ", flush=True)
+ print('log file does not exist or is not accessible... ', flush=True)
return stringfound
def __exit__(self, type, value, traceback):
# pylint: disable=W0622
signal.alarm(0)
+
+#
+# Basic NetCONF device operations
+#
+
+
+def mount_device(node: str, sim: str):
+ url = {'rfc8040': '{}/data/network-topology:network-topology/topology=topology-netconf/node={}',
+ 'draft-bierman02': '{}/config/network-topology:network-topology/topology/topology-netconf/node/{}'}
+ body = {'node': [{
+ 'node-id': node,
+ 'netconf-node-topology:username': NODES_LOGIN,
+ 'netconf-node-topology:password': NODES_PWD,
+ 'netconf-node-topology:host': '127.0.0.1',
+ 'netconf-node-topology:port': SIMS[sim]['port'],
+ '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, '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)
+ if response.status_code == requests.codes.ok:
+ print('It was probably loaded at start-up', end='... ', flush=True)
+ # TODO an else-clause to abort test would probably be nice here
+ return response
+
+
+def unmount_device(node: str):
+ url = {'rfc8040': '{}/data/network-topology:network-topology/topology=topology-netconf/node={}',
+ 'draft-bierman02': '{}/config/network-topology:network-topology/topology/topology-netconf/node/{}'}
+ response = delete_request(url[RESTCONF_VERSION].format('{}', node))
+ if wait_until_log_contains(TPCE_LOG, re.escape("onDeviceDisConnected: " + node), 180):
+ print('Node ' + node + ' correctly deleted from tpce topology', end='... ', flush=True)
+ else:
+ print('Node ' + node + ' still not deleted from tpce topology', end='... ', flush=True)
+ return response
+
+
+def check_device_connection(node: str):
+ url = {'rfc8040': '{}/data/network-topology:network-topology/topology=topology-netconf/node={}?content=nonconfig',
+ 'draft-bierman02': '{}/operational/network-topology:network-topology/topology/topology-netconf/node/{}'}
+ response = get_request(url[RESTCONF_VERSION].format('{}', node))
+ res = response.json()
+ return_key = {'rfc8040': 'network-topology:node',
+ 'draft-bierman02': 'node'}
+ if return_key[RESTCONF_VERSION] in res.keys():
+ connection_status = res[return_key[RESTCONF_VERSION]][0]['netconf-node-topology:connection-status']
+ else:
+ connection_status = res['errors']['error'][0]
+ return {'status_code': response.status_code,
+ 'connection-status': connection_status}
+
+
+def check_node_request(node: str):
+ # pylint: disable=line-too-long
+ url = {'rfc8040': '{}/data/network-topology:network-topology/topology=topology-netconf/node={}/yang-ext:mount/org-openroadm-device:org-openroadm-device?content=config', # nopep8
+ 'draft-bierman02': '{}/config/network-topology:network-topology/topology/topology-netconf/node/{}/yang-ext:mount/org-openroadm-device:org-openroadm-device'} # nopep8
+ response = get_request(url[RESTCONF_VERSION].format('{}', node))
+ res = response.json()
+ return_key = {'rfc8040': 'org-openroadm-device:org-openroadm-device',
+ 'draft-bierman02': 'org-openroadm-device'}
+ if return_key[RESTCONF_VERSION] in res.keys():
+ response_attribute = res[return_key[RESTCONF_VERSION]]
+ else:
+ response_attribute = res['errors']['error'][0]
+ return {'status_code': response.status_code,
+ 'org-openroadm-device': response_attribute}
+
+
+def check_node_attribute_request(node: str, attribute: str, attribute_value: str):
+ # pylint: disable=line-too-long
+ url = {'rfc8040': '{}/data/network-topology:network-topology/topology=topology-netconf/node={}/yang-ext:mount/org-openroadm-device:org-openroadm-device/{}={}?content=nonconfig', # nopep8
+ 'draft-bierman02': '{}/operational/network-topology:network-topology/topology/topology-netconf/node/{}/yang-ext:mount/org-openroadm-device:org-openroadm-device/{}/{}'} # nopep8
+ response = get_request(url[RESTCONF_VERSION].format('{}', node, attribute, attribute_value))
+ res = response.json()
+ return_key = {'rfc8040': 'org-openroadm-device:' + attribute,
+ 'draft-bierman02': attribute}
+ if return_key[RESTCONF_VERSION] in res.keys():
+ response_attribute = res[return_key[RESTCONF_VERSION]]
+ else:
+ response_attribute = res['errors']['error'][0]
+ return {'status_code': response.status_code,
+ attribute: response_attribute}
+
+
+def check_node_attribute2_request(node: str, attribute: str, attribute_value: str, attribute2: str):
+ # pylint: disable=line-too-long
+ url = {'rfc8040': '{}/data/network-topology:network-topology/topology=topology-netconf/node={}/yang-ext:mount/org-openroadm-device:org-openroadm-device/{}={}/{}?content=config', # nopep8
+ 'draft-bierman02': '{}/config/network-topology:network-topology/topology/topology-netconf/node/{}/yang-ext:mount/org-openroadm-device:org-openroadm-device/{}/{}/{}'} # nopep8
+ response = get_request(url[RESTCONF_VERSION].format('{}', node, attribute, attribute_value, attribute2))
+ res = response.json()
+ if attribute2 in res.keys():
+ response_attribute = res[attribute2]
+ else:
+ response_attribute = res['errors']['error'][0]
+ return {'status_code': response.status_code,
+ attribute2: response_attribute}
+
+
+def del_node_attribute_request(node: str, attribute: str, attribute_value: str):
+ # pylint: disable=line-too-long
+ url = {'rfc8040': '{}/data/network-topology:network-topology/topology=topology-netconf/node={}/yang-ext:mount/org-openroadm-device:org-openroadm-device/{}={}', # nopep8
+ 'draft-bierman02': '{}/config/network-topology:network-topology/topology/topology-netconf/node/{}/yang-ext:mount/org-openroadm-device:org-openroadm-device/{}/{}'} # nopep8
+ response = delete_request(url[RESTCONF_VERSION].format('{}', node, attribute, attribute_value))
+ return response
+
+#
+# Portmapping operations
+#
+
+
+def post_portmapping(payload: str):
+ url = {'rfc8040': '{}/data/transportpce-portmapping:network',
+ 'draft-bierman02': '{}/config/transportpce-portmapping:network'}
+ json_payload = json.loads(payload)
+ response = post_request(url[RESTCONF_VERSION].format('{}'), json_payload)
+ return {'status_code': response.status_code}
+
+
+def del_portmapping():
+ url = {'rfc8040': '{}/data/transportpce-portmapping:network',
+ 'draft-bierman02': '{}/config/transportpce-portmapping:network'}
+ response = delete_request(url[RESTCONF_VERSION].format('{}'))
+ return {'status_code': response.status_code}
+
+
+def get_portmapping_node_attr(node: str, attr: str, value: str):
+ # pylint: disable=consider-using-f-string
+ url = {'rfc8040': '{}/data/transportpce-portmapping:network/nodes={}',
+ 'draft-bierman02': '{}/config/transportpce-portmapping:network/nodes/{}'}
+ target_url = url[RESTCONF_VERSION].format('{}', node)
+ if attr is not None:
+ target_url = (target_url + '/{}').format('{}', attr)
+ if value is not None:
+ suffix = {'rfc8040': '={}', 'draft-bierman02': '/{}'}
+ target_url = (target_url + suffix[RESTCONF_VERSION]).format('{}', value)
+ else:
+ attr = 'nodes'
+ response = get_request(target_url)
+ res = response.json()
+ return_key = {'rfc8040': 'transportpce-portmapping:' + attr,
+ 'draft-bierman02': attr}
+ if return_key[RESTCONF_VERSION] in res.keys():
+ return_output = res[return_key[RESTCONF_VERSION]]
+ else:
+ return_output = res['errors']['error'][0]
+ return {'status_code': response.status_code,
+ attr: return_output}
+
+#
+# Topology operations
+#
+
+
+def get_ietf_network_request(network: str, content: str):
+ url = {'rfc8040': '{}/data/ietf-network:networks/network={}?content={}',
+ 'draft-bierman02': '{}/{}/ietf-network:networks/network/{}'}
+ if RESTCONF_VERSION == 'rfc8040':
+ format_args = ('{}', network, content)
+ elif content == 'config':
+ format_args = ('{}', content, network)
+ else:
+ format_args = ('{}', 'operational', network)
+ response = get_request(url[RESTCONF_VERSION].format(*format_args))
+ if bool(response):
+ res = response.json()
+ return_key = {'rfc8040': 'ietf-network:network',
+ 'draft-bierman02': 'network'}
+ networks = res[return_key[RESTCONF_VERSION]]
+ else:
+ networks = None
+ return {'status_code': response.status_code,
+ 'network': networks}
+
+
+def put_ietf_network(network: str, payload: str):
+ url = {'rfc8040': '{}/data/ietf-network:networks/network={}',
+ 'draft-bierman02': '{}/config/ietf-network:networks/network/{}'}
+ json_payload = json.loads(payload)
+ response = put_request(url[RESTCONF_VERSION].format('{}', network), json_payload)
+ return {'status_code': response.status_code}
+
+
+def del_ietf_network(network: str):
+ url = {'rfc8040': '{}/data/ietf-network:networks/network={}',
+ 'draft-bierman02': '{}/config/ietf-network:networks/network/{}'}
+ response = delete_request(url[RESTCONF_VERSION].format('{}', network))
+ return {'status_code': response.status_code}
+
+
+def get_ietf_network_link_request(network: str, link: str, content: str):
+ url = {'rfc8040': '{}/data/ietf-network:networks/network={}/ietf-network-topology:link={}?content={}',
+ 'draft-bierman02': '{}/{}/ietf-network:networks/network/{}/ietf-network-topology:link/{}'}
+ if RESTCONF_VERSION == 'rfc8040':
+ format_args = ('{}', network, link, content)
+ elif content == 'config':
+ format_args = ('{}', content, network, link)
+ else:
+ format_args = ('{}', 'operational', network, link)
+ response = get_request(url[RESTCONF_VERSION].format(*format_args))
+ res = response.json()
+ return_key = {'rfc8040': 'ietf-network-topology:link',
+ 'draft-bierman02': 'ietf-network-topology:link'}
+ link = res[return_key[RESTCONF_VERSION]][0]
+ return {'status_code': response.status_code,
+ 'link': link}
+
+
+def del_ietf_network_link_request(network: str, link: str, content: str):
+ url = {'rfc8040': '{}/data/ietf-network:networks/network={}/ietf-network-topology:link={}?content={}',
+ 'draft-bierman02': '{}/{}/ietf-network:networks/network/{}/ietf-network-topology:link/{}'}
+ if RESTCONF_VERSION == 'rfc8040':
+ format_args = ('{}', network, link, content)
+ elif content == 'config':
+ format_args = ('{}', content, network, link)
+ else:
+ format_args = ('{}', 'operational', network, link)
+ response = delete_request(url[RESTCONF_VERSION].format(*format_args))
+ return response
+
+
+def add_oms_attr_request(link: str, oms_attr: str):
+ url = {'rfc8040': '{}/data/ietf-network:networks/network={}/ietf-network-topology:link={}',
+ 'draft-bierman02': '{}/config/ietf-network:networks/network/{}/ietf-network-topology:link/{}'}
+ url2 = url[RESTCONF_VERSION] + '/org-openroadm-network-topology:OMS-attributes/span'
+ network = 'openroadm-topology'
+ response = put_request(url2.format('{}', network, link), oms_attr)
+ return response
+
+
+def del_oms_attr_request(link: str,):
+ url = {'rfc8040': '{}/data/ietf-network:networks/network={}/ietf-network-topology:link={}',
+ 'draft-bierman02': '{}/config/ietf-network:networks/network/{}/ietf-network-topology:link/{}'}
+ url2 = url[RESTCONF_VERSION] + '/org-openroadm-network-topology:OMS-attributes/span'
+ network = 'openroadm-topology'
+ response = delete_request(url2.format('{}', network, link))
+ return response
+
+
+def get_ietf_network_node_request(network: str, node: str, content: str):
+ url = {'rfc8040': '{}/data/ietf-network:networks/network={}/node={}?content={}',
+ 'draft-bierman02': '{}/{}/ietf-network:networks/network/{}/node/{}'}
+ if RESTCONF_VERSION == 'rfc8040':
+ format_args = ('{}', network, node, content)
+ elif content == 'config':
+ format_args = ('{}', content, network, node)
+ else:
+ format_args = ('{}', 'operational', network, node)
+ response = get_request(url[RESTCONF_VERSION].format(*format_args))
+ if bool(response):
+ res = response.json()
+ return_key = {'rfc8040': 'ietf-network:node',
+ 'draft-bierman02': 'node'}
+ node = res[return_key[RESTCONF_VERSION]][0]
+ else:
+ node = None
+ return {'status_code': response.status_code,
+ 'node': node}
+
+
+def del_ietf_network_node_request(network: str, node: str, content: str):
+ url = {'rfc8040': '{}/data/ietf-network:networks/network={}/node={}?content={}',
+ 'draft-bierman02': '{}/{}/ietf-network:networks/network/{}/node/{}'}
+ if RESTCONF_VERSION == 'rfc8040':
+ format_args = ('{}', network, node, content)
+ elif content == 'config':
+ format_args = ('{}', content, network, node)
+ else:
+ format_args = ('{}', 'operational', network, node)
+ response = delete_request(url[RESTCONF_VERSION].format(*format_args))
+ return response
+
+
+#
+# Service list operations
+#
+
+
+def get_ordm_serv_list_request():
+ url = {'rfc8040': '{}/data/org-openroadm-service:service-list?content=nonconfig',
+ 'draft-bierman02': '{}/operational/org-openroadm-service:service-list/'}
+ response = get_request(url[RESTCONF_VERSION])
+ res = response.json()
+ return_key = {'rfc8040': 'org-openroadm-service:service-list',
+ 'draft-bierman02': 'service-list'}
+ if return_key[RESTCONF_VERSION] in res.keys():
+ response_attribute = res[return_key[RESTCONF_VERSION]]
+ else:
+ response_attribute = res['errors']['error'][0]
+ return {'status_code': response.status_code,
+ 'service-list': response_attribute}
+
+
+def get_ordm_serv_list_attr_request(attribute: str, value: str):
+ url = {'rfc8040': '{}/data/org-openroadm-service:service-list/{}={}?content=nonconfig',
+ 'draft-bierman02': '{}/operational/org-openroadm-service:service-list/{}/{}'}
+ if RESTCONF_VERSION == 'rfc8040':
+ format_args = ('{}', attribute, value)
+ else:
+ format_args = ('{}', attribute, value)
+ response = get_request(url[RESTCONF_VERSION].format(*format_args))
+ res = response.json()
+ return_key = {'rfc8040': 'org-openroadm-service:' + attribute,
+ 'draft-bierman02': attribute}
+ if return_key[RESTCONF_VERSION] in res.keys():
+ response_attribute = res[return_key[RESTCONF_VERSION]]
+ else:
+ response_attribute = res['errors']['error'][0]
+ return {'status_code': response.status_code,
+ attribute: response_attribute}
+
+
+def get_serv_path_list_attr(attribute: str, value: str):
+ url = {'rfc8040': '{}/data/transportpce-service-path:service-path-list/{}={}?content=nonconfig',
+ 'draft-bierman02': '{}/operational/transportpce-service-path:service-path-list/{}/{}'}
+ response = get_request(url[RESTCONF_VERSION].format('{}', attribute, value))
+ res = response.json()
+ return_key = {'rfc8040': 'transportpce-service-path:' + attribute,
+ 'draft-bierman02': attribute}
+ if return_key[RESTCONF_VERSION] in res.keys():
+ response_attribute = res[return_key[RESTCONF_VERSION]]
+ else:
+ response_attribute = res['errors']['error'][0]
+ return {'status_code': response.status_code,
+ attribute: response_attribute}
+
+
+#
+# TransportPCE internal API RPCs
+#
+
+
+def prepend_dict_keys(input_dict: dict, prefix: str):
+ return_dict = {}
+ for key, value in input_dict.items():
+ newkey = prefix + key
+ if isinstance(value, dict):
+ return_dict[newkey] = prepend_dict_keys(value, prefix)
+ # TODO: perhaps some recursion depth limit or another solution has to be considered here
+ # even if recursion depth is given by the input_dict argument
+ # direct (self-)recursive functions may carry unwanted side-effects such as ressource consumptions
+ else:
+ return_dict[newkey] = value
+ return return_dict
+
+
+def transportpce_api_rpc_request(api_module: str, rpc: str, payload: dict):
+ # pylint: disable=consider-using-f-string
+ url = "{}/operations/{}:{}".format('{}', api_module, rpc)
+ if payload is None:
+ data = None
+ elif RESTCONF_VERSION == 'draft-bierman02':
+ data = prepend_dict_keys({'input': payload}, api_module + ':')
+ else:
+ data = {'input': payload}
+ response = post_request(url, data)
+ if response.status_code == requests.codes.no_content:
+ return_output = None
+ else:
+ res = response.json()
+ return_key = {'rfc8040': api_module + ':output',
+ 'draft-bierman02': 'output'}
+ if response.status_code == requests.codes.internal_server_error:
+ return_output = res
+ else:
+ return_output = res[return_key[RESTCONF_VERSION]]
+ return {'status_code': response.status_code,
+ 'output': return_output}
+++ /dev/null
-#!/usr/bin/env python
-
-##############################################################################
-# Copyright (c) 2021 Orange, Inc. and others. All rights reserved.
-#
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-##############################################################################
-
-# pylint: disable=no-member
-
-import json
-import os
-# pylint: disable=wrong-import-order
-import sys
-import re
-import signal
-import subprocess
-import time
-
-import psutil
-import requests
-
-# pylint: disable=import-error
-import simulators
-
-SIMS = simulators.SIMS
-
-HONEYNODE_OK_START_MSG = 'Netconf SSH endpoint started successfully at 0.0.0.0'
-KARAF_OK_START_MSG = "Blueprint container for bundle org.opendaylight.netconf.restconf.* was successfully created"
-LIGHTY_OK_START_MSG = re.escape("lighty.io and RESTCONF-NETCONF started")
-
-ODL_LOGIN = 'admin'
-ODL_PWD = 'admin'
-NODES_LOGIN = 'admin'
-NODES_PWD = 'admin'
-
-TYPE_APPLICATION_JSON = {'Content-Type': 'application/json', 'Accept': 'application/json'}
-TYPE_APPLICATION_XML = {'Content-Type': 'application/xml', 'Accept': 'application/xml'}
-
-REQUEST_TIMEOUT = 10
-
-CODE_SHOULD_BE_200 = 'Http status code should be 200'
-CODE_SHOULD_BE_201 = 'Http status code should be 201'
-T100GE = 'Transponder 100GE'
-T0_MULTILAYER_TOPO = 'T0 - Multi-layer topology'
-T0_FULL_MULTILAYER_TOPO = 'T0 - Full Multi-layer topology'
-
-SIM_LOG_DIRECTORY = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'log')
-
-process_list = []
-
-if 'USE_ODL_ALT_RESTCONF_PORT' in os.environ:
- RESTCONF_PORT = os.environ['USE_ODL_ALT_RESTCONF_PORT']
-else:
- RESTCONF_PORT = 8181
-
-RESTCONF_PATH_PREFIX = {'rfc8040': '/rests',
- 'draft-bierman02': '/restconf'}
-if 'USE_ODL_RESTCONF_VERSION' in os.environ:
- RESTCONF_VERSION = os.environ['USE_ODL_RESTCONF_VERSION']
- if RESTCONF_VERSION not in RESTCONF_PATH_PREFIX:
- print('unsupported RESTCONF version ' + RESTCONF_VERSION)
- sys.exit(3)
-else:
- RESTCONF_VERSION = 'rfc8040'
-
-RESTCONF_BASE_URL = 'http://localhost:' + str(RESTCONF_PORT) + RESTCONF_PATH_PREFIX[RESTCONF_VERSION]
-
-if 'USE_ODL_ALT_KARAF_INSTALL_DIR' in os.environ:
- KARAF_INSTALLDIR = os.environ['USE_ODL_ALT_KARAF_INSTALL_DIR']
-else:
- KARAF_INSTALLDIR = 'karaf'
-
-KARAF_LOG = os.path.join(
- os.path.dirname(os.path.realpath(__file__)),
- '..', '..', '..', KARAF_INSTALLDIR, 'target', 'assembly', 'data', 'log', 'karaf.log')
-
-if 'USE_LIGHTY' in os.environ and os.environ['USE_LIGHTY'] == 'True':
- TPCE_LOG = 'odl-' + str(os.getpid()) + '.log'
-else:
- TPCE_LOG = KARAF_LOG
-
-#
-# Basic HTTP operations
-#
-
-
-def get_request(url):
- return requests.request(
- 'GET', url.format(RESTCONF_BASE_URL),
- headers=TYPE_APPLICATION_JSON,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
-
-
-def put_request(url, data):
- return requests.request(
- 'PUT', url.format(RESTCONF_BASE_URL),
- data=json.dumps(data),
- headers=TYPE_APPLICATION_JSON,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
-
-
-def delete_request(url):
- return requests.request(
- 'DELETE', url.format(RESTCONF_BASE_URL),
- headers=TYPE_APPLICATION_JSON,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
-
-
-def post_request(url, data):
- if data:
- return requests.request(
- "POST", url.format(RESTCONF_BASE_URL),
- data=json.dumps(data),
- headers=TYPE_APPLICATION_JSON,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
- return requests.request(
- "POST", url.format(RESTCONF_BASE_URL),
- headers=TYPE_APPLICATION_JSON,
- auth=(ODL_LOGIN, ODL_PWD),
- timeout=REQUEST_TIMEOUT)
-
-#
-# Process management
-#
-
-
-def start_sims(sims_list):
- for sim in sims_list:
- print('starting simulator ' + sim[0] + ' in OpenROADM device version ' + sim[1] + '...')
- log_file = os.path.join(SIM_LOG_DIRECTORY, SIMS[sim]['logfile'])
- process = start_honeynode(log_file, sim)
- if wait_until_log_contains(log_file, HONEYNODE_OK_START_MSG, 100):
- print('simulator for ' + sim[0] + ' started')
- else:
- print('simulator for ' + sim[0] + ' failed to start')
- shutdown_process(process)
- for pid in process_list:
- shutdown_process(pid)
- sys.exit(3)
- process_list.append(process)
- return process_list
-
-
-def start_tpce():
- print('starting OpenDaylight...')
- if 'USE_LIGHTY' in os.environ and os.environ['USE_LIGHTY'] == 'True':
- process = start_lighty()
- start_msg = LIGHTY_OK_START_MSG
- else:
- process = start_karaf()
- start_msg = KARAF_OK_START_MSG
- if wait_until_log_contains(TPCE_LOG, start_msg, time_to_wait=300):
- print('OpenDaylight started !')
- else:
- print('OpenDaylight failed to start !')
- shutdown_process(process)
- for pid in process_list:
- shutdown_process(pid)
- sys.exit(1)
- process_list.append(process)
- return process_list
-
-
-def start_karaf():
- print('starting KARAF TransportPCE build...')
- executable = os.path.join(
- os.path.dirname(os.path.realpath(__file__)),
- '..', '..', '..', KARAF_INSTALLDIR, 'target', 'assembly', 'bin', 'karaf')
- with open('odl.log', 'w', encoding='utf-8') as outfile:
- return subprocess.Popen(
- ['sh', executable, 'server'], stdout=outfile, stderr=outfile, stdin=None)
-
-
-def start_lighty():
- print('starting LIGHTY.IO TransportPCE build...')
- executable = os.path.join(
- os.path.dirname(os.path.realpath(__file__)),
- '..', '..', '..', 'lighty', 'target', 'tpce',
- 'clean-start-controller.sh')
- with open(TPCE_LOG, 'w', encoding='utf-8') as outfile:
- return subprocess.Popen(
- ['sh', executable], stdout=outfile, stderr=outfile, stdin=None)
-
-
-def install_karaf_feature(feature_name: str):
- print('installing feature ' + feature_name)
- executable = os.path.join(
- os.path.dirname(os.path.realpath(__file__)),
- '..', '..', '..', KARAF_INSTALLDIR, 'target', 'assembly', 'bin', 'client')
- return subprocess.run([executable],
- input='feature:install ' + feature_name + '\n feature:list | grep '
- + feature_name + ' \n logout \n',
- universal_newlines=True, check=False)
-
-
-def shutdown_process(process):
- if process is not None:
- for child in psutil.Process(process.pid).children():
- child.send_signal(signal.SIGINT)
- child.wait()
- process.send_signal(signal.SIGINT)
-
-
-def start_honeynode(log_file: str, sim):
- executable = os.path.join(os.path.dirname(os.path.realpath(__file__)),
- '..', '..', 'honeynode', sim[1], 'honeynode-simulator', 'honeycomb-tpce')
- sample_directory = os.path.join(os.path.dirname(os.path.realpath(__file__)),
- '..', '..', 'sample_configs', 'openroadm', sim[1])
- if os.path.isfile(executable):
- with open(log_file, 'w', encoding='utf-8') as outfile:
- return subprocess.Popen(
- [executable, SIMS[sim]['port'], os.path.join(sample_directory, SIMS[sim]['configfile'])],
- stdout=outfile, stderr=outfile)
- return None
-
-
-def wait_until_log_contains(log_file, regexp, time_to_wait=60):
- # pylint: disable=lost-exception
- # pylint: disable=consider-using-with
- stringfound = False
- filefound = False
- line = None
- try:
- with TimeOut(seconds=time_to_wait):
- while not os.path.exists(log_file):
- time.sleep(0.2)
- filelogs = open(log_file, 'r', encoding='utf-8')
- filelogs.seek(0, 2)
- filefound = True
- print("Searching for pattern '" + regexp + "' in " + os.path.basename(log_file), end='... ', flush=True)
- compiled_regexp = re.compile(regexp)
- while True:
- line = filelogs.readline()
- if compiled_regexp.search(line):
- print('Pattern found!', end=' ')
- stringfound = True
- break
- if not line:
- time.sleep(0.1)
- except TimeoutError:
- print('Pattern not found after ' + str(time_to_wait), end=' seconds! ', flush=True)
- except PermissionError:
- print('Permission Error when trying to access the log file', end=' ... ', flush=True)
- finally:
- if filefound:
- filelogs.close()
- else:
- print('log file does not exist or is not accessible... ', flush=True)
- return stringfound
-
-
-class TimeOut:
- def __init__(self, seconds=1, error_message='Timeout'):
- self.seconds = seconds
- self.error_message = error_message
-
- def handle_timeout(self, signum, frame):
- raise TimeoutError(self.error_message)
-
- def __enter__(self):
- signal.signal(signal.SIGALRM, self.handle_timeout)
- signal.alarm(self.seconds)
-
- def __exit__(self, type, value, traceback):
- # pylint: disable=W0622
- signal.alarm(0)
-
-#
-# Basic NetCONF device operations
-#
-
-
-def mount_device(node: str, sim: str):
- url = {'rfc8040': '{}/data/network-topology:network-topology/topology=topology-netconf/node={}',
- 'draft-bierman02': '{}/config/network-topology:network-topology/topology/topology-netconf/node/{}'}
- body = {'node': [{
- 'node-id': node,
- 'netconf-node-topology:username': NODES_LOGIN,
- 'netconf-node-topology:password': NODES_PWD,
- 'netconf-node-topology:host': '127.0.0.1',
- 'netconf-node-topology:port': SIMS[sim]['port'],
- '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, '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)
- if response.status_code == requests.codes.ok:
- print('It was probably loaded at start-up', end='... ', flush=True)
- # TODO an else-clause to abort test would probably be nice here
- return response
-
-
-def unmount_device(node: str):
- url = {'rfc8040': '{}/data/network-topology:network-topology/topology=topology-netconf/node={}',
- 'draft-bierman02': '{}/config/network-topology:network-topology/topology/topology-netconf/node/{}'}
- response = delete_request(url[RESTCONF_VERSION].format('{}', node))
- if wait_until_log_contains(TPCE_LOG, re.escape("onDeviceDisConnected: " + node), 180):
- print('Node ' + node + ' correctly deleted from tpce topology', end='... ', flush=True)
- else:
- print('Node ' + node + ' still not deleted from tpce topology', end='... ', flush=True)
- return response
-
-
-def check_device_connection(node: str):
- url = {'rfc8040': '{}/data/network-topology:network-topology/topology=topology-netconf/node={}?content=nonconfig',
- 'draft-bierman02': '{}/operational/network-topology:network-topology/topology/topology-netconf/node/{}'}
- response = get_request(url[RESTCONF_VERSION].format('{}', node))
- res = response.json()
- return_key = {'rfc8040': 'network-topology:node',
- 'draft-bierman02': 'node'}
- if return_key[RESTCONF_VERSION] in res.keys():
- connection_status = res[return_key[RESTCONF_VERSION]][0]['netconf-node-topology:connection-status']
- else:
- connection_status = res['errors']['error'][0]
- return {'status_code': response.status_code,
- 'connection-status': connection_status}
-
-
-def check_node_request(node: str):
- # pylint: disable=line-too-long
- url = {'rfc8040': '{}/data/network-topology:network-topology/topology=topology-netconf/node={}/yang-ext:mount/org-openroadm-device:org-openroadm-device?content=config', # nopep8
- 'draft-bierman02': '{}/config/network-topology:network-topology/topology/topology-netconf/node/{}/yang-ext:mount/org-openroadm-device:org-openroadm-device'} # nopep8
- response = get_request(url[RESTCONF_VERSION].format('{}', node))
- res = response.json()
- return_key = {'rfc8040': 'org-openroadm-device:org-openroadm-device',
- 'draft-bierman02': 'org-openroadm-device'}
- if return_key[RESTCONF_VERSION] in res.keys():
- response_attribute = res[return_key[RESTCONF_VERSION]]
- else:
- response_attribute = res['errors']['error'][0]
- return {'status_code': response.status_code,
- 'org-openroadm-device': response_attribute}
-
-
-def check_node_attribute_request(node: str, attribute: str, attribute_value: str):
- # pylint: disable=line-too-long
- url = {'rfc8040': '{}/data/network-topology:network-topology/topology=topology-netconf/node={}/yang-ext:mount/org-openroadm-device:org-openroadm-device/{}={}?content=nonconfig', # nopep8
- 'draft-bierman02': '{}/operational/network-topology:network-topology/topology/topology-netconf/node/{}/yang-ext:mount/org-openroadm-device:org-openroadm-device/{}/{}'} # nopep8
- response = get_request(url[RESTCONF_VERSION].format('{}', node, attribute, attribute_value))
- res = response.json()
- return_key = {'rfc8040': 'org-openroadm-device:' + attribute,
- 'draft-bierman02': attribute}
- if return_key[RESTCONF_VERSION] in res.keys():
- response_attribute = res[return_key[RESTCONF_VERSION]]
- else:
- response_attribute = res['errors']['error'][0]
- return {'status_code': response.status_code,
- attribute: response_attribute}
-
-
-def check_node_attribute2_request(node: str, attribute: str, attribute_value: str, attribute2: str):
- # pylint: disable=line-too-long
- url = {'rfc8040': '{}/data/network-topology:network-topology/topology=topology-netconf/node={}/yang-ext:mount/org-openroadm-device:org-openroadm-device/{}={}/{}?content=config', # nopep8
- 'draft-bierman02': '{}/config/network-topology:network-topology/topology/topology-netconf/node/{}/yang-ext:mount/org-openroadm-device:org-openroadm-device/{}/{}/{}'} # nopep8
- response = get_request(url[RESTCONF_VERSION].format('{}', node, attribute, attribute_value, attribute2))
- res = response.json()
- if attribute2 in res.keys():
- response_attribute = res[attribute2]
- else:
- response_attribute = res['errors']['error'][0]
- return {'status_code': response.status_code,
- attribute2: response_attribute}
-
-
-def del_node_attribute_request(node: str, attribute: str, attribute_value: str):
- # pylint: disable=line-too-long
- url = {'rfc8040': '{}/data/network-topology:network-topology/topology=topology-netconf/node={}/yang-ext:mount/org-openroadm-device:org-openroadm-device/{}={}', # nopep8
- 'draft-bierman02': '{}/config/network-topology:network-topology/topology/topology-netconf/node/{}/yang-ext:mount/org-openroadm-device:org-openroadm-device/{}/{}'} # nopep8
- response = delete_request(url[RESTCONF_VERSION].format('{}', node, attribute, attribute_value))
- return response
-
-#
-# Portmapping operations
-#
-
-
-def post_portmapping(payload: str):
- url = {'rfc8040': '{}/data/transportpce-portmapping:network',
- 'draft-bierman02': '{}/config/transportpce-portmapping:network'}
- json_payload = json.loads(payload)
- response = post_request(url[RESTCONF_VERSION].format('{}'), json_payload)
- return {'status_code': response.status_code}
-
-
-def del_portmapping():
- url = {'rfc8040': '{}/data/transportpce-portmapping:network',
- 'draft-bierman02': '{}/config/transportpce-portmapping:network'}
- response = delete_request(url[RESTCONF_VERSION].format('{}'))
- return {'status_code': response.status_code}
-
-
-def get_portmapping_node_attr(node: str, attr: str, value: str):
- # pylint: disable=consider-using-f-string
- url = {'rfc8040': '{}/data/transportpce-portmapping:network/nodes={}',
- 'draft-bierman02': '{}/config/transportpce-portmapping:network/nodes/{}'}
- target_url = url[RESTCONF_VERSION].format('{}', node)
- if attr is not None:
- target_url = (target_url + '/{}').format('{}', attr)
- if value is not None:
- suffix = {'rfc8040': '={}', 'draft-bierman02': '/{}'}
- target_url = (target_url + suffix[RESTCONF_VERSION]).format('{}', value)
- else:
- attr = 'nodes'
- response = get_request(target_url)
- res = response.json()
- return_key = {'rfc8040': 'transportpce-portmapping:' + attr,
- 'draft-bierman02': attr}
- if return_key[RESTCONF_VERSION] in res.keys():
- return_output = res[return_key[RESTCONF_VERSION]]
- else:
- return_output = res['errors']['error'][0]
- return {'status_code': response.status_code,
- attr: return_output}
-
-#
-# Topology operations
-#
-
-
-def get_ietf_network_request(network: str, content: str):
- url = {'rfc8040': '{}/data/ietf-network:networks/network={}?content={}',
- 'draft-bierman02': '{}/{}/ietf-network:networks/network/{}'}
- if RESTCONF_VERSION == 'rfc8040':
- format_args = ('{}', network, content)
- elif content == 'config':
- format_args = ('{}', content, network)
- else:
- format_args = ('{}', 'operational', network)
- response = get_request(url[RESTCONF_VERSION].format(*format_args))
- if bool(response):
- res = response.json()
- return_key = {'rfc8040': 'ietf-network:network',
- 'draft-bierman02': 'network'}
- networks = res[return_key[RESTCONF_VERSION]]
- else:
- networks = None
- return {'status_code': response.status_code,
- 'network': networks}
-
-
-def put_ietf_network(network: str, payload: str):
- url = {'rfc8040': '{}/data/ietf-network:networks/network={}',
- 'draft-bierman02': '{}/config/ietf-network:networks/network/{}'}
- json_payload = json.loads(payload)
- response = put_request(url[RESTCONF_VERSION].format('{}', network), json_payload)
- return {'status_code': response.status_code}
-
-
-def del_ietf_network(network: str):
- url = {'rfc8040': '{}/data/ietf-network:networks/network={}',
- 'draft-bierman02': '{}/config/ietf-network:networks/network/{}'}
- response = delete_request(url[RESTCONF_VERSION].format('{}', network))
- return {'status_code': response.status_code}
-
-
-def get_ietf_network_link_request(network: str, link: str, content: str):
- url = {'rfc8040': '{}/data/ietf-network:networks/network={}/ietf-network-topology:link={}?content={}',
- 'draft-bierman02': '{}/{}/ietf-network:networks/network/{}/ietf-network-topology:link/{}'}
- if RESTCONF_VERSION == 'rfc8040':
- format_args = ('{}', network, link, content)
- elif content == 'config':
- format_args = ('{}', content, network, link)
- else:
- format_args = ('{}', 'operational', network, link)
- response = get_request(url[RESTCONF_VERSION].format(*format_args))
- res = response.json()
- return_key = {'rfc8040': 'ietf-network-topology:link',
- 'draft-bierman02': 'ietf-network-topology:link'}
- link = res[return_key[RESTCONF_VERSION]][0]
- return {'status_code': response.status_code,
- 'link': link}
-
-
-def del_ietf_network_link_request(network: str, link: str, content: str):
- url = {'rfc8040': '{}/data/ietf-network:networks/network={}/ietf-network-topology:link={}?content={}',
- 'draft-bierman02': '{}/{}/ietf-network:networks/network/{}/ietf-network-topology:link/{}'}
- if RESTCONF_VERSION == 'rfc8040':
- format_args = ('{}', network, link, content)
- elif content == 'config':
- format_args = ('{}', content, network, link)
- else:
- format_args = ('{}', 'operational', network, link)
- response = delete_request(url[RESTCONF_VERSION].format(*format_args))
- return response
-
-
-def add_oms_attr_request(link: str, oms_attr: str):
- url = {'rfc8040': '{}/data/ietf-network:networks/network={}/ietf-network-topology:link={}',
- 'draft-bierman02': '{}/config/ietf-network:networks/network/{}/ietf-network-topology:link/{}'}
- url2 = url[RESTCONF_VERSION] + '/org-openroadm-network-topology:OMS-attributes/span'
- network = 'openroadm-topology'
- response = put_request(url2.format('{}', network, link), oms_attr)
- return response
-
-
-def del_oms_attr_request(link: str,):
- url = {'rfc8040': '{}/data/ietf-network:networks/network={}/ietf-network-topology:link={}',
- 'draft-bierman02': '{}/config/ietf-network:networks/network/{}/ietf-network-topology:link/{}'}
- url2 = url[RESTCONF_VERSION] + '/org-openroadm-network-topology:OMS-attributes/span'
- network = 'openroadm-topology'
- response = delete_request(url2.format('{}', network, link))
- return response
-
-
-def get_ietf_network_node_request(network: str, node: str, content: str):
- url = {'rfc8040': '{}/data/ietf-network:networks/network={}/node={}?content={}',
- 'draft-bierman02': '{}/{}/ietf-network:networks/network/{}/node/{}'}
- if RESTCONF_VERSION == 'rfc8040':
- format_args = ('{}', network, node, content)
- elif content == 'config':
- format_args = ('{}', content, network, node)
- else:
- format_args = ('{}', 'operational', network, node)
- response = get_request(url[RESTCONF_VERSION].format(*format_args))
- if bool(response):
- res = response.json()
- return_key = {'rfc8040': 'ietf-network:node',
- 'draft-bierman02': 'node'}
- node = res[return_key[RESTCONF_VERSION]][0]
- else:
- node = None
- return {'status_code': response.status_code,
- 'node': node}
-
-
-def del_ietf_network_node_request(network: str, node: str, content: str):
- url = {'rfc8040': '{}/data/ietf-network:networks/network={}/node={}?content={}',
- 'draft-bierman02': '{}/{}/ietf-network:networks/network/{}/node/{}'}
- if RESTCONF_VERSION == 'rfc8040':
- format_args = ('{}', network, node, content)
- elif content == 'config':
- format_args = ('{}', content, network, node)
- else:
- format_args = ('{}', 'operational', network, node)
- response = delete_request(url[RESTCONF_VERSION].format(*format_args))
- return response
-
-
-#
-# Service list operations
-#
-
-
-def get_ordm_serv_list_request():
- url = {'rfc8040': '{}/data/org-openroadm-service:service-list?content=nonconfig',
- 'draft-bierman02': '{}/operational/org-openroadm-service:service-list/'}
- response = get_request(url[RESTCONF_VERSION])
- res = response.json()
- return_key = {'rfc8040': 'org-openroadm-service:service-list',
- 'draft-bierman02': 'service-list'}
- if return_key[RESTCONF_VERSION] in res.keys():
- response_attribute = res[return_key[RESTCONF_VERSION]]
- else:
- response_attribute = res['errors']['error'][0]
- return {'status_code': response.status_code,
- 'service-list': response_attribute}
-
-
-def get_ordm_serv_list_attr_request(attribute: str, value: str):
- url = {'rfc8040': '{}/data/org-openroadm-service:service-list/{}={}?content=nonconfig',
- 'draft-bierman02': '{}/operational/org-openroadm-service:service-list/{}/{}'}
- if RESTCONF_VERSION == 'rfc8040':
- format_args = ('{}', attribute, value)
- else:
- format_args = ('{}', attribute, value)
- response = get_request(url[RESTCONF_VERSION].format(*format_args))
- res = response.json()
- return_key = {'rfc8040': 'org-openroadm-service:' + attribute,
- 'draft-bierman02': attribute}
- if return_key[RESTCONF_VERSION] in res.keys():
- response_attribute = res[return_key[RESTCONF_VERSION]]
- else:
- response_attribute = res['errors']['error'][0]
- return {'status_code': response.status_code,
- attribute: response_attribute}
-
-
-def get_serv_path_list_attr(attribute: str, value: str):
- url = {'rfc8040': '{}/data/transportpce-service-path:service-path-list/{}={}?content=nonconfig',
- 'draft-bierman02': '{}/operational/transportpce-service-path:service-path-list/{}/{}'}
- response = get_request(url[RESTCONF_VERSION].format('{}', attribute, value))
- res = response.json()
- return_key = {'rfc8040': 'transportpce-service-path:' + attribute,
- 'draft-bierman02': attribute}
- if return_key[RESTCONF_VERSION] in res.keys():
- response_attribute = res[return_key[RESTCONF_VERSION]]
- else:
- response_attribute = res['errors']['error'][0]
- return {'status_code': response.status_code,
- attribute: response_attribute}
-
-
-#
-# TransportPCE internal API RPCs
-#
-
-
-def prepend_dict_keys(input_dict: dict, prefix: str):
- return_dict = {}
- for key, value in input_dict.items():
- newkey = prefix + key
- if isinstance(value, dict):
- return_dict[newkey] = prepend_dict_keys(value, prefix)
- # TODO: perhaps some recursion depth limit or another solution has to be considered here
- # even if recursion depth is given by the input_dict argument
- # direct (self-)recursive functions may carry unwanted side-effects such as ressource consumptions
- else:
- return_dict[newkey] = value
- return return_dict
-
-
-def transportpce_api_rpc_request(api_module: str, rpc: str, payload: dict):
- # pylint: disable=consider-using-f-string
- url = "{}/operations/{}:{}".format('{}', api_module, rpc)
- if payload is None:
- data = None
- elif RESTCONF_VERSION == 'draft-bierman02':
- data = prepend_dict_keys({'input': payload}, api_module + ':')
- else:
- data = {'input': payload}
- response = post_request(url, data)
- if response.status_code == requests.codes.no_content:
- return_output = None
- else:
- res = response.json()
- return_key = {'rfc8040': api_module + ':output',
- 'draft-bierman02': 'output'}
- if response.status_code == requests.codes.internal_server_error:
- return_output = res
- else:
- return_output = res[return_key[RESTCONF_VERSION]]
- return {'status_code': response.status_code,
- 'output': return_output}
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEFulltesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION_121),
- ('roadma', cls.NODE_VERSION_221),
- ('roadmc', cls.NODE_VERSION_221),
- ('xpdrc', cls.NODE_VERSION_71)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION_121),
+ ('roadma', cls.NODE_VERSION_221),
+ ('roadmc', cls.NODE_VERSION_221),
+ ('xpdrc', cls.NODE_VERSION_71)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
time.sleep(3)
print("execution of {}".format(self.id().split(".")[-1]))
def test_01_connect_xpdrA(self):
- response = test_utils_rfc8040.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION_121))
+ response = test_utils.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION_121))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_connect_xpdrC(self):
- response = test_utils_rfc8040.mount_device("XPDR-C1", ('xpdrc', self.NODE_VERSION_71))
+ response = test_utils.mount_device("XPDR-C1", ('xpdrc', self.NODE_VERSION_71))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_connect_rdmA(self):
- response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION_221))
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION_221))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_04_connect_rdmC(self):
- response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION_221))
+ response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION_221))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-xpdr-rdm-links',
{'links-input': {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '1',
'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"])
def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-rdm-xpdr-links',
{'links-input': {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '1',
'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
self.assertIn('Roadm Xponder links created successfully', response["output"]["result"])
def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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.assertIn('Xponder Roadm Link created successfully', response["output"]["result"])
def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.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_11_create_eth_service1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_12_get_eth_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request(
+ response = test_utils.get_ordm_serv_list_attr_request(
"services", "service1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['services'][0]['administrative-state'], 'inService')
"administrative-state": "outOfService",
"port-qual": "xpdr-network"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8130/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
def test_14_check_update_portmapping(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDRA01", None, None)
+ response = test_utils.get_portmapping_node_attr("XPDRA01", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
mapping_list = response['nodes'][0]['mapping']
for mapping in mapping_list:
time.sleep(1)
def test_15_check_update_openroadm_topo(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
node_list = response['network'][0]['node']
nb_updated_tp = 0
time.sleep(1)
def test_16_check_update_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1")
+ response = test_utils.get_ordm_serv_list_attr_request("services", "service1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['services'][0]['operational-state'], 'outOfService')
self.assertEqual(response['services'][0]['administrative-state'], 'inService')
"administrative-state": "inService",
"port-qual": "xpdr-network"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8130/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
def test_18_check_update_portmapping_ok(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDRA01", None, None)
+ response = test_utils.get_portmapping_node_attr("XPDRA01", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
mapping_list = response['nodes'][0]['mapping']
for mapping in mapping_list:
time.sleep(1)
def test_19_check_update_openroadm_topo_ok(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
node_list = response['network'][0]['node']
for node in node_list:
"administrative-state": "outOfService",
"port-qual": "roadm-external"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
def test_22_check_update_portmapping(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", None, None)
+ response = test_utils.get_portmapping_node_attr("ROADM-A1", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
mapping_list = response['nodes'][0]['mapping']
for mapping in mapping_list:
time.sleep(1)
def test_23_check_update_openroadm_topo(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
node_list = response['network'][0]['node']
nb_updated_tp = 0
"administrative-state": "inService",
"port-qual": "roadm-external"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
"administrative-state": "outOfService",
"port-qual": "roadm-external"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
def test_29_check_update_portmapping(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", None, None)
+ response = test_utils.get_portmapping_node_attr("ROADM-A1", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
mapping_list = response['nodes'][0]['mapping']
for mapping in mapping_list:
time.sleep(1)
def test_30_check_update_openroadm_topo(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
node_list = response['network'][0]['node']
nb_updated_tp = 0
"administrative-state": "inService",
"port-qual": "roadm-external"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
"administrative-state": "outOfService",
"port-qual": "xpdr-network"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8154/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
def test_36_check_update_portmapping(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-C1", None, None)
+ response = test_utils.get_portmapping_node_attr("XPDR-C1", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
mapping_list = response['nodes'][0]['mapping']
for mapping in mapping_list:
time.sleep(1)
def test_37_check_update_openroadm_topo(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
node_list = response['network'][0]['node']
nb_updated_tp = 0
"administrative-state": "inService",
"port-qual": "xpdr-network"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8154/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
"administrative-state": "outOfService",
"port-qual": "roadm-external"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
def test_43_check_update_portmapping(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", None, None)
+ response = test_utils.get_portmapping_node_attr("ROADM-A1", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
mapping_list = response['nodes'][0]['mapping']
for mapping in mapping_list:
time.sleep(1)
def test_44_check_update_openroadm_topo(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
node_list = response['network'][0]['node']
nb_updated_tp = 0
def test_46_delete_eth_service1(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_47_disconnect_xponders_from_roadm(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.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'):
- response = test_utils_rfc8040.del_ietf_network_link_request(
+ response = test_utils.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_48_disconnect_XPDRA(self):
- response = test_utils_rfc8040.unmount_device("XPDRA01")
+ response = test_utils.unmount_device("XPDRA01")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_49_disconnect_XPDRC(self):
- response = test_utils_rfc8040.unmount_device("XPDR-C1")
+ response = test_utils.unmount_device("XPDR-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_50_disconnect_ROADMA(self):
- response = test_utils_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_51_disconnect_ROADMC(self):
- response = test_utils_rfc8040.unmount_device("ROADM-C1")
+ response = test_utils.unmount_device("ROADM-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEtesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra2', cls.NODE_VERSION_71),
- ('roadma', cls.NODE_VERSION_221),
- ('roadmc', cls.NODE_VERSION_221),
- ('xpdrc2', cls.NODE_VERSION_71)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('xpdra2', cls.NODE_VERSION_71),
+ ('roadma', cls.NODE_VERSION_221),
+ ('roadmc', cls.NODE_VERSION_221),
+ ('xpdrc2', cls.NODE_VERSION_71)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(1)
def test_01_connect_xpdra2(self):
- response = test_utils_rfc8040.mount_device("XPDR-A2", ('xpdra2', self.NODE_VERSION_71))
+ response = test_utils.mount_device("XPDR-A2", ('xpdra2', self.NODE_VERSION_71))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_connect_xpdrc2(self):
- response = test_utils_rfc8040.mount_device("XPDR-C2", ('xpdrc2', self.NODE_VERSION_71))
+ response = test_utils.mount_device("XPDR-C2", ('xpdrc2', self.NODE_VERSION_71))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_connect_rdma(self):
- response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION_221))
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION_221))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_04_connect_rdmc(self):
- response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION_221))
+ response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION_221))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_05_connect_xprda2_2_N1_to_roadma_PP2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-xpdr-rdm-links',
{'links-input': {'xpdr-node': 'XPDR-A2', 'xpdr-num': '2', 'network-num': '1',
'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"])
def test_06_connect_roadma_PP2_to_xpdra2_2_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-rdm-xpdr-links',
{'links-input': {'xpdr-node': 'XPDR-A2', 'xpdr-num': '2', 'network-num': '1',
'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
self.assertIn('Roadm Xponder links created successfully', response["output"]["result"])
def test_07_connect_xprdc2_2_N1_to_roadmc_PP2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-xpdr-rdm-links',
{'links-input': {'xpdr-node': 'XPDR-C2', 'xpdr-num': '2', 'network-num': '1',
'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"])
def test_08_connect_roadmc_PP2_to_xpdrc2_2_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-rdm-xpdr-links',
{'links-input': {'xpdr-node': 'XPDR-C2', 'xpdr-num': '2', 'network-num': '1',
'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.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 OCH-OTU4 service from xpdra2 to xpdrc2
def test_11_check_otn_topology(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.get_ietf_network_request('otn-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 6, 'There should be 6 nodes')
self.assertNotIn('ietf-network-topology:link', response['network'][0])
def test_12_create_OTUC4_service(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_13_get_OTUC4_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request(
+ response = test_utils.get_ordm_serv_list_attr_request(
"services", "service1-OTUC4")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['services'][0]['administrative-state'], 'inService')
# Check correct configuration of devices
def test_14_check_interface_otsi_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-NETWORK1-755:768')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertDictEqual(dict({'name': 'XPDR2-NETWORK1-755:768',
response['interface'][0]['org-openroadm-optical-tributary-signal-interfaces:otsi'])
def test_15_check_interface_OTSI_GROUP_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-NETWORK1-OTSIGROUP-400G')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-OTSIGROUP-400G',
['org-openroadm-otsi-group-interfaces:otsi-group'])
def test_16_check_interface_OTUC4_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-NETWORK1-OTUC4')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-OTUC4',
['org-openroadm-otn-otu-interfaces:otu'])
def test_17_check_interface_otsi_xpdrc2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-C2', 'interface', 'XPDR2-NETWORK1-755:768')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertDictEqual(dict({'name': 'XPDR2-NETWORK1-755:768',
response['interface'][0]['org-openroadm-optical-tributary-signal-interfaces:otsi'])
def test_18_check_interface_OTSI_GROUP_xpdrc2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-C2', 'interface', 'XPDR2-NETWORK1-OTSIGROUP-400G')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-OTSIGROUP-400G',
['org-openroadm-otsi-group-interfaces:otsi-group'])
def test_19_check_interface_OTUC4_xpdrc2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-C2', 'interface', 'XPDR2-NETWORK1-OTUC4')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR1-NETWORK1-OTUC4',
['org-openroadm-otn-otu-interfaces:otu'])
def test_20_check_no_interface_ODUC4_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-NETWORK1-ODUC4')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_21_check_openroadm_topo_xpdra2(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDR-A2-XPDR2', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'XPDR-A2-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'])
float(ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength']['width']))
def test_22_check_otn_topo_OTUC4_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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 = ['OTUC4-XPDR-A2-XPDR2-XPDR2-NETWORK1toXPDR-C2-XPDR2-XPDR2-NETWORK1',
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:ODUCn"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_24_get_ODUC4_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request(
+ response = test_utils.get_ordm_serv_list_attr_request(
"services", "service1-ODUC4")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['services'][0]['service-name'], 'service1-ODUC4')
'org-openroadm-otn-common-types:ODUCn')
def test_25_check_interface_ODUC4_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-NETWORK1-ODUC4')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-ODUC4',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_26_check_interface_ODUC4_xpdrc2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-C2', 'interface', 'XPDR2-NETWORK1-ODUC4')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-ODUC4',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_27_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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.fail("this link should not exist")
def test_28_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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'] in ('XPDR-A2-XPDR2', 'XPDR-C2-XPDR2'):
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"] = "XPDR2-CLIENT1"
self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT1"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_30_get_100GE_service_1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request(
+ response = test_utils.get_ordm_serv_list_attr_request(
"services", "service-100GE")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['services'][0]['administrative-state'], 'inService')
self.assertEqual(response['services'][0]['lifecycle-state'], 'planned')
def test_31_check_interface_100GE_CLIENT_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-CLIENT1-ETHERNET-100G')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-CLIENT1-ETHERNET-100G',
response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
def test_32_check_interface_ODU4_CLIENT_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-CLIENT1-ODU4')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-CLIENT1-ODU4',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_33_check_interface_ODU4_NETWORK_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-NETWORK1-ODU4')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4',
['opucn-trib-slots'])
def test_34_check_ODU4_connection_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'odu-connection', 'XPDR2-CLIENT1-ODU4-x-XPDR2-NETWORK1-ODU4')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {
response['odu-connection'][0]['source'])
def test_35_check_interface_100GE_CLIENT_xpdrc2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-C2', 'interface', 'XPDR2-CLIENT1-ETHERNET-100G')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-CLIENT1-ETHERNET-100G',
response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
def test_36_check_interface_ODU4_CLIENT_xpdrc2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-C2', 'interface', 'XPDR2-CLIENT1-ODU4')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-CLIENT1-ODU4',
response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_37_check_interface_ODU4_NETWORK_xpdrc2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-C2', 'interface', 'XPDR2-NETWORK1-ODU4')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4',
'parent-odu-allocation']['opucn-trib-slots'])
def test_38_check_ODU4_connection_xpdrc2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-C2', 'odu-connection', 'XPDR2-CLIENT1-ODU4-x-XPDR2-NETWORK1-ODU4')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {
response['odu-connection'][0]['source'])
def test_39_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
link['org-openroadm-otn-network-topology:used-bandwidth'], 100000)
def test_40_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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'] in ('XPDR-A2-XPDR2', 'XPDR-C2-XPDR2'):
self.cr_serv_input_data["service-z-end"]["service-format"] = "Ethernet"
self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT2"
self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-CLIENT2"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_42_get_100GE_service_2(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-100GE2")
+ response = test_utils.get_ordm_serv_list_attr_request("services", "service-100GE2")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['services'][0]['administrative-state'], 'inService')
self.assertEqual(response['services'][0]['service-name'], 'service-100GE2')
time.sleep(1)
def test_43_check_service_list(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['service-list']['services']), 4)
def test_44_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
link['org-openroadm-otn-network-topology:used-bandwidth'], 200000)
def test_45_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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'] in ('XPDR-A2-XPDR2', 'XPDR-C2-XPDR2'):
def test_46_delete_100GE_service_2(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-100GE2"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_47_delete_100GE_service_1(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-100GE"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_48_check_service_list(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['service-list']['services']), 2)
def test_49_check_no_ODU4_connection_xpdra2(self):
- response = test_utils_rfc8040.check_node_request("XPDR-A2")
+ response = test_utils.check_node_request("XPDR-A2")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertNotIn(['odu-connection'][0], response['org-openroadm-device'])
def test_50_check_no_interface_ODU4_NETWORK_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-NETWORK1-ODU4')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_51_check_no_interface_ODU4_CLIENT_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-CLIENT1-ODU4')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_52_check_no_interface_100GE_CLIENT_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-CLIENT1-ETHERNET-100G')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_53_check_otn_topo_links(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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']:
link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
def test_54_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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'] in ('XPDR-A2-XPDR2', 'XPDR-C2-XPDR2'):
def test_55_delete_ODUC4_service(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1-ODUC4"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_56_check_service_list(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['service-list']['services']), 1)
def test_57_check_no_interface_ODU4_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-NETWORK1-ODUC4')
self.assertEqual(response['status_code'], requests.codes.conflict)
self.test_22_check_otn_topo_OTUC4_links()
def test_59_check_otn_topo_tp(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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'] in ('XPDR-A2-XPDR2', 'XPDR-C2-XPDR2'):
def test_60_delete_OTUC4_service(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1-OTUC4"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_61_get_no_service(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['service-list'], (
{
}))
def test_62_check_no_interface_OTUC4_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-NETWORK1-OTUC4')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_63_check_no_interface_OTSI_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-NETWORK1-755:768')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_64_check_no_interface_OTSIG_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR2-NETWORK1-OTSIGROUP-400G')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_65_getLinks_OtnTopology(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.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_66_check_openroadm_topo_xpdra2(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDR-A2-XPDR2', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'XPDR-A2-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'])
tp['org-openroadm-network-topology:xpdr-network-attributes']))
def test_67_check_openroadm_topology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.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(22, len(links), 'Topology should contain 22 links')
def test_68_connect_xprda2_1_N1_to_roadma_PP2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-xpdr-rdm-links',
{'links-input': {'xpdr-node': 'XPDR-A2', 'xpdr-num': '1', 'network-num': '1',
'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"])
def test_69_connect_roadma_PP2_to_xpdra2_1_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-rdm-xpdr-links',
{'links-input': {'xpdr-node': 'XPDR-A2', 'xpdr-num': '1', 'network-num': '1',
'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
self.assertIn('Roadm Xponder links created successfully', response["output"]["result"])
def test_70_connect_xprdc2_1_N1_to_roadmc_PP2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-xpdr-rdm-links',
{'links-input': {'xpdr-node': 'XPDR-C2', 'xpdr-num': '1', 'network-num': '1',
'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"])
def test_71_connect_roadmc_PP2_to_xpdrc2_1_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-rdm-xpdr-links',
{'links-input': {'xpdr-node': 'XPDR-C2', 'xpdr-num': '1', 'network-num': '1',
'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
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"]["rx-direction"][0]["port"]["port-name"]
del self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"]
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_73_get_400GE_service(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service-400GE")
+ response = test_utils.get_ordm_serv_list_attr_request("services", "service-400GE")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['services'][0]['administrative-state'], 'inService')
self.assertEqual(response['services'][0]['service-name'], 'service-400GE')
time.sleep(1)
def test_74_check_xc1_roadma(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
"ROADM-A1", "roadm-connections", "SRG1-PP1-TXRX-DEG2-TTP-TXRX-755:768")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertDictEqual(
time.sleep(1)
def test_75_check_topo_xpdra2(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPDR-A2-XPDR1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'XPDR-A2-XPDR1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
liste_tp = response['node']['ietf-network-topology:termination-point']
for ele in liste_tp:
time.sleep(1)
def test_76_check_topo_roadma_SRG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-SRG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_77_check_topo_roadma_DEG1(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADM-A1-DEG2', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
freq_map = base64.b64decode(
response['node']['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
time.sleep(1)
def test_78_check_interface_400GE_CLIENT_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR1-CLIENT1-ETHERNET')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR1-CLIENT1-ETHERNET',
response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
def test_79_check_interface_OTSI_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR1-NETWORK1-755:768')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR1-NETWORK1-755:768',
response['interface'][0]['org-openroadm-optical-tributary-signal-interfaces:otsi']['flexo'])
def test_80_check_interface_OTSI_GROUP_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR1-NETWORK1-OTSIGROUP-400G')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR1-NETWORK1-OTSIGROUP-400G',
response['interface'][0]['org-openroadm-otsi-group-interfaces:otsi-group'])
def test_81_check_interface_OTUC4_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR1-NETWORK1-OTUC4')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR1-NETWORK1-OTUC4',
response['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
def test_82_check_interface_ODUC4_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR1-NETWORK1-ODUC4')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR1-NETWORK1-ODUC4',
self.assertEqual('XPDR1-NETWORK1-OTUC4', response['interface'][0]['supporting-interface-list'][0])
def test_82a_check_interface_ODUFLEX_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR1-NETWORK1-ODUFLEX')
self.assertEqual(response['status_code'], requests.codes.ok)
input_dict_1 = {'name': 'XPDR1-NETWORK1-ODUFLEX',
def test_83_delete_400GE_service(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-400GE"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_84_get_no_service(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.conflict)
self.assertIn(response['service-list'], (
{
time.sleep(1)
def test_85_check_no_interface_ODUC4_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR1-NETWORK1-ODUC4')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_86_check_no_interface_OTUC4_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR1-NETWORK1-OTUC4')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_87_check_no_interface_OTSI_GROUP_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR1-NETWORK1-OTSIGROUP-400G')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_88_check_no_interface_OTSI_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR1-NETWORK1-755:768')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_89_check_no_interface_400GE_CLIENT_xpdra2(self):
- response = test_utils_rfc8040.check_node_attribute_request(
+ response = test_utils.check_node_attribute_request(
'XPDR-A2', 'interface', 'XPDR1-CLIENT1-ETHERNET')
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_90_disconnect_xponders_from_roadm(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.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'):
- response = test_utils_rfc8040.del_ietf_network_link_request(
+ response = test_utils.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_91_disconnect_xpdra2(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A2")
+ response = test_utils.unmount_device("XPDR-A2")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_92_disconnect_xpdrc2(self):
- response = test_utils_rfc8040.unmount_device("XPDR-C2")
+ response = test_utils.unmount_device("XPDR-C2")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_93_disconnect_roadmA(self):
- response = test_utils_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_94_disconnect_roadmC(self):
- response = test_utils_rfc8040.unmount_device("ROADM-C1")
+ response = test_utils.unmount_device("ROADM-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEtesting(unittest.TestCase):
@classmethod
def setUpClass(cls):
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra2', cls.NODE_VERSION_71),
- ('roadma', cls.NODE_VERSION_221),
- ('roadmb', cls.NODE_VERSION_221),
- ('roadmc', cls.NODE_VERSION_221),
- ('xpdrc2', cls.NODE_VERSION_71)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('xpdra2', cls.NODE_VERSION_71),
+ ('roadma', cls.NODE_VERSION_221),
+ ('roadmb', cls.NODE_VERSION_221),
+ ('roadmc', cls.NODE_VERSION_221),
+ ('xpdrc2', cls.NODE_VERSION_71)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
time.sleep(1)
def test_01_connect_xpdra2(self):
- response = test_utils_rfc8040.mount_device("XPDR-A2", ('xpdra2', self.NODE_VERSION_71))
+ response = test_utils.mount_device("XPDR-A2", ('xpdra2', self.NODE_VERSION_71))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_connect_xpdrc2(self):
- response = test_utils_rfc8040.mount_device("XPDR-C2", ('xpdrc2', self.NODE_VERSION_71))
+ response = test_utils.mount_device("XPDR-C2", ('xpdrc2', self.NODE_VERSION_71))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_connect_rdma(self):
- response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION_221))
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION_221))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_04_connect_rdmb(self):
- response = test_utils_rfc8040.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION_221))
+ response = test_utils.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION_221))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_05_connect_rdmc(self):
- response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION_221))
+ response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION_221))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_06_connect_xprda2_1_N1_to_roadma_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-xpdr-rdm-links',
{'links-input': {'xpdr-node': 'XPDR-A2', 'xpdr-num': '1', 'network-num': '1',
'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"])
def test_07_connect_roadma_PP1_to_xpdra2_1_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-rdm-xpdr-links',
{'links-input': {'xpdr-node': 'XPDR-A2', 'xpdr-num': '1', 'network-num': '1',
'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
self.assertIn('Roadm Xponder links created successfully', response["output"]["result"])
def test_08_connect_xprdc2_1_N1_to_roadmc_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-xpdr-rdm-links',
{'links-input': {'xpdr-node': 'XPDR-C2', 'xpdr-num': '1', 'network-num': '1',
'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"])
def test_09_connect_roadmc_PP1_to_xpdrc2_1_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-rdm-xpdr-links',
{'links-input': {'xpdr-node': 'XPDR-C2', 'xpdr-num': '1', 'network-num': '1',
'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
self.assertIn('Roadm Xponder links created successfully', response["output"]["result"])
def test_10_connect_xprda2_3_N1_to_roadma_PP2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-xpdr-rdm-links',
{'links-input': {'xpdr-node': 'XPDR-A2', 'xpdr-num': '3', 'network-num': '1',
'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"])
def test_11_connect_roadma_PP2_to_xpdra2_3_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-rdm-xpdr-links',
{'links-input': {'xpdr-node': 'XPDR-A2', 'xpdr-num': '3', 'network-num': '1',
'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
self.assertIn('Roadm Xponder links created successfully', response["output"]["result"])
def test_12_connect_xprdc2_3_N1_to_roadmc_PP2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-xpdr-rdm-links',
{'links-input': {'xpdr-node': 'XPDR-C2', 'xpdr-num': '3', 'network-num': '1',
'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"])
def test_13_connect_roadmc_PP2_to_xpdrc2_3_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-rdm-xpdr-links',
{'links-input': {'xpdr-node': 'XPDR-C2', 'xpdr-num': '3', 'network-num': '1',
'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.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_20_create_OTS_ROADMA_DEG1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADM-A1',
response["output"]["result"])
def test_21_create_OTS_ROADMC_DEG2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADM-C1',
response["output"]["result"])
def test_22_create_OTS_ROADMB_DEG1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADM-B1',
response["output"]["result"])
def test_23_create_OTS_ROADMB_DEG2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-device-renderer', 'create-ots-oms',
{
'node-id': 'ROADM-B1',
response["output"]["result"])
def test_24_calculate_span_loss_base_all(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-olm', 'calculate-spanloss-base',
{
'src-type': 'all'
# test service-create for Eth service from xpdr to xpdr with service-resiliency
def test_25_create_eth_service1_with_service_resiliency_restorable(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_26_get_eth_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1")
+ response = test_utils.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')
time.sleep(1)
def test_27_get_service_path_service_1(self):
- response = test_utils_rfc8040.get_serv_path_list_attr("service-paths", "service1")
+ response = test_utils.get_serv_path_list_attr("service-paths", "service1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertCountEqual(
self.service_path_service_1_AtoZ,
def test_28_create_eth_service2_without_service_resiliency(self):
self.cr_serv_input_data["service-name"] = "service2"
del self.cr_serv_input_data["service-resiliency"]
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_29_get_eth_service2(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service2")
+ response = test_utils.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')
time.sleep(1)
def test_30_get_service_path_service_2(self):
- response = test_utils_rfc8040.get_serv_path_list_attr("service-paths", "service2")
+ response = test_utils.get_serv_path_list_attr("service-paths", "service2")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertCountEqual(
self.service_path_service_2_AtoZ,
}
}
response = requests.request("POST", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(response.json()['output']['status-message'], "The PMs has been successfully set !")
time.sleep(self.WAITING * 2)
self.test_26_get_eth_service1()
def test_33_get_service_path_service_1(self):
- response = test_utils_rfc8040.get_serv_path_list_attr("service-paths", "service1")
+ response = test_utils.get_serv_path_list_attr("service-paths", "service1")
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertCountEqual(
self.service_path_service_1_rerouted_AtoZ,
response['service-paths'][0]['path-description']['aToZ-direction']['aToZ'])
def test_34_get_eth_service2(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service2")
+ response = test_utils.get_ordm_serv_list_attr_request("services", "service2")
self.assertEqual(response['services'][0]['operational-state'], 'outOfService')
self.assertEqual(response['services'][0]['administrative-state'], 'inService')
self.assertEqual(response['services'][0]['service-name'], 'service2')
time.sleep(1)
def test_35_get_service_path_service_2(self):
- response = test_utils_rfc8040.get_serv_path_list_attr("service-paths", "service2")
+ response = test_utils.get_serv_path_list_attr("service-paths", "service2")
self.assertEqual(response['status_code'], requests.codes.ok)
index = self.service_path_service_2_AtoZ.index(
{
}
}
response = requests.request("POST", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(response.json()['output']['status-message'], "The PMs has been successfully released !")
time.sleep(2)
def test_41_delete_eth_service2(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service2"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_42_delete_eth_service1(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_43_disconnect_xponders_from_roadm(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.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'):
- response = test_utils_rfc8040.del_ietf_network_link_request(
+ response = test_utils.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_44_disconnect_xpdra2(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A2")
+ response = test_utils.unmount_device("XPDR-A2")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_45_disconnect_xpdrc2(self):
- response = test_utils_rfc8040.unmount_device("XPDR-C2")
+ response = test_utils.unmount_device("XPDR-C2")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_46_disconnect_roadmA(self):
- response = test_utils_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_47_disconnect_roadmB(self):
- response = test_utils_rfc8040.unmount_device("ROADM-B1")
+ response = test_utils.unmount_device("ROADM-B1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_48_disconnect_roadmC(self):
- response = test_utils_rfc8040.unmount_device("ROADM-C1")
+ response = test_utils.unmount_device("ROADM-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCEtesting(unittest.TestCase):
if sample_files_parsed:
print("sample files content loaded")
- cls.processes = test_utils_rfc8040.start_tpce()
+ cls.processes = test_utils.start_tpce()
@classmethod
def tearDownClass(cls):
# clean datastores
- test_utils_rfc8040.del_portmapping()
- test_utils_rfc8040.del_ietf_network('openroadm-topology')
+ test_utils.del_portmapping()
+ test_utils.del_ietf_network('openroadm-topology')
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self): # instruction executed before each test method
# Load port mapping
def test_01_load_port_mapping(self):
- response = test_utils_rfc8040.post_portmapping(self.port_mapping_data)
+ response = test_utils.post_portmapping(self.port_mapping_data)
self.assertIn(response['status_code'], (requests.codes.created, requests.codes.no_content))
time.sleep(1)
# Load simple bidirectional topology
def test_02_load_simple_topology_bi(self):
- response = test_utils_rfc8040.put_ietf_network('openroadm-topology', self.simple_topo_bi_dir_data)
+ response = test_utils.put_ietf_network('openroadm-topology', self.simple_topo_bi_dir_data)
self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content))
time.sleep(1)
# Get existing nodeId
def test_03_get_nodeId(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-SRG1', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-SRG1', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['node']['node-id'], 'ROADMA01-SRG1')
time.sleep(1)
# Get existing linkId
def test_04_get_linkId(self):
- response = test_utils_rfc8040.get_ietf_network_link_request(
+ response = test_utils.get_ietf_network_link_request(
'openroadm-topology', 'XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['link']['link-id'], 'XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX')
# Path Computation success
def test_05_path_computation_xpdr_bi(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Path is calculated',
response['output']['configuration-response-common']['response-message'])
def test_06_path_computation_rdm_bi(self):
self.path_computation_input_data["service-a-end"]["node-id"] = "ROADMA01"
self.path_computation_input_data["service-z-end"]["node-id"] = "ROADMC01"
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Path is calculated',
response['output']['configuration-response-common']['response-message'])
# Load simple bidirectional topology
def test_07_load_simple_topology_uni(self):
- response = test_utils_rfc8040.put_ietf_network('openroadm-topology', self.simple_topo_uni_dir_data)
+ response = test_utils.put_ietf_network('openroadm-topology', self.simple_topo_uni_dir_data)
self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content))
time.sleep(1)
# Get existing nodeId
def test_08_get_nodeId(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPONDER-1-2', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'XPONDER-1-2', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['node']['node-id'], 'XPONDER-1-2')
time.sleep(1)
# Get existing linkId
def test_09_get_linkId(self):
- response = test_utils_rfc8040.get_ietf_network_link_request(
+ response = test_utils.get_ietf_network_link_request(
'openroadm-topology', 'XPONDER-1-2XPDR-NW1-TX-toOpenROADM-1-2-SRG1-SRG1-PP1-RX', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['link']['link-id'], 'XPONDER-1-2XPDR-NW1-TX-toOpenROADM-1-2-SRG1-SRG1-PP1-RX')
self.path_computation_input_data["service-a-end"]["clli"] = "ORANGE1"
self.path_computation_input_data["service-z-end"]["node-id"] = "XPONDER-3-2"
self.path_computation_input_data["service-z-end"]["clli"] = "ORANGE3"
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Path is calculated',
response['output']['configuration-response-common']['response-message'])
self.path_computation_input_data["service-a-end"]["clli"] = "cll21"
self.path_computation_input_data["service-z-end"]["node-id"] = "OpenROADM-2-2"
self.path_computation_input_data["service-z-end"]["clli"] = "ncli22"
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Path is calculated',
response['output']['configuration-response-common']['response-message'])
# Load complex topology
def test_12_load_complex_topology(self):
- response = test_utils_rfc8040.put_ietf_network('openroadm-topology', self.complex_topo_uni_dir_data)
+ response = test_utils.put_ietf_network('openroadm-topology', self.complex_topo_uni_dir_data)
self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content))
time.sleep(1)
# Get existing nodeId
def test_13_get_nodeId(self):
- response = test_utils_rfc8040.get_ietf_network_node_request('openroadm-topology', 'XPONDER-3-2', 'config')
+ response = test_utils.get_ietf_network_node_request('openroadm-topology', 'XPONDER-3-2', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['node']['node-id'], 'XPONDER-3-2')
time.sleep(1)
del self.path_computation_input_data["service-name"]
del self.path_computation_input_data["service-a-end"]
del self.path_computation_input_data["service-z-end"]
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Service Name is not set',
response['output']['configuration-response-common']['response-message'])
"service-identifier-list": [{
"service-identifier": "Some existing-service"}]
}}
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Path is calculated',
response['output']['configuration-response-common']['response-message'])
self.path_computation_input_data["service-z-end"]["clli"] = "ORANGE3"
del self.path_computation_input_data["hard-constraints"]
del self.path_computation_input_data["soft-constraints"]
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Path is calculated',
response['output']['configuration-response-common']['response-message'])
def test_17_success3_path_computation(self):
self.path_computation_input_data["hard-constraints"] = {"exclude":
{"node-id": ["OpenROADM-2-1", "OpenROADM-2-2"]}}
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Path is calculated',
response['output']['configuration-response-common']['response-message'])
self.path_computation_input_data["service-z-end"]["node-id"] = "XPONDER-1-2"
self.path_computation_input_data["service-z-end"]["clli"] = "ORANGE1"
del self.path_computation_input_data["hard-constraints"]
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Path is calculated',
response['output']['configuration-response-common']['response-message'])
# Delete oms-attribute in the link :openroadm1-3 to openroadm1-2
def test_19_delete_oms_attribute_in_openroadm13toopenroadm12_link(self):
- response = test_utils_rfc8040.del_oms_attr_request("OpenROADM-1-3-DEG2-to-OpenROADM-1-2-DEG2")
+ response = test_utils.del_oms_attr_request("OpenROADM-1-3-DEG2-to-OpenROADM-1-2-DEG2")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
time.sleep(2)
# Path computation after deleting oms-attribute of the link :openroadm1-3 to openroadm1-2
def test_20_path_computation_after_oms_attribute_deletion(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Path is calculated',
response['output']['configuration-response-common']['response-message'])
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportPCE400Gtesting(unittest.TestCase):
finally:
if sample_files_parsed:
print("sample files content loaded")
- cls.processes = test_utils_rfc8040.start_tpce()
+ cls.processes = test_utils.start_tpce()
@classmethod
def tearDownClass(cls):
# clean datastores
- test_utils_rfc8040.del_portmapping()
- test_utils_rfc8040.del_ietf_network('openroadm-topology')
- test_utils_rfc8040.del_ietf_network('otn-topology')
+ test_utils.del_portmapping()
+ test_utils.del_ietf_network('openroadm-topology')
+ test_utils.del_ietf_network('otn-topology')
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self): # instruction executed before each test method
# Load port mapping
def test_01_load_port_mapping(self):
- response = test_utils_rfc8040.post_portmapping(self.port_mapping_data)
+ response = test_utils.post_portmapping(self.port_mapping_data)
self.assertIn(response['status_code'], (requests.codes.created, requests.codes.no_content))
time.sleep(1)
# Load openroadm topology
def test_02_load_openroadm_topology_bi(self):
- response = test_utils_rfc8040.put_ietf_network('openroadm-topology', self.topo_bi_dir_data)
+ response = test_utils.put_ietf_network('openroadm-topology', self.topo_bi_dir_data)
self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content))
time.sleep(1)
# Path Computation success
def test_03_path_computation_400G_xpdr_bi(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Path is calculated',
response['output']['configuration-response-common']['response-message'])
# Load otn topology
def test_04_load_otn_topology_bi(self):
- response = test_utils_rfc8040.put_ietf_network('otn-topology', self.otn_topo_bi_dir_data)
+ response = test_utils.put_ietf_network('otn-topology', self.otn_topo_bi_dir_data)
self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content))
time.sleep(1)
self.path_computation_input_data["service-z-end"]["service-format"] = "OTU"
self.path_computation_input_data["service-z-end"]["tx-direction"] =\
{"port": {"port-device-name": "XPDR-C2-XPDR2"}}
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Path is calculated',
response['output']['configuration-response-common']['response-message'])
# Load otn topology with OTUC4 links
def test_06_load_otuc4_otn_topology_bi(self):
- response = test_utils_rfc8040.put_ietf_network('otn-topology', self.otuc4_otn_topo_bi_dir_data)
+ response = test_utils.put_ietf_network('otn-topology', self.otuc4_otn_topo_bi_dir_data)
self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content))
time.sleep(1)
self.path_computation_input_data["service-z-end"]["service-format"] = "ODU"
self.path_computation_input_data["service-z-end"]["tx-direction"] = \
{"port": {"port-device-name": "XPDR-C2-XPDR2"}}
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Path is calculated',
response['output']['configuration-response-common']['response-message'])
# Load otn topology with OTUC4 links
def test_08_load_oduc4_otn_topology_bi(self):
- response = test_utils_rfc8040.put_ietf_network('otn-topology', self.oduc4_otn_topo_bi_dir_data)
+ response = test_utils.put_ietf_network('otn-topology', self.oduc4_otn_topo_bi_dir_data)
self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content))
time.sleep(1)
{"port": {"port-device-name": "XPDR-C2-XPDR2",
"port-name": "XPDR2-CLIENT1"}}
self.path_computation_input_data["service-z-end"]["service-format"] = "ODU"
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertIn('Path is calculated',
response['output']['configuration-response-common']['response-message'])
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportGNPYtesting(unittest.TestCase):
with open('gnpy.log', 'w', encoding='utf-8') as outfile:
print('starting GNPy REST server...')
# pylint: disable=consider-using-with
- test_utils_rfc8040.process_list.append(subprocess.Popen(
+ test_utils.process_list.append(subprocess.Popen(
['gnpy-rest'], stdout=outfile, stderr=outfile, stdin=None))
- cls.processes = test_utils_rfc8040.start_tpce()
+ cls.processes = test_utils.start_tpce()
@classmethod
def tearDownClass(cls):
# clean datastores
- test_utils_rfc8040.del_portmapping()
- test_utils_rfc8040.del_ietf_network('openroadm-topology')
- test_utils_rfc8040.del_ietf_network('openroadm-network')
- test_utils_rfc8040.del_ietf_network('clli-network')
+ test_utils.del_portmapping()
+ test_utils.del_ietf_network('openroadm-topology')
+ test_utils.del_ietf_network('openroadm-network')
+ test_utils.del_ietf_network('clli-network')
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
# Load port mapping
def test_00_load_port_mapping(self):
- response = test_utils_rfc8040.post_portmapping(self.port_mapping_data)
+ response = test_utils.post_portmapping(self.port_mapping_data)
self.assertIn(response['status_code'], (requests.codes.created, requests.codes.no_content))
time.sleep(1)
# Mount the different topologies
def test_01_connect_clliNetwork(self):
- response = test_utils_rfc8040.put_ietf_network('clli-network', self.topo_cllinet_data)
+ response = test_utils.put_ietf_network('clli-network', self.topo_cllinet_data)
self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content))
time.sleep(1)
def test_02_connect_openroadmNetwork(self):
- response = test_utils_rfc8040.put_ietf_network('openroadm-network', self.topo_ordnet_data)
+ response = test_utils.put_ietf_network('openroadm-network', self.topo_ordnet_data)
self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content))
time.sleep(1)
def test_03_connect_openroadmTopology(self):
- response = test_utils_rfc8040.put_ietf_network('openroadm-topology', self.topo_ordtopo_data)
+ response = test_utils.put_ietf_network('openroadm-topology', self.topo_ordtopo_data)
self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content))
time.sleep(1)
# Path computed by PCE is feasible according to Gnpy
def test_04_path_computation_FeasibleWithPCE(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['output']['configuration-response-common']['response-code'], '200')
self.assertEqual(response['output']['configuration-response-common']['response-message'],
self.path_computation_input_data["service-handler-header"]["request-id"] = "request-2"
self.path_computation_input_data["hard-constraints"] =\
{"include": {"node-id": ["OpenROADM-2", "OpenROADM-3", "OpenROADM-4"]}}
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['output']['configuration-response-common'][
'response-code'], '500')
self.path_computation_input_data["service-z-end"]["node-id"] = "XPONDER-4"
self.path_computation_input_data["hard-constraints"] =\
{"include": {"node-id": ["OpenROADM-2", "OpenROADM-3"]}}
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['output']['configuration-response-common'][
'response-code'], '200')
self.path_computation_input_data["service-z-end"]["clli"] = "Node4"
self.path_computation_input_data["hard-constraints"] =\
{"include": {"node-id": ["OpenROADM-3", "OpenROADM-2", "OpenROADM-5"]}}
- response = test_utils_rfc8040.transportpce_api_rpc_request('transportpce-pce',
- 'path-computation-request',
- self.path_computation_input_data)
+ response = test_utils.transportpce_api_rpc_request('transportpce-pce',
+ 'path-computation-request',
+ self.path_computation_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['output']['configuration-response-common'][
'response-code'], '500')
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
CREATED_SUCCESSFULLY = 'Result message should contain Xponder Roadm Link created successfully'
cls.init_failed = False
os.environ['JAVA_MIN_MEM'] = '1024M'
os.environ['JAVA_MAX_MEM'] = '4096M'
- cls.processes = test_utils_rfc8040.start_tpce()
+ cls.processes = test_utils.start_tpce()
# TAPI feature is not installed by default in Karaf
if "USE_LIGHTY" not in os.environ or os.environ['USE_LIGHTY'] != 'True':
print("installing tapi feature...")
- result = test_utils_rfc8040.install_karaf_feature("odl-transportpce-tapi")
+ result = test_utils.install_karaf_feature("odl-transportpce-tapi")
if result.returncode != 0:
cls.init_failed = True
print("Restarting OpenDaylight...")
- test_utils_rfc8040.shutdown_process(cls.processes[0])
- cls.processes[0] = test_utils_rfc8040.start_karaf()
- test_utils_rfc8040.process_list[0] = cls.processes[0]
- cls.init_failed = not test_utils_rfc8040.wait_until_log_contains(
- test_utils_rfc8040.KARAF_LOG, test_utils_rfc8040.KARAF_OK_START_MSG, time_to_wait=60)
+ test_utils.shutdown_process(cls.processes[0])
+ cls.processes[0] = test_utils.start_karaf()
+ test_utils.process_list[0] = cls.processes[0]
+ cls.init_failed = not test_utils.wait_until_log_contains(
+ test_utils.KARAF_LOG, test_utils.KARAF_OK_START_MSG, time_to_wait=60)
if cls.init_failed:
print("tapi installation feature failed...")
- test_utils_rfc8040.shutdown_process(cls.processes[0])
+ test_utils.shutdown_process(cls.processes[0])
sys.exit(2)
- cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION),
- ('roadma', cls.NODE_VERSION),
- ('roadmb', cls.NODE_VERSION),
- ('roadmc', cls.NODE_VERSION),
- ('xpdrc', cls.NODE_VERSION),
- ('spdra', cls.NODE_VERSION),
- ('spdrc', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION),
+ ('roadma', cls.NODE_VERSION),
+ ('roadmb', cls.NODE_VERSION),
+ ('roadmc', cls.NODE_VERSION),
+ ('xpdrc', cls.NODE_VERSION),
+ ('spdra', cls.NODE_VERSION),
+ ('spdrc', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self): # instruction executed before each test method
print("execution of {}".format(self.id().split(".")[-1]))
def test_01_get_tapi_topology_T100G(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T100GE
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T100GE
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response["output"]["topology"]["node"]), 1, 'Topology should contain 1 node')
'node should contain 1 node rule group')
def test_02_get_tapi_topology_T0(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertNotIn("node", response["output"]["topology"], 'Topology should contain no node')
self.assertNotIn("link", response["output"]["topology"], 'Topology should contain no link')
def test_03_connect_rdmb(self):
- response = test_utils_rfc8040.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_04_check_tapi_topos(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T100GE
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T100GE
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response["output"]["topology"]["node"]), 1, 'Topology should contain 1 node')
self.assertNotIn("link", response["output"]["topology"], 'Topology should contain no link')
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response["output"]["topology"]["node"]), 1, 'Topology should contain 1 node')
self.assertNotIn("link", response["output"]["topology"], 'Topology should contain no link')
def test_05_disconnect_roadmb(self):
- response = test_utils_rfc8040.unmount_device("ROADM-B1")
+ response = test_utils.unmount_device("ROADM-B1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_06_connect_xpdra(self):
- 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)
+ 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)
def test_07_check_tapi_topos(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertNotIn("node", response["output"]["topology"], 'Topology should contain no node')
self.assertNotIn("link", response["output"]["topology"], 'Topology should contain no link')
def test_08_connect_rdma(self):
- 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)
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_09_connect_rdmc(self):
- 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)
+ response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_10_check_tapi_topos(self):
self.test_01_get_tapi_topology_T100G()
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(1, len(response["output"]["topology"]["node"]), 'Topology should contain 1 node')
'node should contain 1 node rule group')
def test_11_connect_xprda_n1_to_roadma_pp1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_12_connect_roadma_pp1_to_xpdra_n1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_13_check_tapi_topology_T100G(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T100GE
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T100GE
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(1, len(response["output"]["topology"]["node"][0]["owned-node-edge-point"]),
'name of owned-node-edge-points should be XPDR-A1-XPDR1+DSR+XPDR1-CLIENT1')
def test_14_check_tapi_topology_T0(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
nodes = response["output"]["topology"]["node"]
'Topology should contain 1 oms link')
def test_15_connect_xpdrc(self):
- 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)
+ 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)
def test_16_connect_xprdc_n1_to_roadmc_pp1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_17_connect_roadmc_pp1_to_xpdrc_n1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_18_check_tapi_topology_T100G(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T100GE
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T100GE
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(2, len(response["output"]["topology"]["node"][0]["owned-node-edge-point"]),
'name of owned-node-edge-points should be XPDR-A1-XPDR1+DSR+XPDR1-CLIENT1')
def test_19_check_tapi_topology_T0(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
nodes = response["output"]["topology"]["node"]
'Topology should contain 2 oms links')
def test_20_connect_spdr_sa1(self):
- response = test_utils_rfc8040.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
+ response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_21_connect_spdr_sc1(self):
- response = test_utils_rfc8040.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
+ response = test_utils.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_22_check_tapi_topology_T100G(self):
self.test_18_check_tapi_topology_T100G()
self.test_19_check_tapi_topology_T0()
def test_24_connect_sprda_n1_to_roadma_pp2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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-PP2-TXRX'}})
time.sleep(2)
def test_25_connect_roadma_pp2_to_spdra_n1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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-PP2-TXRX'}})
time.sleep(2)
def test_26_connect_sprdc_n1_to_roadmc_pp2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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-PP2-TXRX'}})
time.sleep(2)
def test_27_connect_roadmc_pp2_to_spdrc_n1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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-PP2-TXRX'}})
self.test_18_check_tapi_topology_T100G()
def test_29_check_tapi_topology_T0(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
nodes = response["output"]["topology"]["node"]
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
# Config ROADMC-ROADMA oms-attributes
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.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_31_create_OCH_OTU4_service(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_32_check_tapi_topology_T0(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
nodes = response["output"]["topology"]["node"]
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"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-create',
self.cr_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_34_check_tapi_topology_T0(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
nodes = response["output"]["topology"]["node"]
self.assertEqual(2, len(link["node-edge-point"]), 'link should have 2 neps')
def test_35_connect_sprda_2_n2_to_roadma_pp3(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-xpdr-rdm-links',
{'links-input': {'xpdr-node': 'SPDR-SA1', 'xpdr-num': '2', 'network-num': '2',
'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP3-TXRX'}})
time.sleep(2)
def test_36_connect_roadma_pp3_to_spdra_2_n2(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'transportpce-networkutils', 'init-rdm-xpdr-links',
{'links-input': {'xpdr-node': 'SPDR-SA1', 'xpdr-num': '2', 'network-num': '2',
'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP3-TXRX'}})
time.sleep(2)
def test_37_check_tapi_topology_T0(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
nodes = response["output"]["topology"]["node"]
def test_38_delete_ODU4_service(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1-ODU4"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_39_delete_OCH_OTU4_service(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1-OCH-OTU4"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'org-openroadm-service', 'service-delete',
self.del_serv_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_40_check_tapi_topology_T0(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
nodes = response["output"]["topology"]["node"]
'Topology should contain 0 otn link')
def test_41_disconnect_xponders_from_roadm(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.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'):
- response = test_utils_rfc8040.del_ietf_network_link_request(
+ response = test_utils.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_42_check_tapi_topology_T0(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(1, len(response["output"]["topology"]["node"]), 'Topology should contain 1 node')
'node name should be: ROADM-infra')
def test_43_get_tapi_topology_T100G(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T100GE
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T100GE
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response["output"]["topology"]["node"]), 1, 'Topology should contain 1 node')
'Node should contain no owned-node-edge-points')
def test_44_disconnect_roadma(self):
- response = test_utils_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_45_disconnect_roadmc(self):
- response = test_utils_rfc8040.unmount_device("ROADM-C1")
+ response = test_utils.unmount_device("ROADM-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_46_check_tapi_topos(self):
self.test_02_get_tapi_topology_T0()
def test_47_disconnect_xpdra(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A1")
+ response = test_utils.unmount_device("XPDR-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_48_disconnect_xpdrc(self):
- response = test_utils_rfc8040.unmount_device("XPDR-C1")
+ response = test_utils.unmount_device("XPDR-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_49_disconnect_spdr_sa1(self):
- response = test_utils_rfc8040.unmount_device("SPDR-SA1")
+ response = test_utils.unmount_device("SPDR-SA1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_50_disconnect_spdr_sc1(self):
- response = test_utils_rfc8040.unmount_device("SPDR-SC1")
+ response = test_utils.unmount_device("SPDR-SC1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
# pylint: disable=too-few-public-methods
cls.init_failed = False
os.environ['JAVA_MIN_MEM'] = '1024M'
os.environ['JAVA_MAX_MEM'] = '4096M'
- cls.processes = test_utils_rfc8040.start_tpce()
+ cls.processes = test_utils.start_tpce()
# TAPI feature is not installed by default in Karaf
if "USE_LIGHTY" not in os.environ or os.environ['USE_LIGHTY'] != 'True':
print("installing tapi feature...")
- result = test_utils_rfc8040.install_karaf_feature("odl-transportpce-tapi")
+ result = test_utils.install_karaf_feature("odl-transportpce-tapi")
if result.returncode != 0:
cls.init_failed = True
print("Restarting OpenDaylight...")
- test_utils_rfc8040.shutdown_process(cls.processes[0])
- cls.processes[0] = test_utils_rfc8040.start_karaf()
- test_utils_rfc8040.process_list[0] = cls.processes[0]
- cls.init_failed = not test_utils_rfc8040.wait_until_log_contains(
- test_utils_rfc8040.KARAF_LOG, test_utils_rfc8040.KARAF_OK_START_MSG, time_to_wait=60)
+ test_utils.shutdown_process(cls.processes[0])
+ cls.processes[0] = test_utils.start_karaf()
+ test_utils.process_list[0] = cls.processes[0]
+ cls.init_failed = not test_utils.wait_until_log_contains(
+ test_utils.KARAF_LOG, test_utils.KARAF_OK_START_MSG, time_to_wait=60)
if cls.init_failed:
print("tapi installation feature failed...")
- test_utils_rfc8040.shutdown_process(cls.processes[0])
+ test_utils.shutdown_process(cls.processes[0])
sys.exit(2)
- cls.processes = test_utils_rfc8040.start_sims([('spdra', cls.NODE_VERSION),
- ('roadma', cls.NODE_VERSION),
- ('roadmc', cls.NODE_VERSION),
- ('spdrc', cls.NODE_VERSION)])
+ cls.processes = test_utils.start_sims([('spdra', cls.NODE_VERSION),
+ ('roadma', cls.NODE_VERSION),
+ ('roadmc', cls.NODE_VERSION),
+ ('spdrc', cls.NODE_VERSION)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self):
def test_01_connect_spdrA(self):
print("Connecting SPDRA")
- response = test_utils_rfc8040.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
time.sleep(2)
def test_02_connect_spdrC(self):
print("Connecting SPDRC")
- response = test_utils_rfc8040.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
time.sleep(2)
def test_03_connect_rdmA(self):
print("Connecting ROADMA")
- 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)
+ 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)
time.sleep(2)
def test_04_connect_rdmC(self):
print("Connecting ROADMC")
- 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)
+ 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)
time.sleep(2)
def test_05_connect_sprdA_1_N1_to_roadmA_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_06_connect_roadmA_PP1_to_spdrA_1_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_07_connect_sprdC_1_N1_to_roadmC_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_08_connect_roadmC_PP1_to_spdrC_1_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.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_11_check_otn_topology(self):
- response = test_utils_rfc8040.get_ietf_network_request('otn-topology', 'config')
+ response = test_utils.get_ietf_network_request('otn-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 6, 'There should be 6 otn nodes')
self.assertNotIn('ietf-network-topology:link', response['network'][0])
def test_12_check_openroadm_topology(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['network'][0]['node']), 13, 'There should be 13 openroadm nodes')
self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 22,
'There should be 22 openroadm links')
def test_13_get_tapi_topology_details(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
time.sleep(2)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(len(response['output']['topology']['link']), 15, 'There should be 15 TAPI links')
def test_14_check_sip_details(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-common', 'get-service-interface-point-list', None)
self.assertEqual(len(response['output']['sip']), 60, 'There should be 60 service interface point')
# test create connectivity service from spdrA to spdrC for Photonic_media
def test_15_create_connectivity_service_PhotonicMedia(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'create-connectivity-service', self.cr_serv_input_data)
time.sleep(self.WAITING)
self.assertEqual(response['status_code'], requests.codes.ok)
# time.sleep(self.WAITING)
def test_16_get_service_PhotonicMedia(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", str(self.uuid_services.pm))
+ response = test_utils.get_ordm_serv_list_attr_request("services", str(self.uuid_services.pm))
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['services'][0]['administrative-state'], 'inService')
self.assertEqual(response['services'][0]['service-name'], str(self.uuid_services.pm))
self.cr_serv_input_data["connectivity-constraint"]["service-layer"] = "ODU"
self.cr_serv_input_data["connectivity-constraint"]["service-level"] = self.uuid_services.pm
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'create-connectivity-service', self.cr_serv_input_data)
time.sleep(self.WAITING)
self.assertEqual(response['status_code'], requests.codes.ok)
# time.sleep(self.WAITING)
def test_18_get_service_ODU(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", str(self.uuid_services.odu))
+ response = test_utils.get_ordm_serv_list_attr_request("services", str(self.uuid_services.odu))
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['services'][0]['administrative-state'], 'inService')
self.assertEqual(response['services'][0]['service-name'], str(self.uuid_services.odu))
self.cr_serv_input_data["connectivity-constraint"]["requested-capacity"]["total-size"]["value"] = "10"
self.cr_serv_input_data["connectivity-constraint"]["service-level"] = self.uuid_services.odu
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'create-connectivity-service', self.cr_serv_input_data)
time.sleep(self.WAITING)
self.assertEqual(response['status_code'], requests.codes.ok)
# time.sleep(self.WAITING)
def test_20_get_service_DSR(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", str(self.uuid_services.dsr))
+ response = test_utils.get_ordm_serv_list_attr_request("services", str(self.uuid_services.dsr))
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['services'][0]['administrative-state'], 'inService')
self.assertEqual(response['services'][0]['service-name'], str(self.uuid_services.dsr))
time.sleep(1)
def test_21_get_connectivity_service_list(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'get-connectivity-service-list', None)
self.assertEqual(response['status_code'], requests.codes.ok)
liste_service = response['output']['service']
def test_22_delete_connectivity_service_DSR(self):
self.del_serv_input_data["service-id-or-name"] = str(self.uuid_services.dsr)
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'delete-connectivity-service', self.del_serv_input_data)
self.assertIn(response["status_code"], (requests.codes.ok, requests.codes.no_content))
time.sleep(self.WAITING)
def test_23_delete_connectivity_service_ODU(self):
self.del_serv_input_data["service-id-or-name"] = str(self.uuid_services.odu)
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'delete-connectivity-service', self.del_serv_input_data)
self.assertIn(response["status_code"], (requests.codes.ok, requests.codes.no_content))
time.sleep(self.WAITING)
def test_24_delete_connectivity_service_PhotonicMedia(self):
self.del_serv_input_data["service-id-or-name"] = str(self.uuid_services.pm)
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'delete-connectivity-service', self.del_serv_input_data)
self.assertIn(response["status_code"], (requests.codes.ok, requests.codes.no_content))
time.sleep(self.WAITING)
def test_25_get_no_tapi_services(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'get-connectivity-service-list', None)
self.assertEqual(response['status_code'], requests.codes.internal_server_error)
self.assertIn(
response['output']['errors']['error'])
def test_26_get_no_openroadm_services(self):
- response = test_utils_rfc8040.get_ordm_serv_list_request()
+ response = test_utils.get_ordm_serv_list_request()
self.assertEqual(response['status_code'], requests.codes.conflict)
def test_27_disconnect_spdrA(self):
- response = test_utils_rfc8040.unmount_device("SPDR-SA1")
+ response = test_utils.unmount_device("SPDR-SA1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_28_disconnect_spdrC(self):
- response = test_utils_rfc8040.unmount_device("SPDR-SC1")
+ response = test_utils.unmount_device("SPDR-SC1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_29_disconnect_roadmA(self):
- response = test_utils_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_30_disconnect_roadmC(self):
- response = test_utils_rfc8040.unmount_device("ROADM-C1")
+ response = test_utils.unmount_device("ROADM-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
# pylint: disable=too-few-public-methods
cls.init_failed = False
os.environ['JAVA_MIN_MEM'] = '1024M'
os.environ['JAVA_MAX_MEM'] = '4096M'
- cls.processes = test_utils_rfc8040.start_tpce()
+ cls.processes = test_utils.start_tpce()
# TAPI feature is not installed by default in Karaf
if "USE_LIGHTY" not in os.environ or os.environ['USE_LIGHTY'] != 'True':
print("installing tapi feature...")
- result = test_utils_rfc8040.install_karaf_feature("odl-transportpce-tapi")
+ result = test_utils.install_karaf_feature("odl-transportpce-tapi")
if result.returncode != 0:
cls.init_failed = True
print("Restarting OpenDaylight...")
- test_utils_rfc8040.shutdown_process(cls.processes[0])
- cls.processes[0] = test_utils_rfc8040.start_karaf()
- test_utils_rfc8040.process_list[0] = cls.processes[0]
- cls.init_failed = not test_utils_rfc8040.wait_until_log_contains(
- test_utils_rfc8040.KARAF_LOG, test_utils_rfc8040.KARAF_OK_START_MSG, time_to_wait=60)
+ test_utils.shutdown_process(cls.processes[0])
+ cls.processes[0] = test_utils.start_karaf()
+ test_utils.process_list[0] = cls.processes[0]
+ cls.init_failed = not test_utils.wait_until_log_contains(
+ test_utils.KARAF_LOG, test_utils.KARAF_OK_START_MSG, time_to_wait=60)
if cls.init_failed:
print("tapi installation feature failed...")
- test_utils_rfc8040.shutdown_process(cls.processes[0])
+ test_utils.shutdown_process(cls.processes[0])
sys.exit(2)
- cls.processes = test_utils_rfc8040.start_tpce()
- cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION_221),
- ('roadma', cls.NODE_VERSION_221),
- ('roadmc', cls.NODE_VERSION_221),
- ('xpdrc', cls.NODE_VERSION_221)])
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION_221),
+ ('roadma', cls.NODE_VERSION_221),
+ ('roadmc', cls.NODE_VERSION_221),
+ ('xpdrc', cls.NODE_VERSION_221)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self): # instruction executed before each test method
time.sleep(1)
def test_01_connect_xpdrA(self):
- response = test_utils_rfc8040.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION_221))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION_221))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_connect_xpdrC(self):
- response = test_utils_rfc8040.mount_device("XPDR-C1", ('xpdrc', self.NODE_VERSION_221))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("XPDR-C1", ('xpdrc', self.NODE_VERSION_221))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_connect_rdmA(self):
- response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION_221))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION_221))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_04_connect_rdmC(self):
- response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION_221))
- self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION_221))
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.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_11_create_connectivity_service_Ethernet(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'create-connectivity-service', self.cr_serv_input_data)
time.sleep(self.WAITING)
self.uuid_services.eth = response['output']['service']['uuid']
# time.sleep(self.WAITING)
def test_12_get_service_Ethernet(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", str(self.uuid_services.eth))
+ response = test_utils.get_ordm_serv_list_attr_request("services", str(self.uuid_services.eth))
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['services'][0]['administrative-state'], 'inService')
self.assertEqual(response['services'][0]['service-name'], str(self.uuid_services.eth))
def test_13_get_connectivity_service_Ethernet(self):
self.tapi_serv_details["service-id-or-name"] = str(self.uuid_services.eth)
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'get-connectivity-service-details', self.tapi_serv_details)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['output']['service']['operational-state'], 'ENABLED')
"administrative-state": "outOfService",
"port-qual": "xpdr-network"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8144/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
def test_15_check_update_portmapping(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-C1", None, None)
+ response = test_utils.get_portmapping_node_attr("XPDR-C1", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
mapping_list = response['nodes'][0]['mapping']
for mapping in mapping_list:
time.sleep(1)
def test_16_check_update_openroadm_topo(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
node_list = response['network'][0]['node']
nb_updated_tp = 0
time.sleep(1)
def test_17_check_update_tapi_neps(self):
- self.node_details["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
+ self.node_details["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
self.node_details["node-id-or-name"] = "XPDR-C1-XPDR1+OTSi"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-node-details', self.node_details)
self.assertEqual(response['status_code'], requests.codes.ok)
nep_list = response['output']['node']['owned-node-edge-point']
self.assertEqual(nep['administrative-state'], 'UNLOCKED',
"Administrative State should be 'UNLOCKED'")
self.node_details["node-id-or-name"] = "XPDR-C1-XPDR1+DSR"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-node-details', self.node_details)
self.assertEqual(response['status_code'], requests.codes.ok)
nep_list = response['output']['node']['owned-node-edge-point']
time.sleep(1)
def test_18_check_update_tapi_links(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
time.sleep(2)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(1)
def test_19_check_update_service_Ethernet(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", str(self.uuid_services.eth))
+ response = test_utils.get_ordm_serv_list_attr_request("services", str(self.uuid_services.eth))
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['services'][0]['operational-state'], 'outOfService')
self.assertEqual(response['services'][0]['administrative-state'], 'inService')
def test_20_check_update_connectivity_service_Ethernet(self):
self.tapi_serv_details["service-id-or-name"] = str(self.uuid_services.eth)
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'get-connectivity-service-details', self.tapi_serv_details)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['output']['service']['operational-state'], 'DISABLED')
"administrative-state": "inService",
"port-qual": "xpdr-network"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8144/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
def test_22_check_update_portmapping_ok(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-C1", None, None)
+ response = test_utils.get_portmapping_node_attr("XPDR-C1", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
mapping_list = response['nodes'][0]['mapping']
for mapping in mapping_list:
time.sleep(1)
def test_23_check_update_openroadm_topo_ok(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
node_list = response['network'][0]['node']
for node in node_list:
time.sleep(1)
def test_24_check_update_tapi_neps_ok(self):
- self.node_details["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
+ self.node_details["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
self.node_details["node-id-or-name"] = "XPDR-C1-XPDR1+OTSi"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-node-details', self.node_details)
self.assertEqual(response['status_code'], requests.codes.ok)
nep_list = response['output']['node']['owned-node-edge-point']
"Administrative State should be 'UNLOCKED'")
self.node_details["node-id-or-name"] = "XPDR-C1-XPDR1+DSR"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-node-details', self.node_details)
self.assertEqual(response['status_code'], requests.codes.ok)
nep_list = response['output']['node']['owned-node-edge-point']
time.sleep(1)
def test_25_check_update_tapi_links_ok(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
time.sleep(2)
link_list = response['output']['topology']['link']
"administrative-state": "outOfService",
"port-qual": "roadm-external"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
def test_29_check_update_portmapping(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", None, None)
+ response = test_utils.get_portmapping_node_attr("ROADM-A1", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
mapping_list = response['nodes'][0]['mapping']
for mapping in mapping_list:
time.sleep(1)
def test_30_check_update_openroadm_topo(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
node_list = response['network'][0]['node']
nb_updated_tp = 0
time.sleep(1)
def test_31_check_update_tapi_neps(self):
- self.node_details["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
+ self.node_details["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
self.node_details["node-id-or-name"] = "ROADM-A1+PHOTONIC_MEDIA"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-node-details', self.node_details)
self.assertEqual(response['status_code'], requests.codes.ok)
nep_list = response['output']['node']['owned-node-edge-point']
time.sleep(1)
def test_32_check_update_tapi_links(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
time.sleep(2)
link_list = response['output']['topology']['link']
"administrative-state": "inService",
"port-qual": "roadm-external"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
def test_36_check_update_portmapping_ok(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", None, None)
+ response = test_utils.get_portmapping_node_attr("ROADM-A1", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
mapping_list = response['nodes'][0]['mapping']
for mapping in mapping_list:
self.test_23_check_update_openroadm_topo_ok()
def test_38_check_update_tapi_neps_ok(self):
- self.node_details["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
+ self.node_details["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
self.node_details["node-id-or-name"] = "ROADM-A1+PHOTONIC_MEDIA"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-node-details', self.node_details)
self.assertEqual(response['status_code'], requests.codes.ok)
nep_list = response['output']['node']['owned-node-edge-point']
"administrative-state": "outOfService",
"port-qual": "roadm-external"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
def test_43_check_update_portmapping(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", None, None)
+ response = test_utils.get_portmapping_node_attr("ROADM-A1", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
mapping_list = response['nodes'][0]['mapping']
for mapping in mapping_list:
time.sleep(1)
def test_44_check_update_openroadm_topo(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
node_list = response['network'][0]['node']
nb_updated_tp = 0
time.sleep(1)
def test_45_check_update_tapi_neps(self):
- self.node_details["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
+ self.node_details["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
self.node_details["node-id-or-name"] = "ROADM-A1+PHOTONIC_MEDIA"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-node-details', self.node_details)
self.assertEqual(response['status_code'], requests.codes.ok)
nep_list = response['output']['node']['owned-node-edge-point']
time.sleep(1)
def test_46_check_update_tapi_links(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
time.sleep(2)
self.assertEqual(response['status_code'], requests.codes.ok)
"administrative-state": "inService",
"port-qual": "roadm-external"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
"administrative-state": "outOfService",
"port-qual": "roadm-external"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
def test_57_check_update_portmapping(self):
- response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", None, None)
+ response = test_utils.get_portmapping_node_attr("ROADM-A1", None, None)
self.assertEqual(response['status_code'], requests.codes.ok)
mapping_list = response['nodes'][0]['mapping']
for mapping in mapping_list:
time.sleep(1)
def test_58_check_update_openroadm_topo(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
self.assertEqual(response['status_code'], requests.codes.ok)
node_list = response['network'][0]['node']
nb_updated_tp = 0
time.sleep(1)
def test_59_check_update_tapi_neps(self):
- self.node_details["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
+ self.node_details["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
self.node_details["node-id-or-name"] = "ROADM-A1+PHOTONIC_MEDIA"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-node-details', self.node_details)
self.assertEqual(response['status_code'], requests.codes.ok)
nep_list = response['output']['node']['owned-node-edge-point']
time.sleep(1)
def test_60_check_update_tapi_links(self):
- self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ self.tapi_topo["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
+ response = test_utils.transportpce_api_rpc_request(
'tapi-topology', 'get-topology-details', self.tapi_topo)
time.sleep(2)
self.assertEqual(response['status_code'], requests.codes.ok)
def test_63_delete_connectivity_service_Ethernet(self):
self.del_serv_input_data["service-id-or-name"] = str(self.uuid_services.eth)
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'delete-connectivity-service', self.del_serv_input_data)
self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content))
time.sleep(self.WAITING)
def test_64_disconnect_xponders_from_roadm(self):
- response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+ response = test_utils.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'):
- response = test_utils_rfc8040.del_ietf_network_link_request(
+ response = test_utils.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_65_disconnect_XPDRA(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A1")
+ response = test_utils.unmount_device("XPDR-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_66_disconnect_XPDRC(self):
- response = test_utils_rfc8040.unmount_device("XPDR-C1")
+ response = test_utils.unmount_device("XPDR-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_67_disconnect_ROADMA(self):
- response = test_utils_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_68_disconnect_ROADMC(self):
- response = test_utils_rfc8040.unmount_device("ROADM-C1")
+ response = test_utils.unmount_device("ROADM-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
class TransportNbiNotificationstesting(unittest.TestCase):
# pylint: disable=unsubscriptable-object
# TODO: for lighty manage the activation of NBI notification feature
cls.init_failed = False
- cls.processes = test_utils_rfc8040.start_tpce()
+ cls.processes = test_utils.start_tpce()
# NBI notification feature is not installed by default in Karaf
if "USE_LIGHTY" not in os.environ or os.environ['USE_LIGHTY'] != 'True':
print("installing NBI notification feature...")
- result = test_utils_rfc8040.install_karaf_feature("odl-transportpce-nbinotifications")
+ result = test_utils.install_karaf_feature("odl-transportpce-nbinotifications")
if result.returncode != 0:
cls.init_failed = True
print("Restarting OpenDaylight...")
- test_utils_rfc8040.shutdown_process(cls.processes[0])
- cls.processes[0] = test_utils_rfc8040.start_karaf()
- test_utils_rfc8040.process_list[0] = cls.processes[0]
- cls.init_failed = not test_utils_rfc8040.wait_until_log_contains(
- test_utils_rfc8040.KARAF_LOG, test_utils_rfc8040.KARAF_OK_START_MSG, time_to_wait=60)
+ test_utils.shutdown_process(cls.processes[0])
+ cls.processes[0] = test_utils.start_karaf()
+ test_utils.process_list[0] = cls.processes[0]
+ cls.init_failed = not test_utils.wait_until_log_contains(
+ test_utils.KARAF_LOG, test_utils.KARAF_OK_START_MSG, time_to_wait=60)
if cls.init_failed:
print("NBI notification installation feature failed...")
- test_utils_rfc8040.shutdown_process(cls.processes[0])
+ test_utils.shutdown_process(cls.processes[0])
sys.exit(2)
- cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION),
- ('roadma', cls.NODE_VERSION),
- ('roadmc', cls.NODE_VERSION),
- ('xpdrc', cls.NODE_VERSION)])
+ cls.processes = test_utils.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_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self): # instruction executed before each test method
print("execution of {}".format(self.id().split(".")[-1]))
def test_01_connect_xpdrA(self):
- response = test_utils_rfc8040.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION))
+ response = test_utils.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_connect_xpdrC(self):
- response = test_utils_rfc8040.mount_device("XPDR-C1", ('xpdrc', self.NODE_VERSION))
+ response = test_utils.mount_device("XPDR-C1", ('xpdrc', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_connect_rdmA(self):
- response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_04_connect_rdmC(self):
- response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
+ response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_09_get_notifications_service1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'nbi-notifications', 'get-notifications-process-service', self.nbi_notif_input_data)
self.assertEqual(response['status_code'], requests.codes.no_content)
time.sleep(2)
def test_10_create_eth_service1(self):
self.cr_serv_input_data["service-name"] = "service1"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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',
time.sleep(self.WAITING)
def test_11_get_notifications_service1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'nbi-notifications', 'get-notifications-process-service', self.nbi_notif_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['output']['notifications-process-service'][-1]['service-name'], 'service1')
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.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_14_create_eth_service1(self):
self.cr_serv_input_data["service-name"] = "service1"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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',
time.sleep(self.WAITING)
def test_15_get_eth_service1(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", "service1")
+ response = test_utils.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]['lifecycle-state'], 'planned')
def test_16_get_notifications_service1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'nbi-notifications', 'get-notifications-process-service', self.nbi_notif_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['output']['notifications-process-service'][-1]['service-name'], 'service1')
self.assertEqual(response['output']['notifications-process-service'][-1]['message'], 'Service implemented !')
def test_17_get_notifications_alarm_service1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'nbi-notifications', 'get-notifications-alarm-service', self.nbi_notif_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['output']['notifications-alarm-service'][-1]['service-name'], 'service1')
"administrative-state": "outOfService",
"port-qual": "roadm-external"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
def test_19_get_notifications_alarm_service1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'nbi-notifications', 'get-notifications-alarm-service', self.nbi_notif_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['output']['notifications-alarm-service'][-1]['service-name'], 'service1')
"administrative-state": "inService",
"port-qual": "roadm-external"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
def test_22_delete_eth_service1(self):
self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1"
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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',
time.sleep(20)
def test_23_get_notifications_service1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'nbi-notifications', 'get-notifications-process-service', self.nbi_notif_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['output']['notifications-process-service'][-1]['service-name'], 'service1')
time.sleep(2)
def test_24_disconnect_XPDRA(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A1")
+ response = test_utils.unmount_device("XPDR-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_25_disconnect_XPDRC(self):
- response = test_utils_rfc8040.unmount_device("XPDR-C1")
+ response = test_utils.unmount_device("XPDR-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_26_disconnect_ROADMA(self):
- response = test_utils_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_27_disconnect_ROADMC(self):
- response = test_utils_rfc8040.unmount_device("ROADM-C1")
+ response = test_utils.unmount_device("ROADM-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
sys.path.append('transportpce_tests/common/')
# pylint: disable=wrong-import-position
# pylint: disable=import-error
-import test_utils_rfc8040 # nopep8
+import test_utils # nopep8
# pylint: disable=too-few-public-methods
cls.init_failed_tapi = False
os.environ['JAVA_MIN_MEM'] = '1024M'
os.environ['JAVA_MAX_MEM'] = '4096M'
- cls.processes = test_utils_rfc8040.start_tpce()
+ cls.processes = test_utils.start_tpce()
# NBI notification feature is not installed by default in Karaf
if "USE_LIGHTY" not in os.environ or os.environ['USE_LIGHTY'] != 'True':
print("installing NBI notification feature...")
- result = test_utils_rfc8040.install_karaf_feature("odl-transportpce-nbinotifications")
+ result = test_utils.install_karaf_feature("odl-transportpce-nbinotifications")
if result.returncode != 0:
cls.init_failed_nbi = True
print("installing tapi feature...")
- result = test_utils_rfc8040.install_karaf_feature("odl-transportpce-tapi")
+ result = test_utils.install_karaf_feature("odl-transportpce-tapi")
if result.returncode != 0:
cls.init_failed_tapi = True
print("Restarting OpenDaylight...")
- test_utils_rfc8040.shutdown_process(cls.processes[0])
- cls.processes[0] = test_utils_rfc8040.start_karaf()
- test_utils_rfc8040.process_list[0] = cls.processes[0]
- cls.init_failed = not test_utils_rfc8040.wait_until_log_contains(
- test_utils_rfc8040.KARAF_LOG, test_utils_rfc8040.KARAF_OK_START_MSG, time_to_wait=60)
+ test_utils.shutdown_process(cls.processes[0])
+ cls.processes[0] = test_utils.start_karaf()
+ test_utils.process_list[0] = cls.processes[0]
+ cls.init_failed = not test_utils.wait_until_log_contains(
+ test_utils.KARAF_LOG, test_utils.KARAF_OK_START_MSG, time_to_wait=60)
if cls.init_failed_nbi:
print("NBI notification installation feature failed...")
- test_utils_rfc8040.shutdown_process(cls.processes[0])
+ test_utils.shutdown_process(cls.processes[0])
sys.exit(2)
if cls.init_failed_tapi:
print("tapi installation feature failed...")
- test_utils_rfc8040.shutdown_process(cls.processes[0])
+ test_utils.shutdown_process(cls.processes[0])
sys.exit(2)
- cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION_221),
- ('roadma', cls.NODE_VERSION_221),
- ('roadmc', cls.NODE_VERSION_221),
- ('xpdrc', cls.NODE_VERSION_221)])
+ cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION_221),
+ ('roadma', cls.NODE_VERSION_221),
+ ('roadmc', cls.NODE_VERSION_221),
+ ('xpdrc', cls.NODE_VERSION_221)])
@classmethod
def tearDownClass(cls):
# pylint: disable=not-an-iterable
for process in cls.processes:
- test_utils_rfc8040.shutdown_process(process)
+ test_utils.shutdown_process(process)
print("all processes killed")
def setUp(self): # instruction executed before each test method
print("execution of {}".format(self.id().split(".")[-1]))
def test_01_connect_xpdrA(self):
- response = test_utils_rfc8040.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION_221))
+ response = test_utils.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION_221))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_connect_xpdrC(self):
- response = test_utils_rfc8040.mount_device("XPDR-C1", ('xpdrc', self.NODE_VERSION_221))
+ response = test_utils.mount_device("XPDR-C1", ('xpdrc', self.NODE_VERSION_221))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_connect_rdmA(self):
- response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION_221))
+ response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION_221))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_04_connect_rdmC(self):
- response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION_221))
+ response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION_221))
self.assertEqual(response.status_code,
- requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+ requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
time.sleep(2)
def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.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'}})
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.add_oms_attr_request(
"ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
self.assertEqual(response.status_code, requests.codes.created)
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- response = test_utils_rfc8040.add_oms_attr_request(
+ response = test_utils.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_11_create_connectivity_service_Ethernet(self):
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'create-connectivity-service', self.cr_serv_input_data)
time.sleep(self.WAITING)
self.assertEqual(response['status_code'], requests.codes.ok)
time.sleep(self.WAITING)
def test_12_get_service_Ethernet(self):
- response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", str(self.uuid_services.eth))
+ response = test_utils.get_ordm_serv_list_attr_request("services", str(self.uuid_services.eth))
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['services'][0]['administrative-state'], 'inService')
self.assertEqual(response['services'][0]['service-name'], str(self.uuid_services.eth))
def test_13_get_connectivity_service_Ethernet(self):
self.tapi_serv_details["service-id-or-name"] = str(self.uuid_services.eth)
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'get-connectivity-service-details', self.tapi_serv_details)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['output']['service']['operational-state'], 'ENABLED')
def test_14_create_notifications_subscription_service(self):
self.cr_notif_subs_input_data["subscription-filter"]["requested-object-identifier"][0] =\
str(self.uuid_services.eth)
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-notification', 'create-notification-subscription-service', self.cr_notif_subs_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.uuid_subscriptions.eth = response['output']['subscription-service']['uuid']
"administrative-state": "outOfService",
"port-qual": "roadm-external"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
# If the gate fails is because of the waiting time not being enough
time.sleep(2)
def test_16_get_tapi_notifications_connectivity_service_Ethernet(self):
self.cr_get_notif_list_input_data["subscription-id-or-name"] = str(self.uuid_subscriptions.eth)
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-notification', 'get-notification-list', self.cr_get_notif_list_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['output']['notification'][0]['target-object-identifier'], str(self.uuid_services.eth))
"administrative-state": "inService",
"port-qual": "roadm-external"}]}
response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
- data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
- auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
- timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+ data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+ timeout=test_utils.REQUEST_TIMEOUT)
self.assertEqual(response.status_code, requests.codes.ok)
# If the gate fails is because of the waiting time not being enough
time.sleep(2)
def test_18_get_tapi_notifications_connectivity_service_Ethernet(self):
self.cr_get_notif_list_input_data["subscription-id-or-name"] = str(self.uuid_subscriptions.eth)
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-notification', 'get-notification-list', self.cr_get_notif_list_input_data)
self.assertEqual(response['status_code'], requests.codes.ok)
self.assertEqual(response['output']['notification'][1]['target-object-identifier'], str(self.uuid_services.eth))
def test_19_delete_connectivity_service_Ethernet(self):
self.tapi_serv_details["service-id-or-name"] = str(self.uuid_services.eth)
- response = test_utils_rfc8040.transportpce_api_rpc_request(
+ response = test_utils.transportpce_api_rpc_request(
'tapi-connectivity', 'delete-connectivity-service', self.tapi_serv_details)
self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content))
time.sleep(self.WAITING)
def test_20_disconnect_XPDRA(self):
- response = test_utils_rfc8040.unmount_device("XPDR-A1")
+ response = test_utils.unmount_device("XPDR-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_21_disconnect_XPDRC(self):
- response = test_utils_rfc8040.unmount_device("XPDR-C1")
+ response = test_utils.unmount_device("XPDR-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_22_disconnect_ROADMA(self):
- response = test_utils_rfc8040.unmount_device("ROADM-A1")
+ response = test_utils.unmount_device("ROADM-A1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
def test_23_disconnect_ROADMC(self):
- response = test_utils_rfc8040.unmount_device("ROADM-C1")
+ response = test_utils.unmount_device("ROADM-C1")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
setenv =
PIP_EXTRA_INDEX_URL = https://gitlab.com/api/v4/projects/33090323/packages/pypi/simple
# USE_LIGHTY=True
- USE_ODL_RESTCONF_VERSION=draft-bierman02
+# USE_ODL_RESTCONF_VERSION=draft-bierman02
deps =
-r{toxinidir}/tests/requirements.txt
-r{toxinidir}/tests/test-requirements.txt
passenv = LAUNCHER USE_LIGHTY USE_ODL_RESTCONF_VERSION
setenv =
# USE_LIGHTY=True
- USE_ODL_RESTCONF_VERSION=draft-bierman02
+# USE_ODL_RESTCONF_VERSION=draft-bierman02
USE_ODL_ALT_KARAF_ENV=./karaf121.env
USE_ODL_ALT_KARAF_INSTALL_DIR=karaf121
commands =
passenv = LAUNCHER USE_LIGHTY USE_ODL_RESTCONF_VERSION
setenv =
# USE_LIGHTY=True
- USE_ODL_RESTCONF_VERSION=draft-bierman02
+# USE_ODL_RESTCONF_VERSION=draft-bierman02
USE_ODL_ALT_KARAF_ENV=./karaf221.env
USE_ODL_ALT_KARAF_INSTALL_DIR=karaf221
commands =
passenv = LAUNCHER USE_LIGHTY USE_ODL_RESTCONF_VERSION
setenv =
# USE_LIGHTY=True
- USE_ODL_RESTCONF_VERSION=draft-bierman02
+# USE_ODL_RESTCONF_VERSION=draft-bierman02
USE_ODL_ALT_KARAF_ENV=./karaf71.env
USE_ODL_ALT_KARAF_INSTALL_DIR=karaf71
commands =
[testenv:build_karaf_tests_hybrid]
depends = buildcontroller
-# testsPCE dependency is only here to chain tests in the gate and avoid resources starvation
whitelist_externals = launch_tests.sh
passenv = LAUNCHER USE_LIGHTY
setenv =
# USE_LIGHTY=True
-# USE_ODL_RESTCONF_VERSION=draft-bierman02
USE_ODL_ALT_KARAF_ENV=./karaf121.env
USE_ODL_ALT_KARAF_INSTALL_DIR=karaf_hybrid
commands =
passenv = LAUNCHER USE_LIGHTY USE_ODL_RESTCONF_VERSION
setenv =
# USE_LIGHTY=True
- USE_ODL_RESTCONF_VERSION=draft-bierman02
+# USE_ODL_RESTCONF_VERSION=draft-bierman02
USE_ODL_ALT_KARAF_ENV=./karaf121.env
USE_ODL_ALT_KARAF_INSTALL_DIR=karaf_hybrid
commands =
passenv = LAUNCHER USE_LIGHTY OLM_TIMER1 OLM_TIMER2 USE_ODL_RESTCONF_VERSION
setenv =
# USE_LIGHTY=True
- USE_ODL_RESTCONF_VERSION=draft-bierman02
+# USE_ODL_RESTCONF_VERSION=draft-bierman02
USE_ODL_ALT_KARAF_ENV=./karaf221.env
USE_ODL_ALT_KARAF_INSTALL_DIR=karaf221
INSTALL_TAPI=True
OLM_TIMER2=2000
INSTALL_TAPI=True
INSTALL_NBINOTIFICATIONS=True
- USE_ODL_RESTCONF_VERSION=draft-bierman02
+# USE_ODL_RESTCONF_VERSION=draft-bierman02
commands =
./dockercmd.sh run -d -p 2181:2181 -p 9092:9092 --env ADVERTISED_LISTENERS=PLAINTEXT://localhost:9092 --name tpce_kafka1 teivah/kafka:2.0.0