##############################################################################
import json
-import signal
import time
import unittest
import requests
-import psutil
-import test_utils
+from common import test_utils
class TransportPCETopologyTesting(unittest.TestCase):
- sim_process1 = None
- sim_process2 = None
- sim_process3 = None
- sim_process4 = None
- odl_process = None
- restconf_baseurl = "http://localhost:8181/restconf"
-
-# START_IGNORE_XTESTING
+ processes = None
@classmethod
def setUpClass(cls):
- cls.sim_process1 = test_utils.start_sim('xpdra')
- time.sleep(20)
-
- cls.sim_process2 = test_utils.start_sim('roadma')
- time.sleep(20)
-
- cls.sim_process3 = test_utils.start_sim('roadmb')
- time.sleep(20)
-
- cls.sim_process4 = test_utils.start_sim('roadmc')
- time.sleep(20)
- print("all sims started")
-
- cls.odl_process = test_utils.start_tpce()
- time.sleep(60)
- print("opendaylight started")
+ cls.processes = test_utils.start_tpce()
+ cls.processes = test_utils.start_sims(['xpdra', 'roadma', 'roadmb', 'roadmc'])
@classmethod
def tearDownClass(cls):
- for child in psutil.Process(cls.odl_process.pid).children():
- child.send_signal(signal.SIGINT)
- child.wait()
- cls.odl_process.send_signal(signal.SIGINT)
- cls.odl_process.wait()
- for child in psutil.Process(cls.sim_process1.pid).children():
- child.send_signal(signal.SIGINT)
- child.wait()
- cls.sim_process1.send_signal(signal.SIGINT)
- cls.sim_process1.wait()
- for child in psutil.Process(cls.sim_process2.pid).children():
- child.send_signal(signal.SIGINT)
- child.wait()
- cls.sim_process2.send_signal(signal.SIGINT)
- cls.sim_process2.wait()
-
- for child in psutil.Process(cls.sim_process3.pid).children():
- child.send_signal(signal.SIGINT)
- child.wait()
- cls.sim_process3.send_signal(signal.SIGINT)
- cls.sim_process3.wait()
-
- for child in psutil.Process(cls.sim_process4.pid).children():
- child.send_signal(signal.SIGINT)
- child.wait()
- cls.sim_process4.send_signal(signal.SIGINT)
- cls.sim_process4.wait()
+ for process in cls.processes:
+ test_utils.shutdown_process(process)
+ print("all processes killed")
def setUp(self):
time.sleep(5)
-# END_IGNORE_XTESTING
-
def test_01_connect_ROADMA(self):
- # Config ROADMA
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMA01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "ROADMA01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['roadma']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADMA01", 'roadma')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ )
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
def test_03_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ )
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADMA01')
self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'], '2')
def test_04_getLinks_OpenroadmTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-topology"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
self.assertEqual(len(dropLink), 0)
def test_05_getNodes_OpenRoadmTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-topology"
+ response = test_utils.get_request(url)
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(len(listNode), 0)
def test_06_connect_XPDRA(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDRA01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "XPDRA01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['xpdra']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(30)
+ response = test_utils.mount_device("XPDRA01", 'xpdra')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_07_getClliNetwork(self):
- url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/clli-network"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
def test_08_getOpenRoadmNetwork(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-network"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
self.assertFalse(True)
def test_09_getNodes_OpenRoadmTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-topology"
+ response = test_utils.get_request(url)
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
# Connect the tail XPDRA to ROADMA and vice versa
def test_10_connect_tail_xpdr_rdm(self):
# Connect the tail: XPDRA to ROADMA
- url = ("{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
- .format(self.restconf_baseurl))
- data = {"networkutils:input": {
- "networkutils:links-input": {
- "networkutils:xpdr-node": "XPDRA01",
- "networkutils:xpdr-num": "1",
- "networkutils:network-num": "1",
- "networkutils:rdm-node": "ROADMA01",
- "networkutils:srg-num": "1",
- "networkutils:termination-point-num": "SRG1-PP1-TXRX"
- }
- }
- }
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "POST", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "1",
+ "ROADMA01", "1", "SRG1-PP1-TXRX")
self.assertEqual(response.status_code, requests.codes.ok)
def test_11_connect_tail_rdm_xpdr(self):
# Connect the tail: ROADMA to XPDRA
- url = ("{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
- .format(self.restconf_baseurl))
- data = {"networkutils:input": {
- "networkutils:links-input": {
- "networkutils:xpdr-node": "XPDRA01",
- "networkutils:xpdr-num": "1",
- "networkutils:network-num": "1",
- "networkutils:rdm-node": "ROADMA01",
- "networkutils:srg-num": "1",
- "networkutils:termination-point-num": "SRG1-PP1-TXRX"
- }
- }
- }
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "POST", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "1",
+ "ROADMA01", "1", "SRG1-PP1-TXRX")
self.assertEqual(response.status_code, requests.codes.ok)
def test_12_getLinks_OpenRoadmTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-topology"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
self.assertEqual(len(XPDR_OUT), 0)
def test_13_connect_ROADMC(self):
- # Config ROADMC
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMC01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "ROADMC01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['roadmc']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADMC01", 'roadmc')
+ 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
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ )
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ response = test_utils.put_request(url, data)
self.assertEqual(response.status_code, requests.codes.created)
def test_15_omsAttributes_ROADMC_ROADMA(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ )
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ response = test_utils.put_request(url, data)
self.assertEqual(response.status_code, requests.codes.created)
def test_16_getClliNetwork(self):
- url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/clli-network"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_17_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ )
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
self.assertEqual(len(listNode), 0)
def test_18_getROADMLinkOpenRoadmTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-topology"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
self.assertEqual(len(XPDR_OUT), 0)
def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-topology"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
self.assertEqual(len(R2RLink), 0)
def test_20_getNodes_OpenRoadmTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-topology"
+ response = test_utils.get_request(url)
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(len(listNode), 0)
def test_21_connect_ROADMB(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMB01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "ROADMB01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['roadmb']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADMB01", 'roadmb')
+ 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
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ )
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ response = test_utils.put_request(url, data)
self.assertEqual(response.status_code, requests.codes.created)
def test_23_omsAttributes_ROADMB_ROADMA(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ )
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ response = test_utils.put_request(url, data)
self.assertEqual(response.status_code, requests.codes.created)
def test_24_omsAttributes_ROADMB_ROADMC(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ )
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ response = test_utils.put_request(url, data)
self.assertEqual(response.status_code, requests.codes.created)
def test_25_omsAttributes_ROADMC_ROADMB(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ )
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ response = test_utils.put_request(url, data)
self.assertEqual(response.status_code, requests.codes.created)
def test_26_getClliNetwork(self):
- url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/clli-network"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
self.assertEqual(len(listNode), 0)
def test_27_verifyDegree(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-topology"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
self.assertEqual(len(listR2RLink), 0)
def test_28_verifyOppositeLinkTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-topology"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
oppLink_id = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
# Find the opposite link
url_oppLink = "{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"+oppLink_id
- url = (url_oppLink.format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response_oppLink = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
+ response_oppLink = test_utils.get_request(url_oppLink)
self.assertEqual(response_oppLink.status_code, requests.codes.ok)
res_oppLink = response_oppLink.json()
self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ )
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbLink = len(res['network'][0]['ietf-network-topology:link'])
def test_30_disconnect_ROADMB(self):
# Delete in the topology-netconf
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMB01"
- .format(self.restconf_baseurl))
- data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("ROADMB01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
# Delete in the clli-network
- url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeB"
- .format(self.restconf_baseurl))
+ url = "{}/config/ietf-network:networks/network/clli-network/node/NodeB"
data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ response = test_utils.delete_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
def test_31_disconnect_ROADMC(self):
- # Delete in the topology-netconf
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMC01"
- .format(self.restconf_baseurl))
- data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("ROADMC01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
# Delete in the clli-network
- url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeC"
- .format(self.restconf_baseurl))
+ url = "{}/config/ietf-network:networks/network/clli-network/node/NodeC"
data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ response = test_utils.delete_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
def test_32_getNodes_OpenRoadmTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-topology"
+ response = test_utils.get_request(url)
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMC01-DEG2')
def test_33_getOpenRoadmNetwork(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-network"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMB01')
def test_34_getClliNetwork(self):
- url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/clli-network"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'], 'NodeC')
def test_35_disconnect_XPDRA(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDRA01"
- .format(self.restconf_baseurl))
- data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("XPDRA01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_36_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ )
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_37_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ )
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDRA01')
def test_38_getNodes_OpenRoadmTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-topology"
+ response = test_utils.get_request(url)
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
# Link-1
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX"
- .format(self.restconf_baseurl))
+ )
data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ response = test_utils.delete_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
# Link-2
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1"
- .format(self.restconf_baseurl))
+ )
data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ response = test_utils.delete_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
def test_40_getLinks_OpenRoadmTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-topology"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbLink = len(res['network'][0]['ietf-network-topology:link'])
['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
def test_41_disconnect_ROADMA(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMA01"
- .format(self.restconf_baseurl))
- data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("ROADMA01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
# Delete in the clli-network
- url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeA"
- .format(self.restconf_baseurl))
+ url = "{}/config/ietf-network:networks/network/clli-network/node/NodeA"
data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ response = test_utils.delete_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
def test_42_getClliNetwork(self):
- url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/clli-network"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn('node', res['network'][0])
def test_43_getOpenRoadmNetwork(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-network"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn('node', res['network'][0])
def test_44_check_roadm2roadm_link_persistence(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ url = "{}/config/ietf-network:networks/network/openroadm-topology"
+ response = test_utils.get_request(url)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbLink = len(res['network'][0]['ietf-network-topology:link'])
Code Review / transportpce.git / blobdiff