"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": "17830",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "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": "17830",
+ "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,
"network-topology/topology/topology-netconf/node/XPDRC01"
.format(self.restconf_baseurl))
data = {"node": [{
- "node-id": "XPDRC01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": "17834",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "node-id": "XPDRC01",
+ "netconf-node-topology:username": "admin",
+ "netconf-node-topology:password": "admin",
+ "netconf-node-topology:host": "127.0.0.1",
+ "netconf-node-topology:port": "17834",
+ "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,
"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": "17821",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "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": "17821",
+ "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,
"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": "17823",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "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": "17823",
+ "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,
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"
+ "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(
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"
+ "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(
url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
format(self.restconf_baseurl)
data = {
- "networkutils:input": {
- "networkutils:links-input": {
- "networkutils:xpdr-node": "XPDRC01",
- "networkutils:xpdr-num": "1",
- "networkutils:network-num": "1",
- "networkutils:rdm-node": "ROADMC01",
- "networkutils:srg-num": "1",
- "networkutils:termination-point-num": "SRG1-PP1-TXRX"
+ "networkutils:input": {
+ "networkutils:links-input": {
+ "networkutils:xpdr-node": "XPDRC01",
+ "networkutils:xpdr-num": "1",
+ "networkutils:network-num": "1",
+ "networkutils:rdm-node": "ROADMC01",
+ "networkutils:srg-num": "1",
+ "networkutils:termination-point-num": "SRG1-PP1-TXRX"
+ }
}
- }
}
headers = {'content-type': 'application/json'}
response = requests.request(
url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
format(self.restconf_baseurl)
data = {
- "networkutils:input": {
- "networkutils:links-input": {
- "networkutils:xpdr-node": "XPDRC01",
- "networkutils:xpdr-num": "1",
- "networkutils:network-num": "1",
- "networkutils:rdm-node": "ROADMC01",
- "networkutils:srg-num": "1",
- "networkutils:termination-point-num": "SRG1-PP1-TXRX"
+ "networkutils:input": {
+ "networkutils:links-input": {
+ "networkutils:xpdr-node": "XPDRC01",
+ "networkutils:xpdr-num": "1",
+ "networkutils:network-num": "1",
+ "networkutils:rdm-node": "ROADMC01",
+ "networkutils:srg-num": "1",
+ "networkutils:termination-point-num": "SRG1-PP1-TXRX"
+ }
}
- }
}
headers = {'content-type': 'application/json'}
response = requests.request(
def test_09_add_omsAttributes_ROADMA_ROADMC(self):
# Config ROADMA-ROADMC 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))
+ "{}/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": {
"clfi": "fiber1",
"auto-spanloss": "true",
def test_10_add_omsAttributes_ROADMC_ROADMA(self):
# Config ROADMC-ROADMA oms-attributes
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))
+ "{}/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": {
- "clfi": "fiber1",
- "auto-spanloss": "true",
- "spanloss-base": 11.4,
- "spanloss-current": 12,
- "engineered-spanloss": 12.2,
- "link-concatenation": [{
- "SRLG-Id": 0,
- "fiber-type": "smf",
- "SRLG-length": 100000,
- "pmd": 0.5}]}}
+ "clfi": "fiber1",
+ "auto-spanloss": "true",
+ "spanloss-base": 11.4,
+ "spanloss-current": 12,
+ "engineered-spanloss": 12.2,
+ "link-concatenation": [{
+ "SRLG-Id": 0,
+ "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,
res = response.json()
self.assertIn('PCE calculation in progress',
res['output']['configuration-response-common'][
- 'response-message'])
+ 'response-message'])
time.sleep(self.WAITING)
def test_12_get_eth_service1(self):
body = clli_net.read()
headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=body, headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=body, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
body = ord_net.read()
headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=body, headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=body, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
body = ord_topo.read()
headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=body, headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=body, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['output']['configuration-response-common'][
- 'response-code'], '200')
+ 'response-code'], '200')
self.assertEqual(res['output']['configuration-response-common'][
- 'response-message'],
- 'Path is calculated by PCE')
+ 'response-message'],
+ 'Path is calculated by PCE')
self.assertEqual(res['output']['gnpy-response'][0]['path-dir'],
'A-to-Z')
self.assertEqual(res['output']['gnpy-response'][0]['feasibility'], True)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['output']['configuration-response-common'][
- 'response-code'], '500')
+ 'response-code'], '500')
self.assertEqual(res['output']['configuration-response-common'][
- 'response-message'],
- 'No path available by PCE and GNPy ')
+ 'response-message'],
+ 'No path available by PCE and GNPy ')
self.assertEqual(res['output']['gnpy-response'][0]['path-dir'],
'A-to-Z')
self.assertEqual(res['output']['gnpy-response'][0]['feasibility'],
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['output']['configuration-response-common'][
- 'response-code'], '200')
+ 'response-code'], '200')
self.assertEqual(res['output']['configuration-response-common'][
- 'response-message'],
- 'Path is calculated by GNPy')
+ 'response-message'],
+ 'Path is calculated by GNPy')
self.assertEqual(res['output']['gnpy-response'][0]['path-dir'],
'A-to-Z')
self.assertEqual(res['output']['gnpy-response'][0]['feasibility'], True)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['output']['configuration-response-common'][
- 'response-code'], '500')
+ 'response-code'], '500')
self.assertEqual(res['output']['configuration-response-common'][
- 'response-message'],
- 'No path available by PCE and GNPy ')
+ 'response-message'],
+ 'No path available by PCE and GNPy ')
time.sleep(5)
# Disconnect the different topologies
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
odl_process = None
restconf_baseurl = "http://localhost:8181/restconf"
-#START_IGNORE_XTESTING
+# START_IGNORE_XTESTING
@classmethod
def setUpClass(cls):
- print ("starting honeynode1...")
+ print("starting honeynode1...")
cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
time.sleep(20)
- print ("starting honeynode2...")
+ print("starting honeynode2...")
cls.honeynode_process2 = test_utils.start_roadma_full_honeynode()
time.sleep(20)
- print ("starting honeynode3...")
+ print("starting honeynode3...")
cls.honeynode_process3 = test_utils.start_roadmc_full_honeynode()
time.sleep(20)
- print ("starting honeynode4...")
+ print("starting honeynode4...")
cls.honeynode_process4 = test_utils.start_xpdrc_honeynode()
time.sleep(20)
- print ("all honeynodes started")
+ print("all honeynodes started")
- print ("starting opendaylight...")
+ print("starting opendaylight...")
cls.odl_process = test_utils.start_tpce()
time.sleep(60)
- print ("opendaylight started")
+ print("opendaylight started")
@classmethod
def tearDownClass(cls):
cls.honeynode_process4.wait()
def setUp(self):
- print ("execution of {}".format(self.id().split(".")[-1]))
+ print("execution of {}".format(self.id().split(".")[-1]))
time.sleep(1)
-#END_IGNORE_XTESTING
+# END_IGNORE_XTESTING
def test_01_xpdrA_device_connected(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/XPDRA01"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"node": [{
"node-id": "XPDRA01",
"netconf-node-topology:username": "admin",
def test_02_xpdrC_device_connected(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/XPDRC01"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"node": [{
"node-id": "XPDRC01",
"netconf-node-topology:username": "admin",
"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": "17821",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "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": "17821",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
"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": "17823",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "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": "17823",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
def test_09_create_OTS_ROADMA(self):
url = "{}/operations/transportpce-device-renderer:create-ots-oms".format(self.restconf_baseurl)
data = {
- "input" : {
- "node-id" : "ROADMA01",
- "logical-connection-point" : "DEG1-TTP-TXRX"
+ "input": {
+ "node-id": "ROADMA01",
+ "logical-connection-point": "DEG1-TTP-TXRX"
}
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADMA01',
def test_10_create_OTS_ROADMC(self):
url = "{}/operations/transportpce-device-renderer:create-ots-oms".format(self.restconf_baseurl)
data = {
- "input" : {
- "node-id" : "ROADMC01",
- "logical-connection-point" : "DEG2-TTP-TXRX"
+ "input": {
+ "node-id": "ROADMC01",
+ "logical-connection-point": "DEG2-TTP-TXRX"
}
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADMC01',
"resource-type": "interface",
"granularity": "15min",
"resource-identifier": {
- "resource-name" : "OTS-DEG1-TTP-TXRX"
+ "resource-name": "OTS-DEG1-TTP-TXRX"
}
}
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn({
- "pmparameter-name": "OpticalPowerOutput",
- "pmparameter-value": "2.5"
- }, res["output"]["measurements"])
+ "pmparameter-name": "OpticalPowerOutput",
+ "pmparameter-value": "2.5"
+ }, res["output"]["measurements"])
self.assertIn({
- "pmparameter-name": "OpticalReturnLoss",
- "pmparameter-value": "49.9"
- }, res["output"]["measurements"])
+ "pmparameter-name": "OpticalReturnLoss",
+ "pmparameter-value": "49.9"
+ }, res["output"]["measurements"])
self.assertIn({
- "pmparameter-name": "OpticalPowerInput",
- "pmparameter-value": "3"
- }, res["output"]["measurements"])
+ "pmparameter-name": "OpticalPowerInput",
+ "pmparameter-value": "3"
+ }, res["output"]["measurements"])
def test_12_get_PM_ROADMC(self):
url = "{}/operations/transportpce-olm:get-pm".format(self.restconf_baseurl)
"resource-type": "interface",
"granularity": "15min",
"resource-identifier": {
- "resource-name" : "OTS-DEG2-TTP-TXRX"
+ "resource-name": "OTS-DEG2-TTP-TXRX"
}
}
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn({
- "pmparameter-name": "OpticalPowerOutput",
- "pmparameter-value": "18.1"
- }, res["output"]["measurements"])
+ "pmparameter-name": "OpticalPowerOutput",
+ "pmparameter-value": "18.1"
+ }, res["output"]["measurements"])
self.assertIn({
- "pmparameter-name": "OpticalReturnLoss",
- "pmparameter-value": "48.8"
- }, res["output"]["measurements"])
+ "pmparameter-name": "OpticalReturnLoss",
+ "pmparameter-value": "48.8"
+ }, res["output"]["measurements"])
self.assertIn({
- "pmparameter-name": "OpticalPowerInput",
- "pmparameter-value": "-3.2"
- }, res["output"]["measurements"])
+ "pmparameter-name": "OpticalPowerInput",
+ "pmparameter-value": "-3.2"
+ }, res["output"]["measurements"])
def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
url = "{}/operations/transportpce-olm:calculate-spanloss-base".format(self.restconf_baseurl)
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success',
res["output"]["result"])
self.assertIn({
"spanloss": "6",
- "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
- }, res["output"]["spans"])
+ "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
+ }, res["output"]["spans"])
time.sleep(5)
def test_14_calculate_span_loss_base_all(self):
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success',
res["output"]["result"])
self.assertIn({
- "spanloss": "15",
- "link-id": "ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX"
- }, res["output"]["spans"])
+ "spanloss": "15",
+ "link-id": "ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX"
+ }, res["output"]["spans"])
self.assertIn({
- "spanloss": "6",
- "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
- }, res["output"]["spans"])
+ "spanloss": "6",
+ "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
+ }, res["output"]["spans"])
time.sleep(5)
def test_15_get_OTS_DEG1_TTP_TXRX_ROADMA(self):
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
- #time.sleep(40)
+ # time.sleep(40)
time.sleep(10)
def test_18_servicePath_create_ZToA(self):
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
- #time.sleep(40)
+ # time.sleep(40)
time.sleep(10)
def test_19_service_power_setup_XPDRA_XPDRC(self):
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
- #time.sleep(40)
+ # time.sleep(40)
time.sleep(10)
def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
def test_36_xpdrA_device_disconnected(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDRA01"
+ "network-topology/topology/topology-netconf/node/XPDRA01"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(10)
def test_37_xpdrC_device_disconnected(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDRC01"
+ "network-topology/topology/topology-netconf/node/XPDRC01"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(10)
url = "{}/operations/transportpce-olm:calculate-spanloss-current".format(self.restconf_baseurl)
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, headers=headers, auth=('admin', 'admin'))
+ "POST", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success',
def test_39_rdmA_device_disconnected(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMA01"
+ "network-topology/topology/topology-netconf/node/ROADMA01"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(10)
def test_40_rdmC_device_disconnected(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMC01"
+ "network-topology/topology/topology-netconf/node/ROADMC01"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(10)
+
if __name__ == "__main__":
unittest.main(verbosity=2)
topo_bi_dir_file = "sample_configs/honeynode-topo.xml"
if os.path.isfile(topo_bi_dir_file):
with open(topo_bi_dir_file, 'r') as topo_bi_dir:
- cls.simple_topo_bi_dir_data = topo_bi_dir.read();
+ cls.simple_topo_bi_dir_data = topo_bi_dir.read()
topo_uni_dir_file = "sample_configs/NW-simple-topology.xml"
if os.path.isfile(topo_uni_dir_file):
with open(topo_uni_dir_file, 'r') as topo_uni_dir:
- cls.simple_topo_uni_dir_data = topo_uni_dir.read();
+ cls.simple_topo_uni_dir_data = topo_uni_dir.read()
topo_uni_dir_complex_file = "sample_configs/NW-for-test-5-4.xml"
if os.path.isfile(topo_uni_dir_complex_file):
with open(topo_uni_dir_complex_file, 'r') as topo_uni_dir_complex:
- cls.complex_topo_uni_dir_data = topo_uni_dir_complex.read();
+ cls.complex_topo_uni_dir_data = topo_uni_dir_complex.read()
@classmethod
def setUpClass(cls): # a class method called before tests in an individual class run.
cls._get_file()
- print ("starting opendaylight...")
+ print("starting opendaylight...")
cls.odl_process = test_utils.start_tpce()
time.sleep(90)
- print ("opendaylight started")
+ print("opendaylight started")
@classmethod
def tearDownClass(cls):
# Load simple bidirectional topology
def test_01_load_simple_topology_bi(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
body = self.simple_topo_bi_dir_data
headers = {'content-type': 'application/xml',
- "Accept": "application/xml"}
+ "Accept": "application/xml"}
response = requests.request(
"PUT", url, data=body, headers=headers,
auth=('admin', 'admin'))
# Get existing nodeId
def test_02_get_nodeId(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
# Get existing linkId
def test_03_get_linkId(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/link/XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
# Path Computation success
def test_04_path_computation_xpdr_bi(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
body = {"input": {
"service-name": "service-1",
"resource-reserve": "true",
"service-format": "Ethernet",
"clli": "nodeC"
}
- }
- }
+ }
+ }
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"POST", url, data=json.dumps(body), headers=headers,
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
time.sleep(5)
# Path Computation success
def test_05_path_computation_rdm_bi(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
body = {"input": {
"service-name": "service-1",
"resource-reserve": "true",
"service-format": "Ethernet",
"clli": "NodeC"
}
- }
- }
+ }
+ }
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"POST", url, data=json.dumps(body), headers=headers,
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
time.sleep(5)
# Delete topology
def test_06_delete_simple_topology_bi(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/xml',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"DELETE", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
# Test deleted topology
def test_07_test_topology_simple_bi_deleted(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, 404)
# Load simple bidirectional topology
def test_08_load_simple_topology_uni(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
body = self.simple_topo_uni_dir_data
headers = {'content-type': 'application/xml',
- "Accept": "application/xml"}
+ "Accept": "application/xml"}
response = requests.request(
"PUT", url, data=body, headers=headers,
auth=('admin', 'admin'))
# Get existing nodeId
def test_09_get_nodeId(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPONDER-1-2"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
# Get existing linkId
def test_10_get_linkId(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/link/XPONDER-1-2XPDR-NW1-TX-toOpenROADM-1-2-SRG1-SRG1-PP1-RX"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
# Path Computation success
def test_11_path_computation_xpdr_uni(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
body = {"input": {
"service-name": "service-1",
"resource-reserve": "true",
"service-format": "Ethernet",
"clli": "ORANGE3"
}
- }
- }
+ }
+ }
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"POST", url, data=json.dumps(body), headers=headers,
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
time.sleep(5)
# Path Computation success
def test_12_path_computation_rdm_uni(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
body = {"input": {
"service-name": "service1",
"resource-reserve": "true",
"service-handler-header": {
- "request-id": "request1"
+ "request-id": "request1"
},
"service-a-end": {
- "service-rate": "100",
- "service-format": "Ethernet",
- "clli": "cll21",
- "node-id": "OpenROADM-2-1"
+ "service-rate": "100",
+ "service-format": "Ethernet",
+ "clli": "cll21",
+ "node-id": "OpenROADM-2-1"
},
"service-z-end": {
- "service-rate": "100",
- "service-format": "Ethernet",
- "clli": "ncli22",
- "node-id": "OpenROADM-2-2"
- },
+ "service-rate": "100",
+ "service-format": "Ethernet",
+ "clli": "ncli22",
+ "node-id": "OpenROADM-2-2"
+ },
"pce-metric": "hop-count"
- }
- }
+ }
+ }
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"POST", url, data=json.dumps(body), headers=headers,
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
- res['output']['configuration-response-common']['response-message'])
- #ZtoA path test
+ res['output']['configuration-response-common']['response-message'])
+ # ZtoA path test
atozList = len(res['output']['response-parameters']['path-description']['aToZ-direction']['aToZ'])
ztoaList = len(res['output']['response-parameters']['path-description']['zToA-direction']['zToA'])
- self.assertEqual(atozList,15)
- self.assertEqual(ztoaList,15)
- for i in range(0,15):
+ self.assertEqual(atozList, 15)
+ self.assertEqual(ztoaList, 15)
+ for i in range(0, 15):
atoz = res['output']['response-parameters']['path-description']['aToZ-direction']['aToZ'][i]
ztoa = res['output']['response-parameters']['path-description']['zToA-direction']['zToA'][i]
if (atoz['id'] == '14'):
# Delete topology
def test_13_delete_simple_topology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/xml',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"DELETE", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
# Test deleted topology
def test_14_test_topology_simple_deleted(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPONDER-1-2"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, 404)
# Load simple topology
def test_15_load_complex_topology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
body = self.complex_topo_uni_dir_data
headers = {'content-type': 'application/xml',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"PUT", url, data=body, headers=headers,
auth=('admin', 'admin'))
# Get existing nodeId
def test_16_get_nodeId(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPONDER-3-2"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
# Test failed path computation
def test_17_fail_path_computation(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
body = {"input": {
"service-handler-header": {
"request-id": "request-1"
}
- }
- }
+ }
+ }
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"POST", url, data=json.dumps(body), headers=headers,
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Service Name is not set',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
time.sleep(2)
# Test1 success path computation
def test_18_success1_path_computation(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
body = {"input": {
"service-name": "service1",
"resource-reserve": "true",
"service-handler-header": {
- "request-id": "request1"
+ "request-id": "request1"
},
"service-a-end": {
- "service-format": "Ethernet",
- "service-rate": "100",
- "clli": "ORANGE2",
- "node-id": "XPONDER-2-2",
- "tx-direction": {
- "port": {
- "port-device-name": "Some port-device-name",
- "port-type": "Some port-type",
- "port-name": "Some port-name",
- "port-rack": "Some port-rack",
- "port-shelf": "Some port-shelf",
- "port-slot": "Some port-slot",
- "port-sub-slot": "Some port-sub-slot"
- }
- },
- "rx-direction": {
- "port": {
- "port-device-name": "Some port-device-name",
- "port-type": "Some port-type",
- "port-name": "Some port-name",
- "port-rack": "Some port-rack",
- "port-shelf": "Some port-shelf",
- "port-slot": "Some port-slot",
- "port-sub-slot": "Some port-sub-slot"
+ "service-format": "Ethernet",
+ "service-rate": "100",
+ "clli": "ORANGE2",
+ "node-id": "XPONDER-2-2",
+ "tx-direction": {
+ "port": {
+ "port-device-name": "Some port-device-name",
+ "port-type": "Some port-type",
+ "port-name": "Some port-name",
+ "port-rack": "Some port-rack",
+ "port-shelf": "Some port-shelf",
+ "port-slot": "Some port-slot",
+ "port-sub-slot": "Some port-sub-slot"
+ }
+ },
+ "rx-direction": {
+ "port": {
+ "port-device-name": "Some port-device-name",
+ "port-type": "Some port-type",
+ "port-name": "Some port-name",
+ "port-rack": "Some port-rack",
+ "port-shelf": "Some port-shelf",
+ "port-slot": "Some port-slot",
+ "port-sub-slot": "Some port-sub-slot"
+ }
}
- }
},
"service-z-end": {
- "service-format": "Ethernet",
- "service-rate": "100",
- "clli": "ORANGE1",
- "node-id": "XPONDER-1-2",
- "tx-direction": {
- "port": {
- "port-device-name": "Some port-device-name",
- "port-type": "Some port-type",
- "port-name": "Some port-name",
- "port-rack": "Some port-rack",
- "port-shelf": "Some port-shelf",
- "port-slot": "Some port-slot",
- "port-sub-slot": "Some port-sub-slot"
- }
- },
- "rx-direction": {
- "port": {
- "port-device-name": "Some port-device-name",
- "port-type": "Some port-type",
- "port-name": "Some port-name",
- "port-rack": "Some port-rack",
- "port-shelf": "Some port-shelf",
- "port-slot": "Some port-slot",
- "port-sub-slot": "Some port-sub-slot"
+ "service-format": "Ethernet",
+ "service-rate": "100",
+ "clli": "ORANGE1",
+ "node-id": "XPONDER-1-2",
+ "tx-direction": {
+ "port": {
+ "port-device-name": "Some port-device-name",
+ "port-type": "Some port-type",
+ "port-name": "Some port-name",
+ "port-rack": "Some port-rack",
+ "port-shelf": "Some port-shelf",
+ "port-slot": "Some port-slot",
+ "port-sub-slot": "Some port-sub-slot"
+ }
+ },
+ "rx-direction": {
+ "port": {
+ "port-device-name": "Some port-device-name",
+ "port-type": "Some port-type",
+ "port-name": "Some port-name",
+ "port-rack": "Some port-rack",
+ "port-shelf": "Some port-shelf",
+ "port-slot": "Some port-slot",
+ "port-sub-slot": "Some port-sub-slot"
+ }
}
- }
},
"hard-constraints": {
- "customer-code": [
- "Some customer-code"
- ],
- "co-routing": {
- "existing-service": [
- "Some existing-service"
- ]
- }
+ "customer-code": [
+ "Some customer-code"
+ ],
+ "co-routing": {
+ "existing-service": [
+ "Some existing-service"
+ ]
+ }
},
"soft-constraints": {
- "customer-code": [
- "Some customer-code"
- ],
- "co-routing": {
- "existing-service": [
- "Some existing-service"
- ]
- }
+ "customer-code": [
+ "Some customer-code"
+ ],
+ "co-routing": {
+ "existing-service": [
+ "Some existing-service"
+ ]
+ }
},
"pce-metric": "hop-count",
"locally-protected-links": "true"
- }
- }
+ }
+ }
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"POST", url, data=json.dumps(body), headers=headers,
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
time.sleep(5)
# Test2 success path computation with path description
def test_19_success2_path_computation(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
body = {"input": {
"service-name": "service 1",
"resource-reserve": "true",
"service-format": "Ethernet",
"node-id": "XPONDER-3-2",
"clli": "ORANGE3"
- },
- "pce-metric": "hop-count"
- }
- }
+ },
+ "pce-metric": "hop-count"
+ }
+ }
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"POST", url, data=json.dumps(body), headers=headers,
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
- res['output']['configuration-response-common']['response-message'])
- self.assertEqual(5 , res['output']['response-parameters']['path-description']
- ['aToZ-direction']['aToZ-wavelength-number'])
- self.assertEqual(5 , res['output']['response-parameters']['path-description']
- ['zToA-direction']['zToA-wavelength-number'])
+ res['output']['configuration-response-common']['response-message'])
+ self.assertEqual(5, res['output']['response-parameters']['path-description']
+ ['aToZ-direction']['aToZ-wavelength-number'])
+ self.assertEqual(5, res['output']['response-parameters']['path-description']
+ ['zToA-direction']['zToA-wavelength-number'])
time.sleep(5)
# Test3 success path computation with hard-constraints exclude
def test_20_success3_path_computation(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
body = {"input": {
"service-name": "service 1",
"resource-reserve": "true",
}
},
"pce-metric": "hop-count"
- }
- }
+ }
+ }
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"POST", url, data=json.dumps(body), headers=headers,
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
- res['output']['configuration-response-common']['response-message'])
- self.assertEqual(9 , res['output']['response-parameters']['path-description']
- ['aToZ-direction']['aToZ-wavelength-number'])
- self.assertEqual(9 , res['output']['response-parameters']['path-description']
- ['zToA-direction']['zToA-wavelength-number'])
+ res['output']['configuration-response-common']['response-message'])
+ self.assertEqual(9, res['output']['response-parameters']['path-description']
+ ['aToZ-direction']['aToZ-wavelength-number'])
+ self.assertEqual(9, res['output']['response-parameters']['path-description']
+ ['zToA-direction']['zToA-wavelength-number'])
time.sleep(5)
# Delete complex topology
def test_21_delete_complex_topology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/xml',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"DELETE", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
# Test deleted complex topology
def test_22_test_topology_complex_deleted(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPONDER-3-2"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, 404)
##############################################################################
import json
-import os
-import psutil
-import requests
import signal
-import shutil
-import subprocess
-import time
import unittest
+import time
+import requests
+import psutil
import test_utils
odl_process = None
restconf_baseurl = "http://localhost:8181/restconf"
-#START_IGNORE_XTESTING
+# START_IGNORE_XTESTING
@classmethod
def setUpClass(cls):
- print ("starting honeynode1...")
+ print("starting honeynode1...")
cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
time.sleep(20)
- print ("starting honeynode2...")
+ print("starting honeynode2...")
cls.honeynode_process2 = test_utils.start_roadma_honeynode()
time.sleep(20)
- print ("starting opendaylight...")
+ print("starting opendaylight...")
cls.odl_process = test_utils.start_tpce()
time.sleep(60)
- print ("opendaylight started")
+ print("opendaylight started")
@classmethod
def tearDownClass(cls):
cls.honeynode_process2.wait()
def setUp(self):
- print ("execution of {}".format(self.id().split(".")[-1]))
+ print("execution of {}".format(self.id().split(".")[-1]))
time.sleep(10)
-#END_IGNORE_XTESTING
+# END_IGNORE_XTESTING
# def test_01_restconfAPI(self):
# url = ("{}/operational/network-topology:network-topology/topology/"
# res = response.json()
# self.assertIn(
# {"error-type":"application", "error-tag":"data-missing",
-# "error-message":"Request could not be completed because the relevant data model content does not exist "},
+# "error-message":"Request could not be completed because the relevant data model content does not exist "},
# res['errors']['error'])
def test_01_rdm_device_connected(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/ROADMA01"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"node": [{
"node-id": "ROADMA01",
"netconf-node-topology:username": "admin",
res = response.json()
self.assertEqual(
{u'node-info': {u'node-type': u'rdm',
- u'node-ip-address': u'127.0.0.12',
- u'node-clli': u'NodeA',
- u'openroadm-version': u'1.2.1', u'node-vendor': u'vendorA',
- u'node-model': u'2'}},
+ u'node-ip-address': u'127.0.0.12',
+ u'node-clli': u'NodeA',
+ u'openroadm-version': u'1.2.1', u'node-vendor': u'vendorA',
+ u'node-model': u'2'}},
res)
time.sleep(3)
def test_07_xpdr_device_connected(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/XPDRA01"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"node": [{
"node-id": "XPDRA01",
"netconf-node-topology:username": "admin",
res = response.json()
self.assertEqual(
{u'node-info': {u'node-type': u'xpdr',
- u'node-ip-address': u'127.0.0.10',
- u'node-clli': u'NodeA',
- u'openroadm-version': u'1.2.1', u'node-vendor': u'vendorA',
- u'node-model': u'1'}},
+ u'node-ip-address': u'127.0.0.10',
+ u'node-clli': u'NodeA',
+ u'openroadm-version': u'1.2.1', u'node-vendor': u'vendorA',
+ u'node-model': u'1'}},
res)
time.sleep(3)
def test_16_xpdr_device_disconnected(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDRA01"
+ "network-topology/topology/topology-netconf/node/XPDRA01"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(20)
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing",
- "error-message":"Request could not be completed because the relevant data model content does not exist"},
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
res['errors']['error'])
def test_18_xpdr_device_disconnected(self):
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing",
- "error-message":"Request could not be completed because the relevant data model content does not exist"},
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
res['errors']['error'])
def test_19_rdm_device_disconnected(self):
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(20)
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing",
- "error-message":"Request could not be completed because the relevant data model content does not exist"},
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
res['errors']['error'])
def test_21_rdm_device_disconnected(self):
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing",
- "error-message":"Request could not be completed because the relevant data model content does not exist"},
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
res['errors']['error'])
odl_process = None
restconf_baseurl = "http://localhost:8181/restconf"
-#START_IGNORE_XTESTING
+# START_IGNORE_XTESTING
@classmethod
def setUpClass(cls):
- print ("starting honeynode1...")
+ print("starting honeynode1...")
cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
time.sleep(20)
- print ("starting honeynode2...")
+ print("starting honeynode2...")
cls.honeynode_process2 = test_utils.start_roadma_honeynode()
time.sleep(20)
- print ("starting opendaylight...")
+ print("starting opendaylight...")
cls.odl_process = test_utils.start_tpce()
time.sleep(60)
- print ("opendaylight started")
+ print("opendaylight started")
@classmethod
def tearDownClass(cls):
cls.honeynode_process2.wait()
def setUp(self):
- print ("execution of {}".format(self.id().split(".")[-1]))
+ print("execution of {}".format(self.id().split(".")[-1]))
time.sleep(10)
-#END_IGNORE_XTESTING
+# END_IGNORE_XTESTING
def test_01_rdm_device_connected(self):
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": "17831",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "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": "17831",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
def test_02_xpdr_device_connected(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/XPDRA01"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"node": [{
"node-id": "XPDRA01",
"netconf-node-topology:username": "admin",
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
- {'supporting-port': 'L1', 'supporting-circuit-pack-name': '2/0',
- 'logical-connection-point': 'DEG1-TTP-TXRX', 'port-direction': 'bidirectional'},
- res['nodes'][0]['mapping'])
+ {'supporting-port': 'L1', 'supporting-circuit-pack-name': '2/0',
+ 'logical-connection-point': 'DEG1-TTP-TXRX', 'port-direction': 'bidirectional'},
+ res['nodes'][0]['mapping'])
self.assertIn(
- {'supporting-port': 'C7', 'supporting-circuit-pack-name': '4/0',
- 'logical-connection-point': 'SRG1-PP7-TXRX', 'port-direction': 'bidirectional'},
- res['nodes'][0]['mapping'])
+ {'supporting-port': 'C7', 'supporting-circuit-pack-name': '4/0',
+ 'logical-connection-point': 'SRG1-PP7-TXRX', 'port-direction': 'bidirectional'},
+ res['nodes'][0]['mapping'])
def test_04_xpdr_portmapping(self):
url = ("{}/config/transportpce-portmapping:network/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
- {'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
- 'logical-connection-point': 'XPDR1-NETWORK1', 'port-direction': 'bidirectional',
- 'connection-map-lcp': 'XPDR1-CLIENT1', 'port-qual': 'xpdr-network'},
- res['nodes'][0]['mapping'])
+ {'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
+ 'logical-connection-point': 'XPDR1-NETWORK1', 'port-direction': 'bidirectional',
+ 'connection-map-lcp': 'XPDR1-CLIENT1', 'port-qual': 'xpdr-network'},
+ res['nodes'][0]['mapping'])
self.assertIn(
- {'supporting-port': 'C1',
- 'supporting-circuit-pack-name': '1/0/C1-PLUG-CLIENT',
- 'logical-connection-point': 'XPDR1-CLIENT1', 'port-direction': 'bidirectional',
- 'connection-map-lcp': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-client'},
- res['nodes'][0]['mapping'])
+ {'supporting-port': 'C1',
+ 'supporting-circuit-pack-name': '1/0/C1-PLUG-CLIENT',
+ 'logical-connection-point': 'XPDR1-CLIENT1', 'port-direction': 'bidirectional',
+ 'connection-map-lcp': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-client'},
+ res['nodes'][0]['mapping'])
def test_05_service_path_create(self):
url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
data = {"renderer:input": {
- "renderer:service-name": "service_test",
- "renderer:wave-number": "7",
- "renderer:modulation-format": "qpsk",
- "renderer:operation": "create",
- "renderer:nodes": [
- {"renderer:node-id": "ROADMA01",
- "renderer:src-tp": "SRG1-PP7-TXRX",
- "renderer:dest-tp": "DEG1-TTP-TXRX"},
- {"renderer:node-id": "XPDRA01",
- "renderer:src-tp": "XPDR1-CLIENT1",
- "renderer:dest-tp": "XPDR1-NETWORK1"}]}}
+ "renderer:service-name": "service_test",
+ "renderer:wave-number": "7",
+ "renderer:modulation-format": "qpsk",
+ "renderer:operation": "create",
+ "renderer:nodes": [
+ {"renderer:node-id": "ROADMA01",
+ "renderer:src-tp": "SRG1-PP7-TXRX",
+ "renderer:dest-tp": "DEG1-TTP-TXRX"},
+ {"renderer:node-id": "XPDRA01",
+ "renderer:src-tp": "XPDR1-CLIENT1",
+ "renderer:dest-tp": "XPDR1-NETWORK1"}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes: ROADMA01', res["output"]["result"])
def test_06_service_path_create_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/DEG1-TTP-TXRX-7"
- .format(self.restconf_baseurl))
+ "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/DEG1-TTP-TXRX-7"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset({'name': 'DEG1-TTP-TXRX-7', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': '2/0',
- 'type': 'org-openroadm-interfaces:opticalChannel',
- 'supporting-port': 'L1'}, res['interface'][0])
+ 'supporting-circuit-pack-name': '2/0',
+ 'type': 'org-openroadm-interfaces:opticalChannel',
+ 'supporting-port': 'L1'}, res['interface'][0])
self.assertDictEqual(
- {'wavelength-number': 7},
- res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
+ {'wavelength-number': 7},
+ res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
def test_07_service_path_create_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/SRG1-PP7-TXRX-7"
- .format(self.restconf_baseurl))
+ "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/SRG1-PP7-TXRX-7"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'name': 'SRG1-PP7-TXRX-7', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': '4/0',
- 'type': 'org-openroadm-interfaces:opticalChannel',
- 'supporting-port': 'C7'},
- res['interface'][0])
+ {'name': 'SRG1-PP7-TXRX-7', 'administrative-state': 'inService',
+ 'supporting-circuit-pack-name': '4/0',
+ 'type': 'org-openroadm-interfaces:opticalChannel',
+ 'supporting-port': 'C7'},
+ res['interface'][0])
self.assertDictEqual(
- {'wavelength-number': 7},
- res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
+ {'wavelength-number': 7},
+ res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
def test_08_service_path_create_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'connection-number': 'SRG1-PP7-TXRX-DEG1-TTP-TXRX-7',
- 'wavelength-number': 7,
- 'opticalControlMode': 'off'},
- res['roadm-connections'][0])
+ {'connection-number': 'SRG1-PP7-TXRX-DEG1-TTP-TXRX-7',
+ 'wavelength-number': 7,
+ 'opticalControlMode': 'off'},
+ res['roadm-connections'][0])
self.assertDictEqual(
- {'src-if': 'SRG1-PP7-TXRX-7'},
- res['roadm-connections'][0]['source'])
+ {'src-if': 'SRG1-PP7-TXRX-7'},
+ res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG1-TTP-TXRX-7'},
- res['roadm-connections'][0]['destination'])
+ {'dst-if': 'DEG1-TTP-TXRX-7'},
+ res['roadm-connections'][0]['destination'])
def test_09_service_path_create_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/XPDRA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-NETWORK1-7"
- .format(self.restconf_baseurl))
+ "node/XPDRA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-NETWORK1-7"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'name': 'XPDR1-NETWORK1-7', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
- 'type': 'org-openroadm-interfaces:opticalChannel',
- 'supporting-port': '1'},
- res['interface'][0])
+ {'name': 'XPDR1-NETWORK1-7', 'administrative-state': 'inService',
+ 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
+ 'type': 'org-openroadm-interfaces:opticalChannel',
+ 'supporting-port': '1'},
+ res['interface'][0])
self.assertDictEqual(
- {u'rate': u'org-openroadm-optical-channel-interfaces:R100G',
- u'transmit-power':-5,
- u'wavelength-number': 7,
- u'modulation-format': u'dp-qpsk'},
- res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
+ {u'rate': u'org-openroadm-optical-channel-interfaces:R100G',
+ u'transmit-power': -5,
+ u'wavelength-number': 7,
+ u'modulation-format': u'dp-qpsk'},
+ res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
def test_10_service_path_create_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/XPDRA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-NETWORK1-OTU"
- .format(self.restconf_baseurl))
+ "node/XPDRA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-NETWORK1-OTU"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'name': 'XPDR1-NETWORK1-OTU', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
- 'type': 'org-openroadm-interfaces:otnOtu',
- 'supporting-port': '1',
- 'supporting-interface': 'XPDR1-NETWORK1-7'},
- res['interface'][0])
+ {'name': 'XPDR1-NETWORK1-OTU', 'administrative-state': 'inService',
+ 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
+ 'type': 'org-openroadm-interfaces:otnOtu',
+ 'supporting-port': '1',
+ 'supporting-interface': 'XPDR1-NETWORK1-7'},
+ res['interface'][0])
self.assertDictEqual(
- {u'rate': u'org-openroadm-otn-otu-interfaces:OTU4',
- u'fec': u'scfec'},
- res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
+ {u'rate': u'org-openroadm-otn-otu-interfaces:OTU4',
+ u'fec': u'scfec'},
+ res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
def test_11_service_path_create_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/XPDRA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-NETWORK1-ODU"
- .format(self.restconf_baseurl))
+ "node/XPDRA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-NETWORK1-ODU"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'name': 'XPDR1-NETWORK1-ODU', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
- 'type': 'org-openroadm-interfaces:otnOdu',
- 'supporting-port': '1',
- 'supporting-interface': 'XPDR1-NETWORK1-OTU'},
- res['interface'][0])
+ {'name': 'XPDR1-NETWORK1-ODU', 'administrative-state': 'inService',
+ 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
+ 'type': 'org-openroadm-interfaces:otnOdu',
+ 'supporting-port': '1',
+ 'supporting-interface': 'XPDR1-NETWORK1-OTU'},
+ res['interface'][0])
self.assertDictContainsSubset(
- {'rate': 'org-openroadm-otn-odu-interfaces:ODU4',
- u'monitoring-mode': u'terminated'},
- res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
+ {'rate': 'org-openroadm-otn-odu-interfaces:ODU4',
+ u'monitoring-mode': u'terminated'},
+ res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
self.assertDictEqual({u'exp-payload-type': u'07', u'payload-type': u'07'},
- res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
+ res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_12_service_path_create_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'name': 'XPDR1-CLIENT1-ETHERNET', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': '1/0/C1-PLUG-CLIENT',
- 'type': 'org-openroadm-interfaces:ethernetCsmacd',
- 'supporting-port': 'C1'},
- res['interface'][0])
+ {'name': 'XPDR1-CLIENT1-ETHERNET', 'administrative-state': 'inService',
+ 'supporting-circuit-pack-name': '1/0/C1-PLUG-CLIENT',
+ 'type': 'org-openroadm-interfaces:ethernetCsmacd',
+ 'supporting-port': 'C1'},
+ res['interface'][0])
self.assertDictEqual(
- {'speed': 100000,
- 'mtu': 9000,
- 'auto-negotiation': 'enabled',
- 'duplex': 'full',
- 'fec': 'off'},
- res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
+ {'speed': 100000,
+ 'mtu': 9000,
+ 'auto-negotiation': 'enabled',
+ 'duplex': 'full',
+ 'fec': 'off'},
+ res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
def test_13_service_path_create_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/XPDRA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "circuit-packs/1%2F0%2F1-PLUG-NET"
- .format(self.restconf_baseurl))
+ "node/XPDRA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "circuit-packs/1%2F0%2F1-PLUG-NET"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('not-reserved-inuse', res['circuit-packs'][0]["equipment-state"])
def test_14_service_path_delete(self):
url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
data = {"renderer:input": {
- "renderer:service-name": "service_test",
- "renderer:wave-number": "7",
- "renderer:operation": "delete",
- "renderer:nodes": [
- {"renderer:node-id": "ROADMA01",
- "renderer:src-tp": "SRG1-PP7-TXRX",
- "renderer:dest-tp": "DEG1-TTP-TXRX"},
- {"renderer:node-id": "XPDRA01",
- "renderer:src-tp": "XPDR1-CLIENT1",
- "renderer:dest-tp": "XPDR1-NETWORK1"}]}}
+ "renderer:service-name": "service_test",
+ "renderer:wave-number": "7",
+ "renderer:operation": "delete",
+ "renderer:nodes": [
+ {"renderer:node-id": "ROADMA01",
+ "renderer:src-tp": "SRG1-PP7-TXRX",
+ "renderer:dest-tp": "DEG1-TTP-TXRX"},
+ {"renderer:node-id": "XPDRA01",
+ "renderer:src-tp": "XPDR1-CLIENT1",
+ "renderer:dest-tp": "XPDR1-NETWORK1"}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(response.json(), {
- 'output': {'result': 'Request processed', 'success': True}})
+ 'output': {'result': 'Request processed', 'success': True}})
def test_15_service_path_delete_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/DEG1-TTP-TXRX-7"
- .format(self.restconf_baseurl))
+ "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/DEG1-TTP-TXRX-7"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing",
- "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_16_service_path_delete_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_17_service_path_delete_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_18_service_path_delete_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_19_service_path_delete_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_20_service_path_delete_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_21_service_path_delete_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_22_service_path_delete_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(20)
def test_24_xpdr_device_disconnected(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDRA01"
+ "network-topology/topology/topology-netconf/node/XPDRA01"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(20)
#!/usr/bin/env python
##############################################################################
-#Copyright (c) 2017 Orange, Inc. and others. All rights reserved.
+# Copyright (c) 2017 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
##############################################################################
import json
-import os
-import psutil
-import requests
import signal
-import shutil
-import subprocess
import time
import unittest
-import logging
+import requests
+import psutil
import test_utils
+
class TransportPCEtesting(unittest.TestCase):
honeynode_process1 = None
odl_process = None
restconf_baseurl = "http://localhost:8181/restconf"
-#START_IGNORE_XTESTING
+# START_IGNORE_XTESTING
@classmethod
def setUpClass(cls):
- print ("starting honeynode1...")
+ print("starting honeynode1...")
cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
time.sleep(20)
- print ("starting honeynode2...")
+ print("starting honeynode2...")
cls.honeynode_process2 = test_utils.start_roadma_honeynode()
time.sleep(20)
- print ("starting opendaylight...")
+ print("starting opendaylight...")
cls.odl_process = test_utils.start_tpce()
time.sleep(60)
- print ("opendaylight started")
+ print("opendaylight started")
@classmethod
def tearDownClass(cls):
def setUp(self):
time.sleep(10)
-#END_IGNORE_XTESTING
+# END_IGNORE_XTESTING
- #Connect the ROADMA
+ # Connect the ROADMA
def test_01_connect_rdm(self):
- #Config ROADMA
+ # Config ROADMA
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMA01"
+ "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": "17831",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "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": "17831",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
- #Verify the termination points of the ROADMA
+ # Verify the termination points of the ROADMA
def test_02_compareOpenroadmTopologyPortMapping_rdm(self):
urlTopo = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
- responseTopo = requests.request(
- "GET", urlTopo, headers=headers, auth=('admin', 'admin'))
+ responseTopo = requests.request("GET", urlTopo, headers=headers, auth=('admin', 'admin'))
resTopo = responseTopo.json()
nbNode = len(resTopo['network'][0]['node'])
nbMapCumul = 0
nodeMapId = nodeId.split("-")[0]
urlMapList = "{}/config/transportpce-portmapping:network/nodes/" + nodeMapId
urlMapListFull = urlMapList.format(self.restconf_baseurl)
- responseMapList = requests.request(
- "GET", urlMapListFull, headers=headers, auth=('admin', 'admin'))
+ responseMapList = requests.request("GET", urlMapListFull, headers=headers, auth=('admin', 'admin'))
resMapList = responseMapList.json()
nbMappings = len(resMapList['nodes'][0]['mapping']) - nbMapCumul
for j in range(0, nbTp):
tpId = resTopo['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
if((not "CP" in tpId) and (not "CTP" in tpId)):
- urlMap = "{}/config/transportpce-portmapping:network/nodes/" + nodeMapId + "/mapping/" + tpId
- urlMapFull = urlMap.format(self.restconf_baseurl)
- responseMap = requests.request(
- "GET", urlMapFull, headers=headers, auth=('admin', 'admin'))
- self.assertEqual(responseMap.status_code, requests.codes.ok)
- if(responseMap.status_code == requests.codes.ok):
+ urlMap = "{}/config/transportpce-portmapping:network/nodes/" + nodeMapId + "/mapping/" + tpId
+ urlMapFull = urlMap.format(self.restconf_baseurl)
+ responseMap = requests.request("GET", urlMapFull, headers=headers, auth=('admin', 'admin'))
+ self.assertEqual(responseMap.status_code, requests.codes.ok)
+ if responseMap.status_code == requests.codes.ok:
nbMapCurrent += 1
nbMapCumul += nbMapCurrent
nbMappings -= nbMapCurrent
self.assertEqual(nbMappings, 0)
- #Disconnect the ROADMA
+ # Disconnect the ROADMA
def test_03_disconnect_rdm(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMA01"
+ "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'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
# #Connect the XPDRA
def test_04_connect_xpdr(self):
- #Config XPDRA
- 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": "17830",
- "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)
+ # Config XPDRA
+ 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": "17830",
+ "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)
# #Verify the termination points related to XPDR
def test_05_compareOpenroadmTopologyPortMapping_xpdr(self):
self.test_02_compareOpenroadmTopologyPortMapping_rdm()
- #Disconnect the XPDRA
+ # Disconnect the XPDRA
def test_06_disconnect_device(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/XPDRA01"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
+
if __name__ == "__main__":
- #logging.basicConfig(filename='./transportpce_tests/log/response.log',filemode='w',level=logging.DEBUG)
+ # logging.basicConfig(filename='./transportpce_tests/log/response.log',filemode='w',level=logging.DEBUG)
#logging.debug('I am there')
unittest.main(verbosity=2)
#!/usr/bin/env python
##############################################################################
-#Copyright (c) 2017 Orange, Inc. and others. All rights reserved.
+# Copyright (c) 2017 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
##############################################################################
import json
-import os
-import psutil
-import requests
import signal
-import shutil
-import subprocess
import time
import unittest
-import logging
+import requests
+import psutil
import test_utils
+
class TransportPCETopologyTesting(unittest.TestCase):
honeynode_process1 = None
odl_process = None
restconf_baseurl = "http://localhost:8181/restconf"
-#START_IGNORE_XTESTING
+# START_IGNORE_XTESTING
@classmethod
def setUpClass(cls):
- print ("starting honeynode1...")
+ print("starting honeynode1...")
cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
time.sleep(20)
- print ("starting honeynode2...")
+ print("starting honeynode2...")
cls.honeynode_process2 = test_utils.start_roadma_honeynode()
time.sleep(20)
- print ("starting honeynode3...")
+ print("starting honeynode3...")
cls.honeynode_process3 = test_utils.start_roadmb_honeynode()
time.sleep(20)
- print ("starting honeynode4...")
+ print("starting honeynode4...")
cls.honeynode_process4 = test_utils.start_roadmc_honeynode()
time.sleep(20)
- print ("all honeynodes started")
+ print("all honeynodes started")
- print ("starting opendaylight...")
+ print("starting opendaylight...")
cls.odl_process = test_utils.start_tpce()
time.sleep(60)
- print ("opendaylight started")
+ print("opendaylight started")
@classmethod
def tearDownClass(cls):
def setUp(self):
time.sleep(5)
-#END_IGNORE_XTESTING
+# END_IGNORE_XTESTING
def test_01_connect_ROADMA(self):
- #Config ROADMA
+ # Config ROADMA
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMA01"
+ "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": "17831",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "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": "17831",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
def test_02_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- self.assertEqual(res['network'][0]['node'][0]['node-id'],'NodeA')
- self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
+ 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_03_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- self.assertEqual(res['network'][0]['node'][0]['node-id'],'ROADMA01')
- self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'],'clli-network')
- self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'],'NodeA')
- self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'],'ROADM')
- self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'],'2')
+ self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADMA01')
+ self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
+ self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
+ self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
+ 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))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- #Tests related to links
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
- self.assertEqual(nbLink,10)
- expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
- addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
- 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
- dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
- 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
- for i in range(0,nbLink):
+ # Tests related to links
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
+ self.assertEqual(nbLink, 10)
+ expressLink = ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
+ 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
+ addLink = ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
+ 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
+ dropLink = ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
+ 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
+ for i in range(0, nbLink):
linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
- if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='EXPRESS-LINK'):
- find= linkId in expressLink
+ if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK':
+ find = linkId in expressLink
self.assertEqual(find, True)
expressLink.remove(linkId)
- elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='ADD-LINK'):
- find= linkId in addLink
+ elif res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK':
+ find = linkId in addLink
self.assertEqual(find, True)
addLink.remove(linkId)
- elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='DROP-LINK'):
- find= linkId in dropLink
+ elif res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK':
+ find = linkId in dropLink
self.assertEqual(find, True)
dropLink.remove(linkId)
else:
self.assertFalse(True)
- self.assertEqual(len(expressLink),0)
- self.assertEqual(len(addLink),0)
- self.assertEqual(len(dropLink),0)
+ self.assertEqual(len(expressLink), 0)
+ self.assertEqual(len(addLink), 0)
+ self.assertEqual(len(dropLink), 0)
def test_05_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
- response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ response = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
res = response.json()
- #Tests related to nodes
+ # Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,4)
- listNode=['ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
- for i in range(0,nbNode):
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 4)
+ listNode = ['ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
+ for i in range(0, nbNode):
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
res['network'][0]['node'][i]['supporting-node'])
- nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
- nodeId=res['network'][0]['node'][i]['node-id']
- if(nodeId=='ROADMA01-SRG1'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
+ nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
+ nodeId = res['network'][0]['node'][i]['node-id']
+ if nodeId == 'ROADMA01-SRG1':
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-SRG3'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
+ elif nodeId == 'ROADMA01-SRG3':
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-DEG1'):
- #Test related to DEG1
- self.assertEqual(nodeType,'DEGREE')
+ elif nodeId == 'ROADMA01-DEG1':
+ # Test related to DEG1
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
res['network'][0]['node'][i]['supporting-node'])
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
res['network'][0]['node'][i]['supporting-node'])
- elif(nodeId=='ROADMA01-DEG2'):
- #Test related to DEG2
- self.assertEqual(nodeType,'DEGREE')
+ elif nodeId == 'ROADMA01-DEG2':
+ # Test related to DEG2
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
listNode.remove(nodeId)
else:
self.assertFalse(True)
- self.assertEqual(len(listNode),0)
+ 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": "17830",
- "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)
+ 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": "17830",
+ "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)
def test_07_getClliNetwork(self):
- url = ("{}/config/ietf-network:networks/network/clli-network"
+ 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'))
- 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')
+ headers = {'content-type': 'application/json'}
+ response = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res = response.json()
+ self.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"
+ 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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- res = response.json()
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,2)
- for i in range(0,nbNode):
- self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
- self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
- nodeId=res['network'][0]['node'][i]['node-id']
- if(nodeId=='XPDRA01'):
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'XPONDER')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'1')
- elif(nodeId=='ROADMA01'):
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
- else:
+ headers = {'content-type': 'application/json'}
+ response = requests.request(
+ "GET", url, headers=headers, auth=('admin', 'admin'))
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res = response.json()
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 2)
+ for i in range(0, nbNode):
+ self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
+ self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
+ nodeId = res['network'][0]['node'][i]['node-id']
+ if(nodeId == 'XPDRA01'):
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], '1')
+ elif(nodeId == 'ROADMA01'):
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], '2')
+ else:
self.assertFalse(True)
def test_09_getNodes_OpenRoadmTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
+ 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'))
- res = response.json()
- #Tests related to nodes
- self.assertEqual(response.status_code, requests.codes.ok)
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,5)
- listNode=['XPDRA01-XPDR1','ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
- for i in range(0,nbNode):
- nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
- nodeId=res['network'][0]['node'][i]['node-id']
- #Tests related to XPDRA nodes
- if(nodeId=='XPDRA01-XPDR1'):
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(nodeType,'XPONDER')
- nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- client = 0
- network = 0
- for j in range(0,nbTps):
- tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
- tpId=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
- if (tpType=='XPONDER-CLIENT'):
- client += 1
- elif (tpType=='XPONDER-NETWORK'):
- network += 1
- if (tpId == 'XPDR1-NETWORK2'):
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['transportpce-topology:associated-connection-map-port'],'XPDR1-CLIENT3')
- if (tpId == 'XPDR1-CLIENT3'):
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['transportpce-topology:associated-connection-map-port'],'XPDR1-NETWORK2')
- self.assertTrue(client == 4)
- self.assertTrue(network == 2)
- listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-SRG1'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
- self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
- res['network'][0]['node'][i]['supporting-node'])
- listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-SRG3'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
- self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
- res['network'][0]['node'][i]['supporting-node'])
- listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-DEG1'):
- #Test related to DEG1
- self.assertEqual(nodeType,'DEGREE')
+ headers = {'content-type': 'application/json'}
+ response = requests.request(
+ "GET", url, headers=headers, auth=('admin', 'admin'))
+ res = response.json()
+ # Tests related to nodes
+ self.assertEqual(response.status_code, requests.codes.ok)
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 5)
+ listNode = ['XPDRA01-XPDR1', 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
+ for i in range(0, nbNode):
+ nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
+ nodeId = res['network'][0]['node'][i]['node-id']
+ # Tests related to XPDRA nodes
+ if(nodeId == 'XPDRA01-XPDR1'):
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(nodeType, 'XPONDER')
+ nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ client = 0
+ network = 0
+ for j in range(0, nbTps):
+ tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
+ tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
+ if (tpType == 'XPONDER-CLIENT'):
+ client += 1
+ elif (tpType == 'XPONDER-NETWORK'):
+ network += 1
+ if (tpId == 'XPDR1-NETWORK2'):
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point']
+ [j]['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT3')
+ if (tpId == 'XPDR1-CLIENT3'):
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point']
+ [j]['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
+ self.assertTrue(client == 4)
+ self.assertTrue(network == 2)
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADMA01-SRG1'):
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
+ self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
+ res['network'][0]['node'][i]['supporting-node'])
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADMA01-SRG3'):
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
+ self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
+ res['network'][0]['node'][i]['supporting-node'])
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADMA01-DEG1'):
+ # Test related to DEG1
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-DEG2'):
- #Test related to DEG2
- self.assertEqual(nodeType,'DEGREE')
+ elif(nodeId == 'ROADMA01-DEG2'):
+ # Test related to DEG2
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- else:
+ else:
self.assertFalse(True)
- self.assertEqual(len(listNode),0)
+ self.assertEqual(len(listNode), 0)
- #Connect the tail XPDRA to ROADMA and vice versa
+ # Connect the tail XPDRA to ROADMA and vice versa
def test_10_connect_tail_xpdr_rdm(self):
- #Connect the tail: XPDRA to ROADMA
+ # Connect the tail: XPDRA to ROADMA
url = ("{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
- .format(self.restconf_baseurl))
+ .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"
+ "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'))
+ "POST", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
def test_11_connect_tail_rdm_xpdr(self):
- #Connect the tail: ROADMA to XPDRA
+ # Connect the tail: ROADMA to XPDRA
url = ("{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
- .format(self.restconf_baseurl))
+ .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"
+ "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'))
+ "POST", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
def test_12_getLinks_OpenRoadmTopology(self):
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- #Tests related to links
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
- self.assertEqual(nbLink,12)
- expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
- addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
- 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
- dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
- 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
- XPDR_IN=['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1']
- XPDR_OUT=['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
- for i in range(0,nbLink):
- nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
- linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
- if(nodeType=='EXPRESS-LINK'):
- find= linkId in expressLink
+ # Tests related to links
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
+ self.assertEqual(nbLink, 12)
+ expressLink = ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
+ 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
+ addLink = ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
+ 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
+ dropLink = ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
+ 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
+ XPDR_IN = ['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1']
+ XPDR_OUT = ['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
+ for i in range(0, nbLink):
+ nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
+ linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
+ if(nodeType == 'EXPRESS-LINK'):
+ find = linkId in expressLink
self.assertEqual(find, True)
expressLink.remove(linkId)
- elif(nodeType=='ADD-LINK'):
- find= linkId in addLink
+ elif(nodeType == 'ADD-LINK'):
+ find = linkId in addLink
self.assertEqual(find, True)
addLink.remove(linkId)
- elif(nodeType=='DROP-LINK'):
- find= linkId in dropLink
+ elif(nodeType == 'DROP-LINK'):
+ find = linkId in dropLink
self.assertEqual(find, True)
dropLink.remove(linkId)
- elif(nodeType=='XPONDER-INPUT'):
- find= linkId in XPDR_IN
+ elif(nodeType == 'XPONDER-INPUT'):
+ find = linkId in XPDR_IN
self.assertEqual(find, True)
XPDR_IN.remove(linkId)
- elif(nodeType=='XPONDER-OUTPUT'):
- find= linkId in XPDR_OUT
+ elif(nodeType == 'XPONDER-OUTPUT'):
+ find = linkId in XPDR_OUT
self.assertEqual(find, True)
XPDR_OUT.remove(linkId)
else:
self.assertFalse(True)
- self.assertEqual(len(expressLink),0)
- self.assertEqual(len(addLink),0)
- self.assertEqual(len(dropLink),0)
- self.assertEqual(len(XPDR_IN),0)
- self.assertEqual(len(XPDR_OUT),0)
+ self.assertEqual(len(expressLink), 0)
+ self.assertEqual(len(addLink), 0)
+ self.assertEqual(len(dropLink), 0)
+ self.assertEqual(len(XPDR_IN), 0)
+ self.assertEqual(len(XPDR_OUT), 0)
def test_13_connect_ROADMC(self):
- #Config ROADMC
+ # Config ROADMC
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMC01"
- .format(self.restconf_baseurl))
+ "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": "17833",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "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": "17833",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
def test_16_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbNode=len(res['network'][0]['node'])
- listNode=['NodeA','NodeC']
- for i in range(0,nbNode):
+ nbNode = len(res['network'][0]['node'])
+ listNode = ['NodeA', 'NodeC']
+ for i in range(0, nbNode):
nodeId = res['network'][0]['node'][i]['node-id']
- find= nodeId in listNode
+ find = nodeId in listNode
self.assertEqual(find, True)
- if(nodeId=='NodeA'):
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
+ if(nodeId == 'NodeA'):
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
else:
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
listNode.remove(nodeId)
- self.assertEqual(len(listNode),0)
+ self.assertEqual(len(listNode), 0)
def test_17_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,3)
- listNode=['XPDRA01','ROADMA01','ROADMC01']
- for i in range(0,nbNode):
- self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
- nodeId=res['network'][0]['node'][i]['node-id']
- if(nodeId=='XPDRA01'):
- self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'XPONDER')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'1')
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 3)
+ listNode = ['XPDRA01', 'ROADMA01', 'ROADMC01']
+ for i in range(0, nbNode):
+ self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
+ nodeId = res['network'][0]['node'][i]['node-id']
+ if(nodeId == 'XPDRA01'):
+ self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], '1')
listNode.remove(nodeId)
- elif(nodeId=='ROADMA01'):
- self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
+ elif(nodeId == 'ROADMA01'):
+ self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], '2')
listNode.remove(nodeId)
- elif(nodeId=='ROADMC01'):
- self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeC')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
+ elif(nodeId == 'ROADMC01'):
+ self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeC')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], '2')
listNode.remove(nodeId)
else:
self.assertFalse(True)
- self.assertEqual(len(listNode),0)
+ self.assertEqual(len(listNode), 0)
def test_18_getROADMLinkOpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- #Tests related to links
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
- self.assertEqual(nbLink,20)
- expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
- 'ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX','ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX']
- addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
- 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
- 'ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX','ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX']
- dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
- 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
- 'ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX','ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX']
- R2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX','ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
- XPDR_IN=['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1']
- XPDR_OUT=['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
- for i in range(0,nbLink):
- nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
- linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
- if(nodeType=='EXPRESS-LINK'):
- find= linkId in expressLink
+ # Tests related to links
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
+ self.assertEqual(nbLink, 20)
+ expressLink = ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX', 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
+ 'ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX', 'ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX']
+ addLink = ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
+ 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
+ 'ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX', 'ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX']
+ dropLink = ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
+ 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
+ 'ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX', 'ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX']
+ R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
+ 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
+ XPDR_IN = ['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1']
+ XPDR_OUT = ['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
+ for i in range(0, nbLink):
+ nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
+ linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
+ if(nodeType == 'EXPRESS-LINK'):
+ find = linkId in expressLink
self.assertEqual(find, True)
expressLink.remove(linkId)
- elif(nodeType=='ADD-LINK'):
- find= linkId in addLink
+ elif(nodeType == 'ADD-LINK'):
+ find = linkId in addLink
self.assertEqual(find, True)
addLink.remove(linkId)
- elif(nodeType=='DROP-LINK'):
- find= linkId in dropLink
+ elif(nodeType == 'DROP-LINK'):
+ find = linkId in dropLink
self.assertEqual(find, True)
dropLink.remove(linkId)
- elif(nodeType=='ROADM-TO-ROADM'):
- find= linkId in R2RLink
+ elif(nodeType == 'ROADM-TO-ROADM'):
+ find = linkId in R2RLink
self.assertEqual(find, True)
R2RLink.remove(linkId)
- elif(nodeType=='XPONDER-INPUT'):
- find= linkId in XPDR_IN
+ elif(nodeType == 'XPONDER-INPUT'):
+ find = linkId in XPDR_IN
self.assertEqual(find, True)
XPDR_IN.remove(linkId)
- elif(nodeType=='XPONDER-OUTPUT'):
- find= linkId in XPDR_OUT
+ elif(nodeType == 'XPONDER-OUTPUT'):
+ find = linkId in XPDR_OUT
self.assertEqual(find, True)
XPDR_OUT.remove(linkId)
else:
self.assertFalse(True)
- self.assertEqual(len(expressLink),0)
- self.assertEqual(len(addLink),0)
- self.assertEqual(len(dropLink),0)
- self.assertEqual(len(R2RLink),0)
- self.assertEqual(len(XPDR_IN),0)
- self.assertEqual(len(XPDR_OUT),0)
+ self.assertEqual(len(expressLink), 0)
+ self.assertEqual(len(addLink), 0)
+ self.assertEqual(len(dropLink), 0)
+ self.assertEqual(len(R2RLink), 0)
+ self.assertEqual(len(XPDR_IN), 0)
+ self.assertEqual(len(XPDR_OUT), 0)
def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- #Tests related to links
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
- self.assertEqual(nbLink,20)
- R2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
- 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
- for i in range(0,nbLink):
+ # Tests related to links
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
+ self.assertEqual(nbLink, 20)
+ R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
+ 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
+ for i in range(0, nbLink):
nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
- link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
+ link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
if(link_id in R2RLink):
find = False
spanLoss = res['network'][0]['ietf-network-topology:link'][i][
'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
length = res['network'][0]['ietf-network-topology:link'][i][
'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
- if((spanLoss!=None)&(length!=None)):
+ if((spanLoss != None) & (length != None)):
find = True
self.assertTrue(find)
R2RLink.remove(link_id)
- self.assertEqual(len(R2RLink),0)
+ self.assertEqual(len(R2RLink), 0)
def test_20_getNodes_OpenRoadmTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
+ 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'))
- res = response.json()
- #Tests related to nodes
- self.assertEqual(response.status_code, requests.codes.ok)
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,8)
- listNode=['XPDRA01-XPDR1',
- 'ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2',
- 'ROADMC01-SRG1','ROADMC01-DEG1','ROADMC01-DEG2']
- #************************Tests related to XPDRA nodes
- for i in range(0,nbNode):
- nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
- nodeId=res['network'][0]['node'][i]['node-id']
- if(nodeId=='XPDRA01-XPDR1'):
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(nodeType,'XPONDER')
- nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertTrue(nbTps == 6)
- client = 0
- network = 0
- for j in range(0,nbTps):
- tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
- if (tpType=='XPONDER-CLIENT'):
- client += 1
- elif (tpType=='XPONDER-NETWORK'):
- network += 1
- self.assertTrue(client == 4)
- self.assertTrue(network == 2)
- listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-SRG1'):
- #Test related to SRG1
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
- self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
- listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-SRG3'):
- #Test related to SRG1
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
- self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
- listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-DEG1'):
- #Test related to DEG1
- self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
- listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-DEG2'):
- #Test related to DEG2
- self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
- listNode.remove(nodeId)
- elif(nodeId=='ROADMC01-SRG1'):
- #Test related to SRG1
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
- self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
- listNode.remove(nodeId)
- elif(nodeId=='ROADMC01-DEG1'):
- #Test related to DEG1
- self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
- listNode.remove(nodeId)
- elif(nodeId=='ROADMC01-DEG2'):
- #Test related to DEG2
- self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
- listNode.remove(nodeId)
- else:
+ headers = {'content-type': 'application/json'}
+ response = requests.request(
+ "GET", url, headers=headers, auth=('admin', 'admin'))
+ res = response.json()
+ # Tests related to nodes
+ self.assertEqual(response.status_code, requests.codes.ok)
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 8)
+ listNode = ['XPDRA01-XPDR1',
+ 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2',
+ 'ROADMC01-SRG1', 'ROADMC01-DEG1', 'ROADMC01-DEG2']
+ # ************************Tests related to XPDRA nodes
+ for i in range(0, nbNode):
+ nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
+ nodeId = res['network'][0]['node'][i]['node-id']
+ if(nodeId == 'XPDRA01-XPDR1'):
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(nodeType, 'XPONDER')
+ nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertTrue(nbTps == 6)
+ client = 0
+ network = 0
+ for j in range(0, nbTps):
+ tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
+ if (tpType == 'XPONDER-CLIENT'):
+ client += 1
+ elif (tpType == 'XPONDER-NETWORK'):
+ network += 1
+ self.assertTrue(client == 4)
+ self.assertTrue(network == 2)
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADMA01-SRG1'):
+ # Test related to SRG1
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
+ self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADMA01-SRG3'):
+ # Test related to SRG1
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
+ self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADMA01-DEG1'):
+ # Test related to DEG1
+ self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADMA01-DEG2'):
+ # Test related to DEG2
+ self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADMC01-SRG1'):
+ # Test related to SRG1
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
+ self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADMC01-DEG1'):
+ # Test related to DEG1
+ self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADMC01-DEG2'):
+ # Test related to DEG2
+ self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
+ listNode.remove(nodeId)
+ else:
self.assertFalse(True)
- self.assertEqual(len(listNode),0)
+ self.assertEqual(len(listNode), 0)
def test_21_connect_ROADMB(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMB01"
+ "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": "17832",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "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": "17832",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
"pmd": 0.5}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
def test_23_omsAttributes_ROADMB_ROADMA(self):
"pmd": 0.5}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
def test_24_omsAttributes_ROADMB_ROADMC(self):
"pmd": 0.5}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
def test_25_omsAttributes_ROADMC_ROADMB(self):
"pmd": 0.5}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
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))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbNode=len(res['network'][0]['node'])
- listNode=['NodeA','NodeB','NodeC']
- for i in range(0,nbNode):
+ nbNode = len(res['network'][0]['node'])
+ listNode = ['NodeA', 'NodeB', 'NodeC']
+ for i in range(0, nbNode):
nodeId = res['network'][0]['node'][i]['node-id']
- find= nodeId in listNode
+ find = nodeId in listNode
self.assertEqual(find, True)
- if(nodeId=='NodeA'):
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
- elif(nodeId=='NodeB'):
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeB')
+ if(nodeId == 'NodeA'):
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
+ elif(nodeId == 'NodeB'):
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeB')
else:
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
listNode.remove(nodeId)
- self.assertEqual(len(listNode),0)
+ self.assertEqual(len(listNode), 0)
def test_27_verifyDegree(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- #Tests related to links
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
- listR2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX','ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
- 'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX','ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX',
- 'ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX','ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
- for i in range(0,nbLink):
+ # Tests related to links
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
+ listR2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX', 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
+ 'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX', 'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX',
+ 'ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX', 'ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
+ for i in range(0, nbLink):
if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
- find= link_id in listR2RLink
+ find = link_id in listR2RLink
self.assertEqual(find, True)
listR2RLink.remove(link_id)
- self.assertEqual(len(listR2RLink),0)
+ 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'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- #Tests related to links
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
- self.assertEqual(nbLink,34)
- for i in range(0,nbLink):
- link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
- link_type=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
- link_src=res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
- link_dest=res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
- 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
+ # Tests related to links
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
+ self.assertEqual(nbLink, 34)
+ for i in range(0, nbLink):
+ link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
+ link_type = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
+ link_src = res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
+ link_dest = res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
+ 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'))
self.assertEqual(response_oppLink.status_code, requests.codes.ok)
res_oppLink = response_oppLink.json()
- self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:opposite-link'],link_id)
- self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'],link_dest)
- self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'],link_src)
- oppLink_type=res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
- if link_type=='ADD-LINK':
+ self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
+ ['org-openroadm-common-network:opposite-link'], link_id)
+ self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'], link_dest)
+ self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'], link_src)
+ oppLink_type = res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
+ if link_type == 'ADD-LINK':
self.assertEqual(oppLink_type, 'DROP-LINK')
- elif link_type=='DROP-LINK':
+ elif link_type == 'DROP-LINK':
self.assertEqual(oppLink_type, 'ADD-LINK')
- elif link_type=='EXPRESS-LINK':
+ elif link_type == 'EXPRESS-LINK':
self.assertEqual(oppLink_type, 'EXPRESS-LINK')
- elif link_type=='ROADM-TO-ROADM':
+ elif link_type == 'ROADM-TO-ROADM':
self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
- elif link_type=='XPONDER-INPUT':
+ elif link_type == 'XPONDER-INPUT':
self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
- elif link_type=='XPONDER-OUTPUT':
+ elif link_type == 'XPONDER-OUTPUT':
self.assertEqual(oppLink_type, 'XPONDER-INPUT')
def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
- 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
- 'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX',
- 'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX',
- 'ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX',
- 'ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
- for i in range(0,nbLink):
+ 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
+ 'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX',
+ 'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX',
+ 'ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX',
+ 'ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
+ for i in range(0, nbLink):
nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
- link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
+ link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
if(link_id in R2RLink):
find = False
spanLoss = res['network'][0]['ietf-network-topology:link'][i][
'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
length = res['network'][0]['ietf-network-topology:link'][i][
'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
- if((spanLoss!=None)&(length!=None)):
+ if((spanLoss != None) & (length != None)):
find = True
self.assertTrue(find)
R2RLink.remove(link_id)
- self.assertEqual(len(R2RLink),0)
+ self.assertEqual(len(R2RLink), 0)
def test_30_disconnect_ROADMB(self):
- #Delete in the topology-netconf
+ # Delete in the topology-netconf
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMB01"
+ "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'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
- #Delete in the clli-network
+ # Delete in the clli-network
url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeB"
.format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
def test_31_disconnect_ROADMC(self):
- #Delete in the topology-netconf
+ # Delete in the topology-netconf
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMC01"
+ "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'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
- #Delete in the clli-network
+ # Delete in the clli-network
url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeC"
.format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
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))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
res = response.json()
- #Tests related to nodes
+ # Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,5)
- listNode=['XPDRA01-XPDR1','ROADMA01-SRG1', 'ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
- for i in range(0,nbNode):
- nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
- nodeId=res['network'][0]['node'][i]['node-id']
- #Tests related to XPDRA nodes
- if(nodeId=='XPDRA01-XPDR1'):
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 5)
+ listNode = ['XPDRA01-XPDR1', 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
+ for i in range(0, nbNode):
+ nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
+ nodeId = res['network'][0]['node'][i]['node-id']
+ # Tests related to XPDRA nodes
+ if(nodeId == 'XPDRA01-XPDR1'):
nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
for j in range(0, nbTp):
tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
'ROADMA01-SRG1--SRG1-PP1-TXRX')
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
- res['network'][0]['node'][i]['supporting-node'])
+ res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-SRG1'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
+ elif(nodeId == 'ROADMA01-SRG1'):
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-SRG3'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
+ elif(nodeId == 'ROADMA01-SRG3'):
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-DEG1'):
- #Test related to DEG1
- self.assertEqual(nodeType,'DEGREE')
+ elif(nodeId == 'ROADMA01-DEG1'):
+ # Test related to DEG1
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
- res['network'][0]['node'][i]['supporting-node'])
+ res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-DEG2'):
- #Test related to DEG2
- self.assertEqual(nodeType,'DEGREE')
+ elif(nodeId == 'ROADMA01-DEG2'):
+ # Test related to DEG2
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
listNode.remove(nodeId)
else:
self.assertFalse(True)
- self.assertEqual(len(listNode),0)
- #Test related to SRG1 of ROADMC
- for i in range(0,nbNode):
- self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-SRG1')
- self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-DEG1')
- self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-DEG2')
+ self.assertEqual(len(listNode), 0)
+ # Test related to SRG1 of ROADMC
+ for i in range(0, nbNode):
+ self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMC01-SRG1')
+ self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMC01-DEG1')
+ 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))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,2)
- for i in range(0,nbNode-1):
- self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01')
- self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMB01')
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 2)
+ for i in range(0, nbNode-1):
+ self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMC01')
+ 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))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,1)
- for i in range(0,nbNode-1):
- self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'],'NodeC')
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 1)
+ for i in range(0, nbNode-1):
+ 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))
+ .format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
def test_36_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,1)
- self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 1)
+ self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
def test_37_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,1)
- for i in range(0,nbNode):
- self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'XPDRA01')
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 1)
+ for i in range(0, nbNode):
+ 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))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
res = response.json()
- #Tests related to nodes
+ # Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,4)
- listNode=['ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
- for i in range(0,nbNode):
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 4)
+ listNode = ['ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
+ for i in range(0, nbNode):
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
res['network'][0]['node'][i]['supporting-node'])
- nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
- nodeId=res['network'][0]['node'][i]['node-id']
- if(nodeId=='ROADMA01-SRG1'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
+ nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
+ nodeId = res['network'][0]['node'][i]['node-id']
+ if(nodeId == 'ROADMA01-SRG1'):
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-SRG3'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
+ elif(nodeId == 'ROADMA01-SRG3'):
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-DEG1'):
- #Test related to DEG1
- self.assertEqual(nodeType,'DEGREE')
+ elif(nodeId == 'ROADMA01-DEG1'):
+ # Test related to DEG1
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
listNode.remove(nodeId)
- elif(nodeId=='ROADMA01-DEG2'):
- #Test related to DEG2
- self.assertEqual(nodeType,'DEGREE')
+ elif(nodeId == 'ROADMA01-DEG2'):
+ # Test related to DEG2
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
listNode.remove(nodeId)
else:
self.assertFalse(True)
- self.assertEqual(len(listNode),0)
+ self.assertEqual(len(listNode), 0)
def test_39_disconnect_ROADM_XPDRA_link(self):
- #Link-1
+ # 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))
+ .format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
- #Link-2
+ # 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))
+ .format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
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))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
- self.assertEqual(nbLink,16)
- expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
- addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
- 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
- dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
- 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
+ self.assertEqual(nbLink, 16)
+ expressLink = ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
+ 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
+ addLink = ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
+ 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
+ dropLink = ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
+ 'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
roadmtoroadmLink = 0
- for i in range(0,nbLink):
- if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='EXPRESS-LINK'):
+ for i in range(0, nbLink):
+ if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
- find= link_id in expressLink
+ find = link_id in expressLink
self.assertEqual(find, True)
expressLink.remove(link_id)
- elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='ADD-LINK'):
+ elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
- find= link_id in addLink
+ find = link_id in addLink
self.assertEqual(find, True)
addLink.remove(link_id)
- elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='DROP-LINK'):
+ elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
- find= link_id in dropLink
+ find = link_id in dropLink
self.assertEqual(find, True)
dropLink.remove(link_id)
else:
roadmtoroadmLink += 1
- self.assertEqual(len(expressLink),0)
- self.assertEqual(len(addLink),0)
- self.assertEqual(len(dropLink),0)
+ self.assertEqual(len(expressLink), 0)
+ self.assertEqual(len(addLink), 0)
+ self.assertEqual(len(dropLink), 0)
self.assertEqual(roadmtoroadmLink, 6)
- for i in range(0,nbLink):
- self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'XPONDER-OUTPUT')
- self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'XPONDER-INPUT')
+ for i in range(0, nbLink):
+ self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
+ ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
+ self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
+ ['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"
+ "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'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
- #Delete in the clli-network
+ # Delete in the clli-network
url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeA"
.format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
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))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
def test_43_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
def test_44_check_roadm2roadm_link_persistence(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
self.assertNotIn('node', res['network'][0])
self.assertEqual(nbLink, 6)
+
if __name__ == "__main__":
unittest.main(verbosity=2)
import os
import subprocess
-honeynode_executable=os.path.join(
- os.path.dirname(os.path.realpath(__file__)),
- "..", "..", "honeynode", "1.2.1", "honeynode-distribution", "target", "honeynode-distribution-1.19.04-hc",
- "honeynode-distribution-1.19.04", "honeycomb-tpce")
-samples_directory=os.path.join(
- os.path.dirname(os.path.realpath(__file__)),
- "..", "..", "sample_configs", "openroadm","1.2.1")
+honeynode_executable = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "..", "..", "honeynode", "1.2.1", "honeynode-distribution", "target", "honeynode-distribution-1.19.04-hc",
+ "honeynode-distribution-1.19.04", "honeycomb-tpce")
+samples_directory = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "..", "..", "sample_configs", "openroadm", "1.2.1")
+
+
def start_xpdra_honeynode():
if os.path.isfile(honeynode_executable):
with open('honeynode1.log', 'w') as outfile:
return subprocess.Popen(
- [honeynode_executable, "17830", os.path.join(samples_directory,"oper-XPDRA.xml")],
+ [honeynode_executable, "17830", os.path.join(samples_directory, "oper-XPDRA.xml")],
stdout=outfile, stderr=outfile)
+
def start_roadma_full_honeynode():
if os.path.isfile(honeynode_executable):
with open('honeynode2.log', 'w') as outfile:
return subprocess.Popen(
- [honeynode_executable, "17821", os.path.join(samples_directory,"oper-ROADMA-full.xml")],
+ [honeynode_executable, "17821", os.path.join(samples_directory, "oper-ROADMA-full.xml")],
stdout=outfile, stderr=outfile)
+
def start_roadma_honeynode():
if os.path.isfile(honeynode_executable):
with open('honeynode2.log', 'w') as outfile:
return subprocess.Popen(
- [honeynode_executable, "17831", os.path.join(samples_directory,"oper-ROADMA.xml")],
+ [honeynode_executable, "17831", os.path.join(samples_directory, "oper-ROADMA.xml")],
stdout=outfile, stderr=outfile)
+
def start_roadmb_honeynode():
if os.path.isfile(honeynode_executable):
with open('honeynode3.log', 'w') as outfile:
return subprocess.Popen(
- [honeynode_executable, "17832", os.path.join(samples_directory,"oper-ROADMB.xml")],
+ [honeynode_executable, "17832", os.path.join(samples_directory, "oper-ROADMB.xml")],
stdout=outfile, stderr=outfile)
+
def start_roadmc_full_honeynode():
if os.path.isfile(honeynode_executable):
with open('honeynode3.log', 'w') as outfile:
return subprocess.Popen(
- [honeynode_executable, "17823", os.path.join(samples_directory,"oper-ROADMC-full.xml")],
+ [honeynode_executable, "17823", os.path.join(samples_directory, "oper-ROADMC-full.xml")],
stdout=outfile, stderr=outfile)
+
def start_roadmc_honeynode():
if os.path.isfile(honeynode_executable):
with open('honeynode4.log', 'w') as outfile:
return subprocess.Popen(
- [honeynode_executable, "17833", os.path.join(samples_directory,"oper-ROADMC.xml")],
+ [honeynode_executable, "17833", os.path.join(samples_directory, "oper-ROADMC.xml")],
stdout=outfile, stderr=outfile)
+
def start_xpdrc_honeynode():
if os.path.isfile(honeynode_executable):
with open('honeynode4.log', 'w') as outfile:
return subprocess.Popen(
- [honeynode_executable, "17834", os.path.join(samples_directory,"oper-XPDRC.xml")],
+ [honeynode_executable, "17834", os.path.join(samples_directory, "oper-XPDRC.xml")],
stdout=outfile, stderr=outfile)
+
def start_tpce():
if "USE_LIGHTY" in os.environ and os.environ['USE_LIGHTY'] == 'True':
- 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", "lighty-transportpce-12.0.0-SNAPSHOT",
- "clean-start-controller.sh")
+ os.path.dirname(os.path.realpath(__file__)),
+ "..", "..", "..", "lighty", "target", "lighty-transportpce-12.0.0-SNAPSHOT",
+ "clean-start-controller.sh")
with open('odl.log', 'w') as outfile:
return subprocess.Popen(
["sh", executable], stdout=outfile, stderr=outfile,
stdin=open(os.devnull))
else:
- print ("starting KARAF TransportPCE build...")
+ print("starting KARAF TransportPCE build...")
executable = os.path.join(
- os.path.dirname(os.path.realpath(__file__)),
- "..", "..", "..", "karaf", "target", "assembly", "bin", "karaf")
+ os.path.dirname(os.path.realpath(__file__)),
+ "..", "..", "..", "karaf", "target", "assembly", "bin", "karaf")
with open('odl.log', 'w') as outfile:
return subprocess.Popen(
["sh", executable, "server"], stdout=outfile, stderr=outfile,
honeynode_process3 = None
honeynode_process4 = None
restconf_baseurl = "http://localhost:8181/restconf"
- WAITING = 20 #nominal value is 300
+ WAITING = 20 # nominal value is 300
-#START_IGNORE_XTESTING
+# START_IGNORE_XTESTING
@classmethod
def setUpClass(cls):
- print ("starting honeynode1...")
+ print("starting honeynode1...")
cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
time.sleep(20)
- print ("starting honeynode2...")
+ print("starting honeynode2...")
cls.honeynode_process2 = test_utils.start_roadma_honeynode()
time.sleep(20)
- print ("starting honeynode3...")
+ print("starting honeynode3...")
cls.honeynode_process3 = test_utils.start_roadmc_honeynode()
time.sleep(20)
- print ("starting honeynode4...")
+ print("starting honeynode4...")
cls.honeynode_process4 = test_utils.start_xpdrc_honeynode()
time.sleep(20)
- print ("all honeynodes started")
+ print("all honeynodes started")
- print ("starting opendaylight...")
+ print("starting opendaylight...")
cls.odl_process = test_utils.start_tpce()
time.sleep(80)
- print ("opendaylight started")
+ print("opendaylight started")
@classmethod
def tearDownClass(cls):
child.wait()
cls.honeynode_process4.send_signal(signal.SIGINT)
cls.honeynode_process4.wait()
- print ("all processes killed")
+ print("all processes killed")
def setUp(self): # instruction executed before each test method
- print ("execution of {}".format(self.id().split(".")[-1]))
+ print("execution of {}".format(self.id().split(".")[-1]))
-#END_IGNORE_XTESTING
+# END_IGNORE_XTESTING
# connect netconf devices
def test_01_connect_xpdrA(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/XPDR-A1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"node": [{
"node-id": "XPDR-A1",
"netconf-node-topology:username": "admin",
def test_02_connect_xpdrC(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/XPDR-C1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"node": [{
"node-id": "XPDR-C1",
"netconf-node-topology:username": "admin",
"network-topology/topology/topology-netconf/node/ROADM-A1"
.format(self.restconf_baseurl))
data = {"node": [{
- "node-id": "ROADM-A1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": "17841",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "node-id": "ROADM-A1",
+ "netconf-node-topology:username": "admin",
+ "netconf-node-topology:password": "admin",
+ "netconf-node-topology:host": "127.0.0.1",
+ "netconf-node-topology:port": "17841",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
"network-topology/topology/topology-netconf/node/ROADM-C1"
.format(self.restconf_baseurl))
data = {"node": [{
- "node-id": "ROADM-C1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": "17843",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "node-id": "ROADM-C1",
+ "netconf-node-topology:username": "admin",
+ "netconf-node-topology:password": "admin",
+ "netconf-node-topology:host": "127.0.0.1",
+ "netconf-node-topology:port": "17843",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
-#test service-create for Eth service from xpdr to xpdr
+# test service-create for Eth service from xpdr to xpdr
def test_11_create_eth_service1(self):
url = ("{}/operations/org-openroadm-service:service-create"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
},
"due-date": "2016-11-28T00:00:01Z",
"operator-contact": "pw1234"
- }
- }
+ }
+ }
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"POST", url, data=json.dumps(data), headers=headers,
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
time.sleep(self.WAITING)
def test_12_get_eth_service1(self):
url = ("{}/operational/org-openroadm-service:service-list/services/service1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
- 'opticalControlMode': 'gainLoss',
- 'target-output-power': -3.0},
- res['roadm-connections'][0])
+ {'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
+ 'opticalControlMode': 'gainLoss',
+ 'target-output-power': -3.0},
+ res['roadm-connections'][0])
self.assertDictEqual(
- {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
- res['roadm-connections'][0]['source'])
+ {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
+ res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG2-TTP-TXRX-nmc-1'},
- res['roadm-connections'][0]['destination'])
+ {'dst-if': 'DEG2-TTP-TXRX-nmc-1'},
+ res['roadm-connections'][0]['destination'])
time.sleep(5)
def test_14_check_xc1_ROADMC(self):
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
- 'opticalControlMode': 'gainLoss',
- 'target-output-power': -3.0},
- res['roadm-connections'][0])
+ {'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
+ 'opticalControlMode': 'gainLoss',
+ 'target-output-power': -3.0},
+ res['roadm-connections'][0])
self.assertDictEqual(
- {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
- res['roadm-connections'][0]['source'])
+ {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
+ res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG1-TTP-TXRX-nmc-1'},
- res['roadm-connections'][0]['destination'])
+ {'dst-if': 'DEG1-TTP-TXRX-nmc-1'},
+ res['roadm-connections'][0]['destination'])
time.sleep(5)
def test_15_check_topo_XPDRA(self):
url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDR-A1-XPDR1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
if ele['tp-id'] == 'XPDR1-NETWORK1':
self.assertEqual({u'frequency': 196.1,
u'width': 40},
- ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
+ ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
if ele['tp-id'] == 'XPDR1-CLIENT2' or ele['tp-id'] == 'XPDR1-CLIENT1':
self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
if ele['tp-id'] == 'XPDR1-NETWORK2':
def test_16_check_topo_ROADMA_SRG1(self):
url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-SRG1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn({u'index': 1},
- res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
+ res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
for ele in liste_tp:
if ele['tp-id'] == 'SRG1-PP1-TXRX':
self.assertIn({u'index': 1, u'frequency': 196.1,
u'width': 40},
- ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
+ ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
if ele['tp-id'] == 'SRG1-PP2-TXRX':
self.assertNotIn('used-wavelength', dict.keys(ele))
time.sleep(3)
def test_17_check_topo_ROADMA_DEG1(self):
url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-DEG2"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn({u'index': 1},
- res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
+ res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
for ele in liste_tp:
if ele['tp-id'] == 'DEG2-CTP-TXRX':
self.assertIn({u'index': 1, u'frequency': 196.1,
u'width': 40},
- ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
+ ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
if ele['tp-id'] == 'DEG2-TTP-TXRX':
self.assertIn({u'index': 1, u'frequency': 196.1,
u'width': 40},
- ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
+ ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
time.sleep(3)
def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
def test_22_create_eth_service2(self):
url = ("{}/operations/org-openroadm-service:service-create"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
},
"due-date": "2016-11-28T00:00:01Z",
"operator-contact": "pw1234"
- }
- }
+ }
+ }
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"POST", url, data=json.dumps(data), headers=headers,
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
time.sleep(self.WAITING)
def test_23_get_eth_service2(self):
url = ("{}/operational/org-openroadm-service:service-list/services/service2"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'connection-name': 'DEG2-TTP-TXRX-SRG1-PP2-TXRX-2',
- 'opticalControlMode': 'power'},
- res['roadm-connections'][0])
+ {'connection-name': 'DEG2-TTP-TXRX-SRG1-PP2-TXRX-2',
+ 'opticalControlMode': 'power'},
+ res['roadm-connections'][0])
self.assertDictEqual(
- {'src-if': 'DEG2-TTP-TXRX-nmc-2'},
- res['roadm-connections'][0]['source'])
+ {'src-if': 'DEG2-TTP-TXRX-nmc-2'},
+ res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'SRG1-PP2-TXRX-nmc-2'},
- res['roadm-connections'][0]['destination'])
+ {'dst-if': 'SRG1-PP2-TXRX-nmc-2'},
+ res['roadm-connections'][0]['destination'])
def test_25_check_topo_XPDRA(self):
url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDR-A1-XPDR1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
if ele['tp-id'] == 'XPDR1-NETWORK1':
self.assertEqual({u'frequency': 196.1,
u'width': 40},
- ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
+ ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
if ele['tp-id'] == 'XPDR1-NETWORK2':
self.assertEqual({u'frequency': 196.05,
u'width': 40},
- ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
+ ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT2':
self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
time.sleep(10)
def test_26_check_topo_ROADMA_SRG1(self):
url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-SRG1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- self.assertNotIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
- self.assertNotIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
+ self.assertNotIn({u'index': 1}, res['node'][0]
+ [u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
+ self.assertNotIn({u'index': 2}, res['node'][0]
+ [u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
for ele in liste_tp:
if ele['tp-id'] == 'SRG1-PP1-TXRX':
self.assertIn({u'index': 1, u'frequency': 196.1,
u'width': 40},
- ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
+ ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
self.assertNotIn({u'index': 2, u'frequency': 196.05,
u'width': 40},
- ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
+ ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
if ele['tp-id'] == 'SRG1-PP2-TXRX':
self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
self.assertNotIn({u'index': 1, u'frequency': 196.1,
u'width': 40},
- ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
+ ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
if ele['tp-id'] == 'SRG1-PP3-TXRX':
self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
time.sleep(10)
def test_27_check_topo_ROADMA_DEG2(self):
url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-DEG2"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- self.assertNotIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
- self.assertNotIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
+ self.assertNotIn({u'index': 1}, res['node'][0]
+ [u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
+ self.assertNotIn({u'index': 2}, res['node'][0]
+ [u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
for ele in liste_tp:
if ele['tp-id'] == 'DEG2-CTP-TXRX':
self.assertIn({u'index': 1, u'frequency': 196.1,
u'width': 40},
- ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
+ ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
if ele['tp-id'] == 'DEG2-TTP-TXRX':
self.assertIn({u'index': 1, u'frequency': 196.1,
u'width': 40},
- ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
+ ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
time.sleep(10)
# creation service test on a non-available resource
def test_28_create_eth_service3(self):
url = ("{}/operations/org-openroadm-service:service-create"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
},
"due-date": "2016-11-28T00:00:01Z",
"operator-contact": "pw1234"
- }
- }
+ }
+ }
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"POST", url, data=json.dumps(data), headers=headers,
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
self.assertIn('200', res['output']['configuration-response-common']['response-code'])
time.sleep(self.WAITING)
# add a test that check the openroadm-service-list still only contains 2 elements
def test_29_delete_eth_service3(self):
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
"service-name": "service3",
"tail-retention": "no"
}
- }
- }
+ }
+ }
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data), headers=headers,
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Service \'service3\' does not exist in datastore',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
self.assertIn('500', res['output']['configuration-response-common']['response-code'])
time.sleep(20)
def test_30_delete_eth_service1(self):
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
"service-name": "service1",
"tail-retention": "no"
}
- }
- }
+ }
+ }
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data), headers=headers,
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Renderer service delete in progress',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
time.sleep(20)
def test_31_delete_eth_service2(self):
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
"service-name": "service2",
"tail-retention": "no"
}
- }
- }
+ }
+ }
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data), headers=headers,
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Renderer service delete in progress',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
time.sleep(20)
def test_32_check_no_xc_ROADMA(self):
"node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
.format(self.restconf_baseurl))
response = requests.request(
- "GET", url, auth=('admin', 'admin'))
+ "GET", url, auth=('admin', 'admin'))
res = response.json()
self.assertEqual(response.status_code, requests.codes.ok)
self.assertNotIn('roadm-connections', dict.keys(res['org-openroadm-device']))
def test_33_check_topo_XPDRA(self):
url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDR-A1-XPDR1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
if ele[u'org-openroadm-common-network:tp-type'] == 'XPONDER-CLIENT':
self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
elif (ele[u'org-openroadm-common-network:tp-type'] == 'XPONDER-NETWORK'):
- self.assertIn(u'tail-equipment-id', dict.keys(ele[u'org-openroadm-network-topology:xpdr-network-attributes']))
- self.assertNotIn('wavelength', dict.keys(ele[u'org-openroadm-network-topology:xpdr-network-attributes']))
+ self.assertIn(u'tail-equipment-id',
+ dict.keys(ele[u'org-openroadm-network-topology:xpdr-network-attributes']))
+ self.assertNotIn('wavelength', dict.keys(
+ ele[u'org-openroadm-network-topology:xpdr-network-attributes']))
time.sleep(10)
def test_34_check_topo_ROADMA_SRG1(self):
url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-SRG1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
- self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
+ self.assertIn({u'index': 1}, res['node'][0]
+ [u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
+ self.assertIn({u'index': 2}, res['node'][0]
+ [u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
for ele in liste_tp:
if ele['tp-id'] == 'SRG1-PP1-TXRX' or ele['tp-id'] == 'SRG1-PP1-TXRX':
def test_35_check_topo_ROADMA_DEG2(self):
url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-DEG2"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
- self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
+ self.assertIn({u'index': 1}, res['node'][0]
+ [u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
+ self.assertIn({u'index': 2}, res['node'][0]
+ [u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
for ele in liste_tp:
if ele['tp-id'] == 'DEG2-CTP-TXRX':
# test service-create for Optical Channel (OC) service from srg-pp to srg-pp
def test_36_create_oc_service1(self):
url = ("{}/operations/org-openroadm-service:service-create"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
},
"due-date": "2016-11-28T00:00:01Z",
"operator-contact": "pw1234"
- }
- }
+ }
+ }
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"POST", url, data=json.dumps(data), headers=headers,
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
time.sleep(self.WAITING)
def test_37_get_oc_service1(self):
url = ("{}/operational/org-openroadm-service:service-list/services/service1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
- 'opticalControlMode': 'gainLoss',
- 'target-output-power': -3.0},
- res['roadm-connections'][0])
+ {'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
+ 'opticalControlMode': 'gainLoss',
+ 'target-output-power': -3.0},
+ res['roadm-connections'][0])
self.assertDictEqual(
- {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
- res['roadm-connections'][0]['source'])
+ {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
+ res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG2-TTP-TXRX-nmc-1'},
- res['roadm-connections'][0]['destination'])
+ {'dst-if': 'DEG2-TTP-TXRX-nmc-1'},
+ res['roadm-connections'][0]['destination'])
time.sleep(7)
def test_39_check_xc1_ROADMC(self):
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
- 'opticalControlMode': 'gainLoss',
- 'target-output-power': -3.0},
- res['roadm-connections'][0])
+ {'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
+ 'opticalControlMode': 'gainLoss',
+ 'target-output-power': -3.0},
+ res['roadm-connections'][0])
self.assertDictEqual(
- {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
- res['roadm-connections'][0]['source'])
+ {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
+ res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG1-TTP-TXRX-nmc-1'},
- res['roadm-connections'][0]['destination'])
+ {'dst-if': 'DEG1-TTP-TXRX-nmc-1'},
+ res['roadm-connections'][0]['destination'])
time.sleep(7)
def test_40_create_oc_service2(self):
url = ("{}/operations/org-openroadm-service:service-create"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
},
"due-date": "2016-11-28T00:00:01Z",
"operator-contact": "pw1234"
- }
- }
+ }
+ }
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"POST", url, data=json.dumps(data), headers=headers,
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
time.sleep(self.WAITING)
def test_41_get_oc_service2(self):
url = ("{}/operational/org-openroadm-service:service-list/services/service2"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'connection-name': 'SRG1-PP2-TXRX-DEG2-TTP-TXRX-2',
- 'opticalControlMode': 'gainLoss',
- 'target-output-power': -3.0},
- res['roadm-connections'][0])
+ {'connection-name': 'SRG1-PP2-TXRX-DEG2-TTP-TXRX-2',
+ 'opticalControlMode': 'gainLoss',
+ 'target-output-power': -3.0},
+ res['roadm-connections'][0])
self.assertDictEqual(
- {'src-if': 'SRG1-PP2-TXRX-nmc-2'},
- res['roadm-connections'][0]['source'])
+ {'src-if': 'SRG1-PP2-TXRX-nmc-2'},
+ res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG2-TTP-TXRX-nmc-2'},
- res['roadm-connections'][0]['destination'])
+ {'dst-if': 'DEG2-TTP-TXRX-nmc-2'},
+ res['roadm-connections'][0]['destination'])
time.sleep(2)
def test_43_check_topo_ROADMA(self):
def test_44_delete_oc_service1(self):
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
"service-name": "service1",
"tail-retention": "no"
}
- }
- }
+ }
+ }
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data), headers=headers,
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Renderer service delete in progress',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
time.sleep(20)
def test_45_delete_oc_service2(self):
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
"service-name": "service2",
"tail-retention": "no"
}
- }
- }
+ }
+ }
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data), headers=headers,
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Renderer service delete in progress',
- res['output']['configuration-response-common']['response-message'])
+ res['output']['configuration-response-common']['response-message'])
time.sleep(20)
def test_46_get_no_oc_services(self):
- print ("start test")
+ print("start test")
url = ("{}/operational/org-openroadm-service:service-list"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing",
- "error-message":"Request could not be completed because the relevant data model content does not exist"},
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
res['errors']['error'])
time.sleep(1)
def test_47_get_no_xc_ROADMA(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf"
"/node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "Accept": "application/json"}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
self.test_35_check_topo_ROADMA_DEG2()
def test_49_loop_create_eth_service(self):
- for i in range(1,6):
- print ("trial number {}".format(i))
+ for i in range(1, 6):
+ print("trial number {}".format(i))
print("eth service creation")
self.test_11_create_eth_service1()
- print ("check xc in ROADM-A1")
+ print("check xc in ROADM-A1")
self.test_13_check_xc1_ROADMA()
- print ("check xc in ROADM-C1")
+ print("check xc in ROADM-C1")
self.test_14_check_xc1_ROADMC()
- print ("eth service deletion\n")
+ print("eth service deletion\n")
self.test_30_delete_eth_service1()
def test_50_loop_create_oc_service(self):
"rpc-action": "service-delete",
"request-system-id": "appname",
"notification-url": "http://localhost:8585/NotificationServer/notify"
- },
+ },
"service-delete-req-info": {
"service-name": "service1",
"tail-retention": "no"
- }
}
}
+ }
headers = {'content-type': 'application/json'}
requests.request("POST", url, data=json.dumps(data), headers=headers, auth=('admin', 'admin'))
time.sleep(5)
- for i in range(1,6):
- print ("trial number {}".format(i))
+ for i in range(1, 6):
+ print("trial number {}".format(i))
print("oc service creation")
self.test_36_create_oc_service1()
- print ("check xc in ROADM-A1")
+ print("check xc in ROADM-A1")
self.test_38_check_xc1_ROADMA()
- print ("check xc in ROADM-C1")
+ print("check xc in ROADM-C1")
self.test_39_check_xc1_ROADMC()
- print ("oc service deletion\n")
+ print("oc service deletion\n")
self.test_44_delete_oc_service1()
def test_51_disconnect_XPDRA(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-A1"
+ "network-topology/topology/topology-netconf/node/XPDR-A1"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(10)
def test_52_disconnect_XPDRC(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-C1"
+ "network-topology/topology/topology-netconf/node/XPDR-C1"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(10)
def test_53_disconnect_ROADMA(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-A1"
+ "network-topology/topology/topology-netconf/node/ROADM-A1"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(10)
def test_54_disconnect_ROADMC(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-C1"
+ "network-topology/topology/topology-netconf/node/ROADM-C1"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(10)
odl_process = None
restconf_baseurl = "http://localhost:8181/restconf"
-#START_IGNORE_XTESTING
+# START_IGNORE_XTESTING
@classmethod
def setUpClass(cls):
- print ("starting honeynode1...")
+ print("starting honeynode1...")
cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
time.sleep(20)
- print ("starting honeynode2...")
+ print("starting honeynode2...")
cls.honeynode_process2 = test_utils.start_roadma_honeynode()
time.sleep(20)
- print ("starting honeynode3...")
+ print("starting honeynode3...")
cls.honeynode_process3 = test_utils.start_roadmc_honeynode()
time.sleep(20)
- print ("starting honeynode4...")
+ print("starting honeynode4...")
cls.honeynode_process4 = test_utils.start_xpdrc_honeynode()
time.sleep(20)
- print ("all honeynodes started")
+ print("all honeynodes started")
- print ("starting opendaylight...")
+ print("starting opendaylight...")
cls.odl_process = test_utils.start_tpce()
time.sleep(60)
- print ("opendaylight started")
+ print("opendaylight started")
@classmethod
def tearDownClass(cls):
cls.honeynode_process4.wait()
def setUp(self):
- print ("execution of {}".format(self.id().split(".")[-1]))
+ print("execution of {}".format(self.id().split(".")[-1]))
time.sleep(1)
-#END_IGNORE_XTESTING
+# END_IGNORE_XTESTING
def test_01_xpdrA_device_connected(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/XPDR-A1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"node": [{
"node-id": "XPDR-A1",
"netconf-node-topology:username": "admin",
def test_02_xpdrC_device_connected(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/XPDR-C1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"node": [{
"node-id": "XPDR-C1",
"netconf-node-topology:username": "admin",
"network-topology/topology/topology-netconf/node/ROADM-A1"
.format(self.restconf_baseurl))
data = {"node": [{
- "node-id": "ROADM-A1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": "17841",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "node-id": "ROADM-A1",
+ "netconf-node-topology:username": "admin",
+ "netconf-node-topology:password": "admin",
+ "netconf-node-topology:host": "127.0.0.1",
+ "netconf-node-topology:port": "17841",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
"network-topology/topology/topology-netconf/node/ROADM-C1"
.format(self.restconf_baseurl))
data = {"node": [{
- "node-id": "ROADM-C1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": "17843",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "node-id": "ROADM-C1",
+ "netconf-node-topology:username": "admin",
+ "netconf-node-topology:password": "admin",
+ "netconf-node-topology:host": "127.0.0.1",
+ "netconf-node-topology:port": "17843",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
def test_09_create_OTS_ROADMA(self):
url = "{}/operations/transportpce-device-renderer:create-ots-oms".format(self.restconf_baseurl)
data = {
- "input" : {
- "node-id" : "ROADM-A1",
- "logical-connection-point" : "DEG1-TTP-TXRX"
+ "input": {
+ "node-id": "ROADM-A1",
+ "logical-connection-point": "DEG1-TTP-TXRX"
}
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
time.sleep(10)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
def test_10_create_OTS_ROADMC(self):
url = "{}/operations/transportpce-device-renderer:create-ots-oms".format(self.restconf_baseurl)
data = {
- "input" : {
- "node-id" : "ROADM-C1",
- "logical-connection-point" : "DEG2-TTP-TXRX"
+ "input": {
+ "node-id": "ROADM-C1",
+ "logical-connection-point": "DEG2-TTP-TXRX"
}
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADM-C1',
"resource-type": "interface",
"granularity": "15min",
"resource-identifier": {
- "resource-name" : "OTS-DEG2-TTP-TXRX"
+ "resource-name": "OTS-DEG2-TTP-TXRX"
}
}
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn({
- "pmparameter-name": "OpticalPowerOutput",
- "pmparameter-value": "2.5"
- }, res["output"]["measurements"])
+ "pmparameter-name": "OpticalPowerOutput",
+ "pmparameter-value": "2.5"
+ }, res["output"]["measurements"])
self.assertIn({
- "pmparameter-name": "OpticalReturnLoss",
- "pmparameter-value": "40"
- }, res["output"]["measurements"])
+ "pmparameter-name": "OpticalReturnLoss",
+ "pmparameter-value": "40"
+ }, res["output"]["measurements"])
self.assertIn({
- "pmparameter-name": "OpticalPowerInput",
- "pmparameter-value": "-21.1"
- }, res["output"]["measurements"])
+ "pmparameter-name": "OpticalPowerInput",
+ "pmparameter-value": "-21.1"
+ }, res["output"]["measurements"])
def test_12_get_PM_ROADMC(self):
url = "{}/operations/transportpce-olm:get-pm".format(self.restconf_baseurl)
"resource-type": "interface",
"granularity": "15min",
"resource-identifier": {
- "resource-name" : "OTS-DEG1-TTP-TXRX"
+ "resource-name": "OTS-DEG1-TTP-TXRX"
}
}
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn({
- "pmparameter-name": "OpticalPowerOutput",
- "pmparameter-value": "4.6"
- }, res["output"]["measurements"])
+ "pmparameter-name": "OpticalPowerOutput",
+ "pmparameter-value": "4.6"
+ }, res["output"]["measurements"])
self.assertIn({
- "pmparameter-name": "OpticalReturnLoss",
- "pmparameter-value": "49.1"
- }, res["output"]["measurements"])
+ "pmparameter-name": "OpticalReturnLoss",
+ "pmparameter-value": "49.1"
+ }, res["output"]["measurements"])
self.assertIn({
- "pmparameter-name": "OpticalPowerInput",
- "pmparameter-value": "-15.1"
- }, res["output"]["measurements"])
+ "pmparameter-name": "OpticalPowerInput",
+ "pmparameter-value": "-15.1"
+ }, res["output"]["measurements"])
def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
url = "{}/operations/transportpce-olm:calculate-spanloss-base".format(self.restconf_baseurl)
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success',
res["output"]["result"])
self.assertIn({
"spanloss": "18",
- "link-id": "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX"
- }, res["output"]["spans"])
+ "link-id": "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX"
+ }, res["output"]["spans"])
time.sleep(5)
def test_14_calculate_span_loss_base_all(self):
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success',
res["output"]["result"])
self.assertIn({
- "spanloss": "26",
- "link-id": "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX"
- }, res["output"]["spans"])
+ "spanloss": "26",
+ "link-id": "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX"
+ }, res["output"]["spans"])
self.assertIn({
- "spanloss": "18",
- "link-id": "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX"
- }, res["output"]["spans"])
+ "spanloss": "18",
+ "link-id": "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX"
+ }, res["output"]["spans"])
time.sleep(5)
def test_15_get_OTS_DEG2_TTP_TXRX_ROADMA(self):
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
- #time.sleep(40)
+ # time.sleep(40)
time.sleep(10)
def test_18_servicePath_create_ZToA(self):
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
- #time.sleep(40)
+ # time.sleep(40)
time.sleep(10)
def test_19_service_power_setup_XPDRA_XPDRC(self):
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success', res["output"]["result"])
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- self.assertEqual(-5 , res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
+ self.assertEqual(-5, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
self.assertEqual(196.1, res['org-openroadm-optical-channel-interfaces:och']['frequency'])
def test_25_get_roadmconnection_ROADMC(self):
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
- #time.sleep(40)
+ # time.sleep(40)
time.sleep(10)
def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
def test_36_xpdrA_device_disconnected(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-A1"
+ "network-topology/topology/topology-netconf/node/XPDR-A1"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(10)
def test_37_xpdrC_device_disconnected(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-C1"
+ "network-topology/topology/topology-netconf/node/XPDR-C1"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(10)
url = "{}/operations/transportpce-olm:calculate-spanloss-current".format(self.restconf_baseurl)
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, headers=headers, auth=('admin', 'admin'))
+ "POST", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success',
def test_39_rdmA_device_disconnected(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-A1"
+ "network-topology/topology/topology-netconf/node/ROADM-A1"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(10)
def test_40_rdmC_device_disconnected(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-C1"
+ "network-topology/topology/topology-netconf/node/ROADM-C1"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(10)
+
if __name__ == "__main__":
unittest.main(verbosity=2)
@classmethod
def setUpClass(cls):
- print ("starting honeynode1...")
+ print("starting honeynode1...")
cls.honeynode_process1 = test_utils.start_spdra_honeynode()
time.sleep(30)
- print ("starting opendaylight...")
+ print("starting opendaylight...")
cls.odl_process = test_utils.start_tpce()
time.sleep(60)
- print ("opendaylight started")
+ print("opendaylight started")
@classmethod
def tearDownClass(cls):
def test_01_connect_SPDR_SA1(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/SPDR-SA1"
+ "network-topology/topology/topology-netconf/node/SPDR-SA1"
.format(self.restconf_baseurl))
data = {"node": [{
- "node-id": "SPDR-SA1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": "17845",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "node-id": "SPDR-SA1",
+ "netconf-node-topology:username": "admin",
+ "netconf-node-topology:password": "admin",
+ "netconf-node-topology:host": "127.0.0.1",
+ "netconf-node-topology:port": "17845",
+ "netconf-node-topology:tcp-only": "false",
+ "netconf-node-topology:pass-through": {}}]}
headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(10)
url = ("{}/operational/network-topology:"
res = response.json()
self.assertIn(
{"logical-connection-point": "XPDR1-NETWORK1",
- "supporting-port": "CP1-CFP0-P1",
- "supported-interface-capability": [
- "org-openroadm-port-types:if-OCH-OTU4-ODU4"
- ],
- "port-direction": "bidirectional",
- "port-qual": "xpdr-network",
- "supporting-circuit-pack-name": "CP1-CFP0",
- "xponder-type": "mpdr"},
+ "supporting-port": "CP1-CFP0-P1",
+ "supported-interface-capability": [
+ "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ ],
+ "port-direction": "bidirectional",
+ "port-qual": "xpdr-network",
+ "supporting-circuit-pack-name": "CP1-CFP0",
+ "xponder-type": "mpdr"},
res['mapping'])
def test_04_service_path_create_ODU4(self):
url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
data = {"renderer:input": {
- "service-name": "service_ODU4",
- "wave-number": "1",
- "modulation-format": "qpsk",
- "operation": "create",
- "nodes": [
- {"node-id": "SPDR-SA1",
- "dest-tp": "XPDR1-NETWORK1"}]}}
+ "service-name": "service_ODU4",
+ "wave-number": "1",
+ "modulation-format": "qpsk",
+ "operation": "create",
+ "nodes": [
+ {"node-id": "SPDR-SA1",
+ "dest-tp": "XPDR1-NETWORK1"}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
time.sleep(3)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
res = response.json()
self.assertIn(
{"logical-connection-point": "XPDR1-NETWORK1",
- "supporting-port": "CP1-CFP0-P1",
- "supported-interface-capability": [
- "org-openroadm-port-types:if-OCH-OTU4-ODU4"
- ],
- "port-direction": "bidirectional",
- "port-qual": "xpdr-network",
- "supporting-circuit-pack-name": "CP1-CFP0",
- "xponder-type": "mpdr",
- "supporting-odu4": "XPDR1-NETWORK1-ODU4"},
+ "supporting-port": "CP1-CFP0-P1",
+ "supported-interface-capability": [
+ "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ ],
+ "port-direction": "bidirectional",
+ "port-qual": "xpdr-network",
+ "supporting-circuit-pack-name": "CP1-CFP0",
+ "xponder-type": "mpdr",
+ "supporting-odu4": "XPDR1-NETWORK1-ODU4"},
res['mapping'])
def test_06_check_interface_och(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-NETWORK1-1"
- .format(self.restconf_baseurl))
+ "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-NETWORK1-1"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset({'name': 'XPDR1-NETWORK1-1', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': 'CP1-CFP0',
- 'type': 'org-openroadm-interfaces:opticalChannel',
- 'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
+ 'supporting-circuit-pack-name': 'CP1-CFP0',
+ 'type': 'org-openroadm-interfaces:opticalChannel',
+ 'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
self.assertDictEqual(
- {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
- u'transmit-power': -5},
- res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
+ {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
+ u'transmit-power': -5},
+ res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
def test_07_check_interface_OTU(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-NETWORK1-OTU"
- .format(self.restconf_baseurl))
+ "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-NETWORK1-OTU"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset({'name': 'XPDR1-NETWORK1-OTU', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': 'CP1-CFP0', 'supporting-interface': 'XPDR1-NETWORK1-1',
- 'type': 'org-openroadm-interfaces:otnOtu',
- 'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
+ 'supporting-circuit-pack-name': 'CP1-CFP0', 'supporting-interface': 'XPDR1-NETWORK1-1',
+ 'type': 'org-openroadm-interfaces:otnOtu',
+ 'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
self.assertDictEqual(
- {u'rate': u'org-openroadm-otn-common-types:OTU4',
- u'fec': u'scfec'},
- res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
+ {u'rate': u'org-openroadm-otn-common-types:OTU4',
+ u'fec': u'scfec'},
+ res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
def test_08_check_interface_ODU4(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-NETWORK1-ODU4"
- .format(self.restconf_baseurl))
+ "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-NETWORK1-ODU4"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset({'name': 'XPDR1-NETWORK1-ODU4', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': 'CP1-CFP0', 'supporting-interface': 'XPDR1-NETWORK1-OTU',
- 'type': 'org-openroadm-interfaces:otnOdu',
- 'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
+ 'supporting-circuit-pack-name': 'CP1-CFP0', 'supporting-interface': 'XPDR1-NETWORK1-OTU',
+ 'type': 'org-openroadm-interfaces:otnOdu',
+ 'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
self.assertDictContainsSubset(
- {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
- 'rate': 'org-openroadm-otn-common-types:ODU4'},
- res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
+ {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
+ 'rate': 'org-openroadm-otn-common-types:ODU4'},
+ res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
self.assertDictEqual(
- {u'payload-type': u'21', u'exp-payload-type': u'21'},
- res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
+ {u'payload-type': u'21', u'exp-payload-type': u'21'},
+ res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_09_otn_service_path_create_10GE(self):
url = "{}/operations/transportpce-device-renderer:otn-service-path".format(self.restconf_baseurl)
data = {"renderer:input": {
- "service-name": "service1",
- "operation": "create",
- "service-rate": "10G",
- "service-type": "Ethernet",
- "ethernet-encoding": "eth encode",
- "trib-slot" : ["1"],
- "trib-port-number": "1",
- "opucn-trib-slots": ["1"],
- "nodes": [
- {"node-id": "SPDR-SA1",
- "client-tp": "XPDR1-CLIENT1",
- "network-tp": "XPDR1-NETWORK1"}]}}
+ "service-name": "service1",
+ "operation": "create",
+ "service-rate": "10G",
+ "service-type": "Ethernet",
+ "ethernet-encoding": "eth encode",
+ "trib-slot": ["1"],
+ "trib-port-number": "1",
+ "opucn-trib-slots": ["1"],
+ "nodes": [
+ {"node-id": "SPDR-SA1",
+ "client-tp": "XPDR1-CLIENT1",
+ "network-tp": "XPDR1-NETWORK1"}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Otn Service path was set up successfully for node :service1-SPDR-SA1', res["output"]["result"])
def test_10_check_interface_10GE_CLIENT(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-CLIENT1-ETHERNET10G"
- .format(self.restconf_baseurl))
+ "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-CLIENT1-ETHERNET10G"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset({'name': 'XPDR1-CLIENT1-ETHERNET10G', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': 'CP1-SFP4',
- 'type': 'org-openroadm-interfaces:ethernetCsmacd',
- 'supporting-port': 'CP1-SFP4-P1'}, res['interface'][0])
+ 'supporting-circuit-pack-name': 'CP1-SFP4',
+ 'type': 'org-openroadm-interfaces:ethernetCsmacd',
+ 'supporting-port': 'CP1-SFP4-P1'}, res['interface'][0])
self.assertDictEqual(
- {u'speed': 10000},
- res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
+ {u'speed': 10000},
+ res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
def test_11_check_interface_ODU2E_CLIENT(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-CLIENT1-ODU2e-service1"
- .format(self.restconf_baseurl))
+ "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-CLIENT1-ODU2e-service1"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset({'name': 'XPDR1-CLIENT1-ODU2e-service1', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': 'CP1-SFP4',
- 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
- 'type': 'org-openroadm-interfaces:otnOdu',
- 'supporting-port': 'CP1-SFP4-P1'}, res['interface'][0])
+ 'supporting-circuit-pack-name': 'CP1-SFP4',
+ 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
+ 'type': 'org-openroadm-interfaces:otnOdu',
+ 'supporting-port': 'CP1-SFP4-P1'}, res['interface'][0])
self.assertDictContainsSubset({
'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
'rate': 'org-openroadm-otn-common-types:ODU2e',
'monitoring-mode': 'terminated'}, res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
self.assertDictEqual(
- {u'payload-type': u'03', u'exp-payload-type': u'03'},
- res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
+ {u'payload-type': u'03', u'exp-payload-type': u'03'},
+ res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_12_check_interface_ODU2E_NETWORK(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-NETWORK1-ODU2e-service1"
- .format(self.restconf_baseurl))
+ "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-NETWORK1-ODU2e-service1"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset({'name': 'XPDR1-NETWORK1-ODU2e-service1', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': 'CP1-CFP0',
- 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
- 'type': 'org-openroadm-interfaces:otnOdu',
- 'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
+ 'supporting-circuit-pack-name': 'CP1-CFP0',
+ 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
+ 'type': 'org-openroadm-interfaces:otnOdu',
+ 'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
self.assertDictContainsSubset({
'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
'rate': 'org-openroadm-otn-common-types:ODU2e',
'monitoring-mode': 'monitored'}, res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
self.assertDictContainsSubset(
- {'trib-port-number': 1},
- res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'])
+ {'trib-port-number': 1},
+ res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'])
self.assertIn(1,
- res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']['trib-slots'])
+ res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']['trib-slots'])
def test_13_check_ODU2E_connection(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "odu-connection/XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1"
- .format(self.restconf_baseurl))
+ "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "odu-connection/XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset({
'direction': 'bidirectional'},
res['odu-connection'][0])
self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-service1'},
- res['odu-connection'][0]['destination'])
+ res['odu-connection'][0]['destination'])
self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-service1'},
- res['odu-connection'][0]['source'])
+ res['odu-connection'][0]['source'])
def test_14_otn_service_path_delete_10GE(self):
url = "{}/operations/transportpce-device-renderer:otn-service-path".format(self.restconf_baseurl)
data = {"renderer:input": {
- "service-name": "service1",
- "operation": "delete",
- "service-rate": "10G",
- "service-type": "Ethernet",
- "ethernet-encoding": "eth encode",
- "trib-slot" : ["1"],
- "trib-port-number": "1",
- "opucn-trib-slots": ["1"],
- "nodes": [
- {"node-id": "SPDR-SA1",
- "client-tp": "XPDR1-CLIENT1",
- "network-tp": "XPDR1-NETWORK1"}]}}
+ "service-name": "service1",
+ "operation": "delete",
+ "service-rate": "10G",
+ "service-type": "Ethernet",
+ "ethernet-encoding": "eth encode",
+ "trib-slot": ["1"],
+ "trib-port-number": "1",
+ "opucn-trib-slots": ["1"],
+ "nodes": [
+ {"node-id": "SPDR-SA1",
+ "client-tp": "XPDR1-CLIENT1",
+ "network-tp": "XPDR1-NETWORK1"}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
def test_15_check_no_ODU2E_connection(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "odu-connection/XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1"
- .format(self.restconf_baseurl))
+ "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "odu-connection/XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
def test_16_check_no_interface_ODU2E_NETWORK(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-NETWORK1-ODU2e-service1"
- .format(self.restconf_baseurl))
+ "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-NETWORK1-ODU2e-service1"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
def test_17_check_no_interface_ODU2E_CLIENT(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-CLIENT1-ODU2e-service1"
- .format(self.restconf_baseurl))
+ "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-CLIENT1-ODU2e-service1"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
def test_18_check_no_interface_10GE_CLIENT(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-CLIENT1-ETHERNET10G"
- .format(self.restconf_baseurl))
+ "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-CLIENT1-ETHERNET10G"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
def test_19_service_path_delete_ODU4(self):
url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
data = {"renderer:input": {
- "service-name": "service_ODU4",
- "wave-number": "1",
- "modulation-format": "qpsk",
- "operation": "delete",
- "nodes": [
- {"node-id": "SPDR-SA1",
- "dest-tp": "XPDR1-NETWORK1"}]}}
+ "service-name": "service_ODU4",
+ "wave-number": "1",
+ "modulation-format": "qpsk",
+ "operation": "delete",
+ "nodes": [
+ {"node-id": "SPDR-SA1",
+ "dest-tp": "XPDR1-NETWORK1"}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
time.sleep(3)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
def test_20_check_no_interface_ODU4(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-NETWORK1-ODU4"
- .format(self.restconf_baseurl))
+ "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-NETWORK1-ODU4"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
def test_21_check_no_interface_OTU(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-NETWORK1-OTU"
- .format(self.restconf_baseurl))
+ "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-NETWORK1-OTU"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
def test_22_check_no_interface_och(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-NETWORK1-1"
- .format(self.restconf_baseurl))
+ "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-NETWORK1-1"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
def test_23_disconnect_SPDR_SA1(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/SPDR-SA1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
@classmethod
def setUpClass(cls):
- print ("starting honeynode1...")
+ print("starting honeynode1...")
cls.honeynode_process1 = test_utils.start_spdra_honeynode()
time.sleep(20)
- print ("starting opendaylight...")
+ print("starting opendaylight...")
cls.odl_process = test_utils.start_tpce()
time.sleep(60)
- print ("opendaylight started")
+ print("opendaylight started")
@classmethod
def tearDownClass(cls):
def test_01_connect_SPDR_SA1(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/SPDR-SA1"
+ "network-topology/topology/topology-netconf/node/SPDR-SA1"
.format(self.restconf_baseurl))
data = {"node": [{
- "node-id": "SPDR-SA1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": "17845",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "node-id": "SPDR-SA1",
+ "netconf-node-topology:username": "admin",
+ "netconf-node-topology:password": "admin",
+ "netconf-node-topology:host": "127.0.0.1",
+ "netconf-node-topology:port": "17845",
+ "netconf-node-topology:tcp-only": "false",
+ "netconf-node-topology:pass-through": {}}]}
headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(10)
url = ("{}/operational/network-topology:"
def test_02_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
def test_03_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
def test_04_getLinks_OpenroadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
def test_05_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
def test_06_getLinks_OtnTopology(self):
url = ("{}/config/ietf-network:networks/network/otn-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
def test_07_getNodes_OtnTopology(self):
url = ("{}/config/ietf-network:networks/network/otn-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
res['network'][0]['node'][i]['supporting-node'])
self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeSA'},
res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-otn-network-topology:xpdr-attributes']['xpdr-number'], 1)
+ self.assertEqual(res['network'][0]['node'][i]
+ ['org-openroadm-otn-network-topology:xpdr-attributes']['xpdr-number'], 1)
nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
client = 0
network = 0
tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
if (tpType == 'XPONDER-CLIENT'):
client += 1
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-otn-network-topology:tp-supported-interfaces']['supported-interface-capability'][0]['if-cap-type'], 'org-openroadm-port-types:if-10GE-ODU2e')
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']['rate'], 'org-openroadm-otn-common-types:ODU2e')
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-otn-network-topology:tp-supported-interfaces']
+ ['supported-interface-capability'][0]['if-cap-type'], 'org-openroadm-port-types:if-10GE-ODU2e')
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
+ ['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']['rate'], 'org-openroadm-otn-common-types:ODU2e')
elif (tpType == 'XPONDER-NETWORK'):
network += 1
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-otn-network-topology:tp-supported-interfaces']['supported-interface-capability'][0]['if-cap-type'], 'org-openroadm-port-types:if-OCH-OTU4-ODU4')
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']['rate'], 'org-openroadm-otn-common-types:ODU4')
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['supporting-termination-point'][0]['network-ref'], 'openroadm-topology')
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['supporting-termination-point'][0]['node-ref'], 'SPDR-SA1-XPDR1')
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['supporting-termination-point'][0]['tp-ref'], 'XPDR1-NETWORK1')
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-otn-network-topology:tp-supported-interfaces']
+ ['supported-interface-capability'][0]['if-cap-type'], 'org-openroadm-port-types:if-OCH-OTU4-ODU4')
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
+ ['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']['rate'], 'org-openroadm-otn-common-types:ODU4')
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point']
+ [j]['supporting-termination-point'][0]['network-ref'], 'openroadm-topology')
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point']
+ [j]['supporting-termination-point'][0]['node-ref'], 'SPDR-SA1-XPDR1')
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point']
+ [j]['supporting-termination-point'][0]['tp-ref'], 'XPDR1-NETWORK1')
self.assertTrue(client == 4)
self.assertTrue(network == 1)
listNode.remove(nodeId)
- nbNbl = len(res['network'][0]['node'][i]['org-openroadm-otn-network-topology:switching-pools']['odu-switching-pools'][0]['non-blocking-list'])
+ nbNbl = len(res['network'][0]['node'][i]['org-openroadm-otn-network-topology:switching-pools']
+ ['odu-switching-pools'][0]['non-blocking-list'])
self.assertEqual(nbNbl, 4)
for k in range(0, nbNbl):
nbl = res['network'][0]['node'][i]['org-openroadm-otn-network-topology:switching-pools']['odu-switching-pools'][0]['non-blocking-list'][k]
res['network'][0]['node'][i]['supporting-node'])
self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeSA'},
res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-otn-network-topology:xpdr-attributes']['xpdr-number'], 2)
+ self.assertEqual(res['network'][0]['node'][i]
+ ['org-openroadm-otn-network-topology:xpdr-attributes']['xpdr-number'], 2)
nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
client = 0
network = 0
tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
if (tpType == 'XPONDER-CLIENT'):
client += 1
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-otn-network-topology:tp-supported-interfaces']['supported-interface-capability'][0]['if-cap-type'], 'org-openroadm-port-types:if-100GE-ODU4')
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']['rate'], 'org-openroadm-otn-common-types:ODU4')
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-otn-network-topology:tp-supported-interfaces']
+ ['supported-interface-capability'][0]['if-cap-type'], 'org-openroadm-port-types:if-100GE-ODU4')
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
+ ['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']['rate'], 'org-openroadm-otn-common-types:ODU4')
elif (tpType == 'XPONDER-NETWORK'):
network += 1
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-otn-network-topology:tp-supported-interfaces']['supported-interface-capability'][0]['if-cap-type'], 'org-openroadm-port-types:if-OCH-OTU4-ODU4')
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']['rate'], 'org-openroadm-otn-common-types:ODU4')
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['supporting-termination-point'][0]['network-ref'], 'openroadm-topology')
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['supporting-termination-point'][0]['node-ref'], 'SPDR-SA1-XPDR2')
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['supporting-termination-point'][0]['tp-ref'], tpId)
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-otn-network-topology:tp-supported-interfaces']
+ ['supported-interface-capability'][0]['if-cap-type'], 'org-openroadm-port-types:if-OCH-OTU4-ODU4')
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
+ ['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']['rate'], 'org-openroadm-otn-common-types:ODU4')
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point']
+ [j]['supporting-termination-point'][0]['network-ref'], 'openroadm-topology')
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point']
+ [j]['supporting-termination-point'][0]['node-ref'], 'SPDR-SA1-XPDR2')
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point']
+ [j]['supporting-termination-point'][0]['tp-ref'], tpId)
self.assertTrue(client == 4)
self.assertTrue(network == 4)
listNode.remove(nodeId)
- nbNbl = len(res['network'][0]['node'][i]['org-openroadm-otn-network-topology:switching-pools']['odu-switching-pools'][0]['non-blocking-list'])
+ nbNbl = len(res['network'][0]['node'][i]['org-openroadm-otn-network-topology:switching-pools']
+ ['odu-switching-pools'][0]['non-blocking-list'])
self.assertEqual(nbNbl, 1)
nbl = res['network'][0]['node'][i]['org-openroadm-otn-network-topology:switching-pools']['odu-switching-pools'][0]['non-blocking-list'][0]
self.assertIn('XPDR2-NETWORK1', nbl['tp-list'])
def test_08_disconnect_SPDR_SA1(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/SPDR-SA1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
def test_09_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
def test_10_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
def test_11_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
def test_12_getNodes_OtnTopology(self):
url = ("{}/config/ietf-network:networks/network/otn-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
@classmethod
def setUpClass(cls):
- print ("starting honeynode1...")
+ print("starting honeynode1...")
cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
time.sleep(20)
- print ("starting honeynode2...")
+ print("starting honeynode2...")
cls.honeynode_process2 = test_utils.start_roadma_honeynode()
time.sleep(20)
- print ("all honeynodes started")
+ print("all honeynodes started")
- print ("starting opendaylight...")
+ print("starting opendaylight...")
cls.odl_process = test_utils.start_tpce()
time.sleep(60)
- print ("opendaylight started")
+ print("opendaylight started")
@classmethod
def tearDownClass(cls):
cls.honeynode_process2.wait()
def setUp(self):
- print ("execution of {}".format(self.id().split(".")[-1]))
+ print("execution of {}".format(self.id().split(".")[-1]))
time.sleep(10)
def test_01_rdm_device_connected(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/ROADM-A1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"node": [{
"node-id": "ROADM-A1",
"netconf-node-topology:username": "admin",
res = response.json()
self.assertEqual(
{u'node-info': {u'node-type': u'rdm',
- u'node-ip-address': u'127.0.0.11',
- u'node-clli': u'NodeA',
- u'openroadm-version': u'2.2.1', u'node-vendor': u'vendorA',
- u'node-model': u'model2'}},
+ u'node-ip-address': u'127.0.0.11',
+ u'node-clli': u'NodeA',
+ u'openroadm-version': u'2.2.1', u'node-vendor': u'vendorA',
+ u'node-model': u'model2'}},
res)
time.sleep(3)
def test_08_xpdr_device_connected(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/XPDR-A1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"node": [{
"node-id": "XPDR-A1",
"netconf-node-topology:username": "admin",
res = response.json()
self.assertEqual(
{u'node-info': {u'node-type': u'xpdr',
- u'node-ip-address': u'1.2.3.4',
- u'node-clli': u'NodeA',
- u'openroadm-version': u'2.2.1', u'node-vendor': u'vendorA',
- u'node-model': u'model2'}},
+ u'node-ip-address': u'1.2.3.4',
+ u'node-clli': u'NodeA',
+ u'openroadm-version': u'2.2.1', u'node-vendor': u'vendorA',
+ u'node-model': u'model2'}},
res)
time.sleep(3)
def test_15_xpdr_device_disconnected(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-A1"
+ "network-topology/topology/topology-netconf/node/XPDR-A1"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(20)
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing",
- "error-message":"Request could not be completed because the relevant data model content does not exist"},
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
res['errors']['error'])
def test_17_xpdr_device_disconnected(self):
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing",
- "error-message":"Request could not be completed because the relevant data model content does not exist"},
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
res['errors']['error'])
def test_18_rdm_device_disconnected(self):
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(20)
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing",
- "error-message":"Request could not be completed because the relevant data model content does not exist"},
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
res['errors']['error'])
def test_20_rdm_device_disconnected(self):
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing",
- "error-message":"Request could not be completed because the relevant data model content does not exist"},
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
res['errors']['error'])
odl_process = None
restconf_baseurl = "http://localhost:8181/restconf"
-#START_IGNORE_XTESTING
+# START_IGNORE_XTESTING
@classmethod
def setUpClass(cls):
- print ("starting honeynode1...")
+ print("starting honeynode1...")
cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
time.sleep(20)
- print ("starting honeynode2...")
+ print("starting honeynode2...")
cls.honeynode_process2 = test_utils.start_roadma_honeynode()
time.sleep(20)
- print ("all honeynodes started")
+ print("all honeynodes started")
- print ("starting opendaylight...")
+ print("starting opendaylight...")
cls.odl_process = test_utils.start_tpce()
time.sleep(60)
- print ("opendaylight started")
+ print("opendaylight started")
@classmethod
def tearDownClass(cls):
cls.honeynode_process2.wait()
def setUp(self):
- print ("execution of {}".format(self.id().split(".")[-1]))
+ print("execution of {}".format(self.id().split(".")[-1]))
time.sleep(10)
-#END_IGNORE_XTESTING
+# END_IGNORE_XTESTING
def test_01_rdm_device_connected(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/ROADM-A1"
.format(self.restconf_baseurl))
data = {"node": [{
- "node-id": "ROADM-A1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": "17841",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "node-id": "ROADM-A1",
+ "netconf-node-topology:username": "admin",
+ "netconf-node-topology:password": "admin",
+ "netconf-node-topology:host": "127.0.0.1",
+ "netconf-node-topology:port": "17841",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
def test_02_xpdr_device_connected(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/XPDR-A1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"node": [{
"node-id": "XPDR-A1",
"netconf-node-topology:username": "admin",
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
- {'supporting-port': 'L1', 'supporting-circuit-pack-name': '1/0',
- 'logical-connection-point': 'DEG1-TTP-TXRX', 'port-direction': 'bidirectional'},
- res['nodes'][0]['mapping'])
+ {'supporting-port': 'L1', 'supporting-circuit-pack-name': '1/0',
+ 'logical-connection-point': 'DEG1-TTP-TXRX', 'port-direction': 'bidirectional'},
+ res['nodes'][0]['mapping'])
self.assertIn(
- {'supporting-port': 'C3', 'supporting-circuit-pack-name': '3/0',
- 'logical-connection-point': 'SRG1-PP3-TXRX', 'port-direction': 'bidirectional'},
- res['nodes'][0]['mapping'])
+ {'supporting-port': 'C3', 'supporting-circuit-pack-name': '3/0',
+ 'logical-connection-point': 'SRG1-PP3-TXRX', 'port-direction': 'bidirectional'},
+ res['nodes'][0]['mapping'])
def test_04_xpdr_portmapping(self):
url = ("{}/config/transportpce-portmapping:network/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
- {'supported-interface-capability': ['org-openroadm-port-types:if-OCH'],
- 'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
- 'logical-connection-point': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-network',
- 'port-direction': 'bidirectional', 'connection-map-lcp': 'XPDR1-CLIENT1'},
- res['nodes'][0]['mapping'])
+ {'supported-interface-capability': ['org-openroadm-port-types:if-OCH'],
+ 'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
+ 'logical-connection-point': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-network',
+ 'port-direction': 'bidirectional', 'connection-map-lcp': 'XPDR1-CLIENT1'},
+ res['nodes'][0]['mapping'])
self.assertIn(
- {'supported-interface-capability': ['org-openroadm-port-types:if-100GE'],
- 'supporting-port': 'C1',
- 'supporting-circuit-pack-name': '1/0/1-PLUG-CLIENT',
- 'logical-connection-point': 'XPDR1-CLIENT1', 'port-direction': 'bidirectional',
- 'connection-map-lcp': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-client'},
- res['nodes'][0]['mapping'])
+ {'supported-interface-capability': ['org-openroadm-port-types:if-100GE'],
+ 'supporting-port': 'C1',
+ 'supporting-circuit-pack-name': '1/0/1-PLUG-CLIENT',
+ 'logical-connection-point': 'XPDR1-CLIENT1', 'port-direction': 'bidirectional',
+ 'connection-map-lcp': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-client'},
+ res['nodes'][0]['mapping'])
def test_05_service_path_create(self):
url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
data = {"renderer:input": {
- "renderer:service-name": "service_test",
- "renderer:wave-number": "7",
- "renderer:modulation-format": "qpsk",
- "renderer:operation": "create",
- "renderer:nodes": [
- {"renderer:node-id": "ROADM-A1",
- "renderer:src-tp": "SRG1-PP3-TXRX",
- "renderer:dest-tp": "DEG1-TTP-TXRX"},
- {"renderer:node-id": "XPDR-A1",
- "renderer:src-tp": "XPDR1-CLIENT1",
- "renderer:dest-tp": "XPDR1-NETWORK1"}]}}
+ "renderer:service-name": "service_test",
+ "renderer:wave-number": "7",
+ "renderer:modulation-format": "qpsk",
+ "renderer:operation": "create",
+ "renderer:nodes": [
+ {"renderer:node-id": "ROADM-A1",
+ "renderer:src-tp": "SRG1-PP3-TXRX",
+ "renderer:dest-tp": "DEG1-TTP-TXRX"},
+ {"renderer:node-id": "XPDR-A1",
+ "renderer:src-tp": "XPDR1-CLIENT1",
+ "renderer:dest-tp": "XPDR1-NETWORK1"}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes: ROADM-A1', res["output"]["result"])
def test_06_service_path_create_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/DEG1-TTP-TXRX-nmc-7"
- .format(self.restconf_baseurl))
+ "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/DEG1-TTP-TXRX-nmc-7"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset({'name': 'DEG1-TTP-TXRX-nmc-7', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': '1/0',
- 'type': 'org-openroadm-interfaces:networkMediaChannelConnectionTerminationPoint',
- 'supporting-port': 'L1'}, res['interface'][0])
+ 'supporting-circuit-pack-name': '1/0',
+ 'type': 'org-openroadm-interfaces:networkMediaChannelConnectionTerminationPoint',
+ 'supporting-port': 'L1'}, res['interface'][0])
self.assertDictEqual(
- {u'frequency': 195.8, u'width': 40},
- res['interface'][0]['org-openroadm-network-media-channel-interfaces:nmc-ctp'])
+ {u'frequency': 195.8, u'width': 40},
+ res['interface'][0]['org-openroadm-network-media-channel-interfaces:nmc-ctp'])
def test_07_service_path_create_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/DEG1-TTP-TXRX-mc-7"
- .format(self.restconf_baseurl))
+ "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/DEG1-TTP-TXRX-mc-7"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset({'name': 'DEG1-TTP-TXRX-mc-7', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': '1/0',
- 'type': 'org-openroadm-interfaces:mediaChannelTrailTerminationPoint',
- 'supporting-port': 'L1'}, res['interface'][0])
+ 'supporting-circuit-pack-name': '1/0',
+ 'type': 'org-openroadm-interfaces:mediaChannelTrailTerminationPoint',
+ 'supporting-port': 'L1'}, res['interface'][0])
self.assertDictEqual(
- {u'min-freq': 195.775, u'max-freq': 195.825},
- res['interface'][0]['org-openroadm-media-channel-interfaces:mc-ttp'])
-
+ {u'min-freq': 195.775, u'max-freq': 195.825},
+ res['interface'][0]['org-openroadm-media-channel-interfaces:mc-ttp'])
def test_08_service_path_create_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/SRG1-PP3-TXRX-nmc-7"
- .format(self.restconf_baseurl))
+ "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/SRG1-PP3-TXRX-nmc-7"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset({'name': 'SRG1-PP3-TXRX-nmc-7', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': '3/0',
- 'type': 'org-openroadm-interfaces:networkMediaChannelConnectionTerminationPoint',
- 'supporting-port': 'C3'}, res['interface'][0])
+ 'supporting-circuit-pack-name': '3/0',
+ 'type': 'org-openroadm-interfaces:networkMediaChannelConnectionTerminationPoint',
+ 'supporting-port': 'C3'}, res['interface'][0])
self.assertDictEqual(
- {u'frequency': 195.8, u'width': 40},
- res['interface'][0]['org-openroadm-network-media-channel-interfaces:nmc-ctp'])
+ {u'frequency': 195.8, u'width': 40},
+ res['interface'][0]['org-openroadm-network-media-channel-interfaces:nmc-ctp'])
# -mc supporting interfaces must not be created for SRG, only degrees
def test_09_service_path_create_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/SRG1-PP3-TXRX-mc-7"
- .format(self.restconf_baseurl))
+ "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/SRG1-PP3-TXRX-mc-7"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing",
- "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_10_service_path_create_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'connection-name': 'SRG1-PP3-TXRX-DEG1-TTP-TXRX-7',
- 'opticalControlMode': 'off'},
- res['roadm-connections'][0])
+ {'connection-name': 'SRG1-PP3-TXRX-DEG1-TTP-TXRX-7',
+ 'opticalControlMode': 'off'},
+ res['roadm-connections'][0])
self.assertDictEqual(
- {'src-if': 'SRG1-PP3-TXRX-nmc-7'},
- res['roadm-connections'][0]['source'])
+ {'src-if': 'SRG1-PP3-TXRX-nmc-7'},
+ res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG1-TTP-TXRX-nmc-7'},
- res['roadm-connections'][0]['destination'])
+ {'dst-if': 'DEG1-TTP-TXRX-nmc-7'},
+ res['roadm-connections'][0]['destination'])
def test_11_service_path_create_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-NETWORK1-7"
- .format(self.restconf_baseurl))
+ "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-NETWORK1-7"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'name': 'XPDR1-NETWORK1-7', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
- 'type': 'org-openroadm-interfaces:opticalChannel',
- 'supporting-port': '1'},
- res['interface'][0])
+ {'name': 'XPDR1-NETWORK1-7', 'administrative-state': 'inService',
+ 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
+ 'type': 'org-openroadm-interfaces:opticalChannel',
+ 'supporting-port': '1'},
+ res['interface'][0])
self.assertDictEqual(
- {u'rate': u'org-openroadm-common-types:R100G',
- u'transmit-power':-5,
- u'frequency': 195.8},
- res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
+ {u'rate': u'org-openroadm-common-types:R100G',
+ u'transmit-power': -5,
+ u'frequency': 195.8},
+ res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
def test_12_service_path_create_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-NETWORK1-OTU"
- .format(self.restconf_baseurl))
+ "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-NETWORK1-OTU"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'name': 'XPDR1-NETWORK1-OTU', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
- 'type': 'org-openroadm-interfaces:otnOtu',
- 'supporting-port': '1',
- 'supporting-interface': 'XPDR1-NETWORK1-7'},
- res['interface'][0])
+ {'name': 'XPDR1-NETWORK1-OTU', 'administrative-state': 'inService',
+ 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
+ 'type': 'org-openroadm-interfaces:otnOtu',
+ 'supporting-port': '1',
+ 'supporting-interface': 'XPDR1-NETWORK1-7'},
+ res['interface'][0])
self.assertDictEqual(
- {u'rate': u'org-openroadm-otn-common-types:OTU4',
- u'fec': u'scfec'},
- res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
+ {u'rate': u'org-openroadm-otn-common-types:OTU4',
+ u'fec': u'scfec'},
+ res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
def test_13_service_path_create_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/XPDR1-NETWORK1-ODU"
- .format(self.restconf_baseurl))
+ "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/XPDR1-NETWORK1-ODU"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'name': 'XPDR1-NETWORK1-ODU', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
- 'type': 'org-openroadm-interfaces:otnOdu',
- 'supporting-port': '1',
- 'supporting-interface': 'XPDR1-NETWORK1-OTU'},
- res['interface'][0])
+ {'name': 'XPDR1-NETWORK1-ODU', 'administrative-state': 'inService',
+ 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
+ 'type': 'org-openroadm-interfaces:otnOdu',
+ 'supporting-port': '1',
+ 'supporting-interface': 'XPDR1-NETWORK1-OTU'},
+ res['interface'][0])
self.assertDictContainsSubset(
- {'rate': 'org-openroadm-otn-common-types:ODU4',
- u'monitoring-mode': u'terminated'},
- res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
- self.assertDictEqual({u'exp-payload-type': u'07', u'payload-type': u'07'},
+ {'rate': 'org-openroadm-otn-common-types:ODU4',
+ u'monitoring-mode': u'terminated'},
+ res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
+ self.assertDictEqual({u'exp-payload-type': u'07', u'payload-type': u'07'},
res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_14_service_path_create_xpdr_check(self):
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictContainsSubset(
- {'name': 'XPDR1-CLIENT1-ETHERNET', 'administrative-state': 'inService',
- 'supporting-circuit-pack-name': '1/0/1-PLUG-CLIENT',
- 'type': 'org-openroadm-interfaces:ethernetCsmacd',
- 'supporting-port': 'C1'},
- res['interface'][0])
+ {'name': 'XPDR1-CLIENT1-ETHERNET', 'administrative-state': 'inService',
+ 'supporting-circuit-pack-name': '1/0/1-PLUG-CLIENT',
+ 'type': 'org-openroadm-interfaces:ethernetCsmacd',
+ 'supporting-port': 'C1'},
+ res['interface'][0])
self.assertDictEqual(
- {u'fec': u'off', u'speed': 100000},
- res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
+ {u'fec': u'off', u'speed': 100000},
+ res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
def test_15_service_path_create_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "circuit-packs/1%2F0%2F1-PLUG-NET"
- .format(self.restconf_baseurl))
+ "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "circuit-packs/1%2F0%2F1-PLUG-NET"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('not-reserved-inuse', res['circuit-packs'][0]["equipment-state"])
def test_16_service_path_create_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "circuit-packs/1%2F0%2F1-PLUG-CLIENT"
- .format(self.restconf_baseurl))
+ "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "circuit-packs/1%2F0%2F1-PLUG-CLIENT"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('not-reserved-inuse', res['circuit-packs'][0]["equipment-state"])
def test_17_service_path_delete(self):
url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
data = {"renderer:input": {
- "renderer:service-name": "service_test",
- "renderer:wave-number": "7",
- "renderer:operation": "delete",
- "renderer:nodes": [
- {"renderer:node-id": "ROADM-A1",
- "renderer:src-tp": "SRG1-PP3-TXRX",
- "renderer:dest-tp": "DEG1-TTP-TXRX"},
- {"renderer:node-id": "XPDR-A1",
- "renderer:src-tp": "XPDR1-CLIENT1",
- "renderer:dest-tp": "XPDR1-NETWORK1"}]}}
+ "renderer:service-name": "service_test",
+ "renderer:wave-number": "7",
+ "renderer:operation": "delete",
+ "renderer:nodes": [
+ {"renderer:node-id": "ROADM-A1",
+ "renderer:src-tp": "SRG1-PP3-TXRX",
+ "renderer:dest-tp": "DEG1-TTP-TXRX"},
+ {"renderer:node-id": "XPDR-A1",
+ "renderer:src-tp": "XPDR1-CLIENT1",
+ "renderer:dest-tp": "XPDR1-NETWORK1"}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data),
+ headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(response.json(), {
- 'output': {'result': 'Request processed', 'success': True}})
+ 'output': {'result': 'Request processed', 'success': True}})
def test_18_service_path_delete_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/DEG1-TTP-TXRX-mc-7"
- .format(self.restconf_baseurl))
+ "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/DEG1-TTP-TXRX-mc-7"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing",
- "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_19_service_path_delete_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
- "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
- "interface/DEG1-TTP-TXRX-nmc-7"
- .format(self.restconf_baseurl))
+ "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
+ "interface/DEG1-TTP-TXRX-nmc-7"
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing",
- "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_20_service_path_delete_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_21_service_path_delete_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_22_service_path_delete_rdm_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_23_service_path_delete_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_24_service_path_delete_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_25_service_path_delete_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_26_service_path_delete_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
- {"error-type":"application", "error-tag":"data-missing", "error-message":"Request could not be completed because the relevant data model content does not exist"},
- res['errors']['error'])
+ {"error-type": "application", "error-tag": "data-missing",
+ "error-message": "Request could not be completed because the relevant data model content does not exist"},
+ res['errors']['error'])
def test_27_service_path_delete_xpdr_check(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(20)
def test_30_xpdr_device_disconnected(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-A1"
+ "network-topology/topology/topology-netconf/node/XPDR-A1"
.format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(20)
#!/usr/bin/env python
##############################################################################
-#Copyright (c) 2017 Orange, Inc. and others. All rights reserved.
+# Copyright (c) 2017 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
import logging
import test_utils
+
class TransportPCEtesting(unittest.TestCase):
honeynode_process1 = None
odl_process = None
restconf_baseurl = "http://localhost:8181/restconf"
-#START_IGNORE_XTESTING
+# START_IGNORE_XTESTING
@classmethod
def setUpClass(cls):
- print ("starting honeynode1...")
+ print("starting honeynode1...")
cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
time.sleep(20)
- print ("starting honeynode2...")
+ print("starting honeynode2...")
cls.honeynode_process2 = test_utils.start_roadma_honeynode()
time.sleep(20)
- print ("all honeynodes started")
+ print("all honeynodes started")
- print ("starting opendaylight...")
+ print("starting opendaylight...")
cls.odl_process = test_utils.start_tpce()
time.sleep(60)
- print ("opendaylight started")
+ print("opendaylight started")
@classmethod
def tearDownClass(cls):
def setUp(self):
time.sleep(10)
-#END_IGNORE_XTESTING
+# END_IGNORE_XTESTING
- #Connect the ROADMA
+ # Connect the ROADMA
def test_01_connect_rdm(self):
- #Config ROADMA
+ # Config ROADMA
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-A1"
+ "network-topology/topology/topology-netconf/node/ROADM-A1"
.format(self.restconf_baseurl))
data = {"node": [{
- "node-id": "ROADM-A1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": "17841",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "node-id": "ROADM-A1",
+ "netconf-node-topology:username": "admin",
+ "netconf-node-topology:password": "admin",
+ "netconf-node-topology:host": "127.0.0.1",
+ "netconf-node-topology:port": "17841",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
- #Verify the termination points of the ROADMA
+ # Verify the termination points of the ROADMA
def test_02_compareOpenroadmTopologyPortMapping_rdm(self):
urlTopo = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
responseTopo = requests.request(
"GET", urlTopo, headers=headers, auth=('admin', 'admin'))
urlMapList = "{}/config/transportpce-portmapping:network/nodes/" + nodeMapId
urlMapListFull = urlMapList.format(self.restconf_baseurl)
responseMapList = requests.request(
- "GET", urlMapListFull, headers=headers, auth=('admin', 'admin'))
+ "GET", urlMapListFull, headers=headers, auth=('admin', 'admin'))
resMapList = responseMapList.json()
nbMappings = len(resMapList['nodes'][0]['mapping']) - nbMapCumul
for j in range(0, nbTp):
tpId = resTopo['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
if((not "CP" in tpId) and (not "CTP" in tpId)):
- urlMap = "{}/config/transportpce-portmapping:network/nodes/" + nodeMapId + "/mapping/" + tpId
- urlMapFull = urlMap.format(self.restconf_baseurl)
- responseMap = requests.request(
+ urlMap = "{}/config/transportpce-portmapping:network/nodes/" + nodeMapId + "/mapping/" + tpId
+ urlMapFull = urlMap.format(self.restconf_baseurl)
+ responseMap = requests.request(
"GET", urlMapFull, headers=headers, auth=('admin', 'admin'))
- self.assertEqual(responseMap.status_code, requests.codes.ok)
- if(responseMap.status_code == requests.codes.ok):
+ self.assertEqual(responseMap.status_code, requests.codes.ok)
+ if(responseMap.status_code == requests.codes.ok):
nbMapCurrent += 1
nbMapCumul += nbMapCurrent
nbMappings -= nbMapCurrent
self.assertEqual(nbMappings, 0)
- #Disconnect the ROADMA
+ # Disconnect the ROADMA
def test_03_disconnect_rdm(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-A1"
+ "network-topology/topology/topology-netconf/node/ROADM-A1"
.format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
# #Connect the XPDRA
def test_04_connect_xpdr(self):
- #Config XPDRA
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-A1"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "XPDR-A1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": "17840",
- "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)
+ # Config XPDRA
+ url = ("{}/config/network-topology:"
+ "network-topology/topology/topology-netconf/node/XPDR-A1"
+ .format(self.restconf_baseurl))
+ data = {"node": [{
+ "node-id": "XPDR-A1",
+ "netconf-node-topology:username": "admin",
+ "netconf-node-topology:password": "admin",
+ "netconf-node-topology:host": "127.0.0.1",
+ "netconf-node-topology:port": "17840",
+ "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)
# #Verify the termination points related to XPDR
def test_05_compareOpenroadmTopologyPortMapping_xpdr(self):
self.test_02_compareOpenroadmTopologyPortMapping_rdm()
- #Disconnect the XPDRA
+ # Disconnect the XPDRA
def test_06_disconnect_device(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/XPDR-A1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
+
if __name__ == "__main__":
- #logging.basicConfig(filename='./transportpce_tests/log/response.log',filemode='w',level=logging.DEBUG)
+ # logging.basicConfig(filename='./transportpce_tests/log/response.log',filemode='w',level=logging.DEBUG)
#logging.debug('I am there')
unittest.main(verbosity=2)
#!/usr/bin/env python
##############################################################################
-#Copyright (c) 2017 Orange, Inc. and others. All rights reserved.
+# Copyright (c) 2017 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
import logging
import test_utils
+
class TransportPCEtesting(unittest.TestCase):
honeynode_process1 = None
odl_process = None
restconf_baseurl = "http://localhost:8181/restconf"
-#START_IGNORE_XTESTING
+# START_IGNORE_XTESTING
@classmethod
def setUpClass(cls):
- print ("starting honeynode1...")
+ print("starting honeynode1...")
cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
time.sleep(20)
- print ("starting honeynode2...")
+ print("starting honeynode2...")
cls.honeynode_process2 = test_utils.start_roadma_honeynode()
time.sleep(20)
- print ("starting honeynode3...")
+ print("starting honeynode3...")
cls.honeynode_process3 = test_utils.start_roadmb_honeynode()
time.sleep(20)
- print ("starting honeynode4...")
+ print("starting honeynode4...")
cls.honeynode_process4 = test_utils.start_roadmc_honeynode()
time.sleep(20)
- print ("all honeynodes started")
+ print("all honeynodes started")
- print ("starting opendaylight...")
+ print("starting opendaylight...")
cls.odl_process = test_utils.start_tpce()
time.sleep(60)
- print ("opendaylight started")
+ print("opendaylight started")
@classmethod
def tearDownClass(cls):
cls.honeynode_process4.send_signal(signal.SIGINT)
cls.honeynode_process4.wait()
-
def setUp(self):
time.sleep(5)
-#END_IGNORE_XTESTING
+# END_IGNORE_XTESTING
def test_01_connect_ROADM_A1(self):
- #Config ROADMA
+ # Config ROADMA
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-A1"
+ "network-topology/topology/topology-netconf/node/ROADM-A1"
.format(self.restconf_baseurl))
data = {"node": [{
- "node-id": "ROADM-A1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": "17841",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "node-id": "ROADM-A1",
+ "netconf-node-topology:username": "admin",
+ "netconf-node-topology:password": "admin",
+ "netconf-node-topology:host": "127.0.0.1",
+ "netconf-node-topology:port": "17841",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
def test_02_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
logging.info(res)
- self.assertEqual(res['network'][0]['node'][0]['node-id'],'NodeA')
- self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
+ 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_03_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- self.assertEqual(res['network'][0]['node'][0]['node-id'],'ROADM-A1')
- self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'],'clli-network')
- self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'],'NodeA')
- self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'],'ROADM')
- self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'],'model2')
+ self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADM-A1')
+ self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
+ self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
+ self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
+ self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'], 'model2')
def test_04_getLinks_OpenroadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- #Tests related to links
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
- self.assertEqual(nbLink,10)
- expressLink=['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
- 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
- addLink=['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
- 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
- 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
- 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
- dropLink=['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
- 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
- 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
- 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
- for i in range(0,nbLink):
+ # Tests related to links
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
+ self.assertEqual(nbLink, 10)
+ expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
+ 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
+ addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
+ 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
+ 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
+ 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
+ dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
+ 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
+ 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
+ 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
+ for i in range(0, nbLink):
linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
- if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='EXPRESS-LINK'):
- find= linkId in expressLink
+ if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
+ find = linkId in expressLink
self.assertEqual(find, True)
expressLink.remove(linkId)
- elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='ADD-LINK'):
- find= linkId in addLink
+ elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
+ find = linkId in addLink
self.assertEqual(find, True)
addLink.remove(linkId)
- elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='DROP-LINK'):
- find= linkId in dropLink
+ elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
+ find = linkId in dropLink
self.assertEqual(find, True)
dropLink.remove(linkId)
else:
self.assertFalse(True)
- self.assertEqual(len(expressLink),0)
- self.assertEqual(len(addLink),0)
- self.assertEqual(len(dropLink),0)
+ self.assertEqual(len(expressLink), 0)
+ self.assertEqual(len(addLink), 0)
+ self.assertEqual(len(dropLink), 0)
def test_05_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
res = response.json()
- #Tests related to nodes
+ # Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,4)
- listNode=['ROADM-A1-SRG1', 'ROADM-A1-SRG3','ROADM-A1-DEG1','ROADM-A1-DEG2']
- for i in range(0,nbNode):
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 4)
+ listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
+ for i in range(0, nbNode):
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
res['network'][0]['node'][i]['supporting-node'])
- nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
- nodeId=res['network'][0]['node'][i]['node-id']
- if(nodeId=='ROADM-A1-SRG1'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
+ nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
+ nodeId = res['network'][0]['node'][i]['node-id']
+ if(nodeId == 'ROADM-A1-SRG1'):
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-SRG3'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
+ elif(nodeId == 'ROADM-A1-SRG3'):
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-DEG1'):
- #Test related to DEG1
- self.assertEqual(nodeType,'DEGREE')
+ elif(nodeId == 'ROADM-A1-DEG1'):
+ # Test related to DEG1
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-DEG2'):
- #Test related to DEG2
- self.assertEqual(nodeType,'DEGREE')
+ elif(nodeId == 'ROADM-A1-DEG2'):
+ # Test related to DEG2
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
listNode.remove(nodeId)
else:
self.assertFalse(True)
- self.assertEqual(len(listNode),0)
+ self.assertEqual(len(listNode), 0)
def test_06_connect_XPDRA(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-A1"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "XPDR-A1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": "17840",
- "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)
+ url = ("{}/config/network-topology:"
+ "network-topology/topology/topology-netconf/node/XPDR-A1"
+ .format(self.restconf_baseurl))
+ data = {"node": [{
+ "node-id": "XPDR-A1",
+ "netconf-node-topology:username": "admin",
+ "netconf-node-topology:password": "admin",
+ "netconf-node-topology:host": "127.0.0.1",
+ "netconf-node-topology:port": "17840",
+ "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)
def test_07_getClliNetwork(self):
- url = ("{}/config/ietf-network:networks/network/clli-network"
+ 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'))
- 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')
+ headers = {'content-type': 'application/json'}
+ response = requests.request(
+ "GET", url, headers=headers, auth=('admin', 'admin'))
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res = response.json()
+ self.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"
+ 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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- res = response.json()
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,2)
- for i in range(0,nbNode):
- self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
- self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
- nodeId=res['network'][0]['node'][i]['node-id']
- if(nodeId=='XPDR-A1'):
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'XPONDER')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'model2')
- elif(nodeId=='ROADM-A1'):
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'model2')
- else:
+ headers = {'content-type': 'application/json'}
+ response = requests.request(
+ "GET", url, headers=headers, auth=('admin', 'admin'))
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res = response.json()
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 2)
+ for i in range(0, nbNode):
+ self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
+ self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
+ nodeId = res['network'][0]['node'][i]['node-id']
+ if(nodeId == 'XPDR-A1'):
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
+ elif(nodeId == 'ROADM-A1'):
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
+ else:
self.assertFalse(True)
def test_09_getNodes_OpenRoadmTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
+ 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'))
- res = response.json()
- #Tests related to nodes
- self.assertEqual(response.status_code, requests.codes.ok)
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,5)
- listNode=['XPDR-A1-XPDR1','ROADM-A1-SRG1','ROADM-A1-SRG3','ROADM-A1-DEG1','ROADM-A1-DEG2']
- for i in range(0,nbNode):
- nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
- nodeId=res['network'][0]['node'][i]['node-id']
- #Tests related to XPDRA nodes
- if(nodeId=='XPDR-A1-XPDR1'):
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(nodeType,'XPONDER')
- nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- client = 0
- network = 0
- for j in range(0,nbTps):
- tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
- tpId=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
- if (tpType=='XPONDER-CLIENT'):
- client += 1
- elif (tpType=='XPONDER-NETWORK'):
- network += 1
- if (tpId == 'XPDR1-NETWORK2'):
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
- ['transportpce-topology:associated-connection-map-port'],'XPDR1-CLIENT2')
- if (tpId == 'XPDR1-CLIENT2'):
- self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
- ['transportpce-topology:associated-connection-map-port'],'XPDR1-NETWORK2')
+ headers = {'content-type': 'application/json'}
+ response = requests.request(
+ "GET", url, headers=headers, auth=('admin', 'admin'))
+ res = response.json()
+ # Tests related to nodes
+ self.assertEqual(response.status_code, requests.codes.ok)
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 5)
+ listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
+ for i in range(0, nbNode):
+ nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
+ nodeId = res['network'][0]['node'][i]['node-id']
+ # Tests related to XPDRA nodes
+ if(nodeId == 'XPDR-A1-XPDR1'):
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(nodeType, 'XPONDER')
+ nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ client = 0
+ network = 0
+ for j in range(0, nbTps):
+ tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
+ tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
+ if (tpType == 'XPONDER-CLIENT'):
+ client += 1
+ elif (tpType == 'XPONDER-NETWORK'):
+ network += 1
+ if (tpId == 'XPDR1-NETWORK2'):
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
+ ['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
+ if (tpId == 'XPDR1-CLIENT2'):
+ self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
+ ['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
- self.assertTrue(client == 2)
- self.assertTrue(network == 2)
- listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-SRG1'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
- self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
- res['network'][0]['node'][i]['supporting-node'])
- listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-SRG3'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
- self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
- res['network'][0]['node'][i]['supporting-node'])
- listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-DEG1'):
- #Test related to DEG1
- self.assertEqual(nodeType,'DEGREE')
+ self.assertTrue(client == 2)
+ self.assertTrue(network == 2)
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADM-A1-SRG1'):
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
+ self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
+ res['network'][0]['node'][i]['supporting-node'])
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADM-A1-SRG3'):
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
+ self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
+ res['network'][0]['node'][i]['supporting-node'])
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADM-A1-DEG1'):
+ # Test related to DEG1
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-DEG2'):
- #Test related to DEG2
- self.assertEqual(nodeType,'DEGREE')
+ elif(nodeId == 'ROADM-A1-DEG2'):
+ # Test related to DEG2
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- else:
+ else:
self.assertFalse(True)
- self.assertEqual(len(listNode),0)
+ self.assertEqual(len(listNode), 0)
- #Connect the tail XPDRA to ROADMA and vice versa
+ # Connect the tail XPDRA to ROADMA and vice versa
def test_10_connect_tail_xpdr_rdm(self):
- #Connect the tail: XPDRA to ROADMA
+ # Connect the tail: XPDRA to ROADMA
url = ("{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {"networkutils:input": {
- "networkutils:links-input": {
- "networkutils:xpdr-node": "XPDR-A1",
- "networkutils:xpdr-num": "1",
- "networkutils:network-num": "1",
- "networkutils:rdm-node": "ROADM-A1",
- "networkutils:srg-num": "1",
- "networkutils:termination-point-num": "SRG1-PP1-TXRX"
+ "networkutils:links-input": {
+ "networkutils:xpdr-node": "XPDR-A1",
+ "networkutils:xpdr-num": "1",
+ "networkutils:network-num": "1",
+ "networkutils:rdm-node": "ROADM-A1",
+ "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'))
+ "POST", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
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": {
+ # 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": "XPDR-A1",
"networkutils:xpdr-num": "1",
"networkutils:network-num": "1",
"networkutils:rdm-node": "ROADM-A1",
"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'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ }
+ }
+ }
+ headers = {'content-type': 'application/json'}
+ response = requests.request(
+ "POST", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
+ self.assertEqual(response.status_code, requests.codes.ok)
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'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- #Tests related to links
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
- self.assertEqual(nbLink,12)
- expressLink=['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX','ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
- addLink=['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX','ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
- 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX','ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
- dropLink=['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX','ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
- 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX','ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
- XPDR_IN=['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
- XPDR_OUT=['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
- for i in range(0,nbLink):
- nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
- linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
- if(nodeType=='EXPRESS-LINK'):
- find= linkId in expressLink
+ # Tests related to links
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
+ self.assertEqual(nbLink, 12)
+ expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
+ 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
+ addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
+ 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
+ dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
+ 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
+ XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
+ XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
+ for i in range(0, nbLink):
+ nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
+ linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
+ if(nodeType == 'EXPRESS-LINK'):
+ find = linkId in expressLink
self.assertEqual(find, True)
expressLink.remove(linkId)
- elif(nodeType=='ADD-LINK'):
- find= linkId in addLink
+ elif(nodeType == 'ADD-LINK'):
+ find = linkId in addLink
self.assertEqual(find, True)
addLink.remove(linkId)
- elif(nodeType=='DROP-LINK'):
- find= linkId in dropLink
+ elif(nodeType == 'DROP-LINK'):
+ find = linkId in dropLink
self.assertEqual(find, True)
dropLink.remove(linkId)
- elif(nodeType=='XPONDER-INPUT'):
- find= linkId in XPDR_IN
+ elif(nodeType == 'XPONDER-INPUT'):
+ find = linkId in XPDR_IN
self.assertEqual(find, True)
XPDR_IN.remove(linkId)
- elif(nodeType=='XPONDER-OUTPUT'):
- find= linkId in XPDR_OUT
+ elif(nodeType == 'XPONDER-OUTPUT'):
+ find = linkId in XPDR_OUT
self.assertEqual(find, True)
XPDR_OUT.remove(linkId)
else:
self.assertFalse(True)
- self.assertEqual(len(expressLink),0)
- self.assertEqual(len(addLink),0)
- self.assertEqual(len(dropLink),0)
- self.assertEqual(len(XPDR_IN),0)
- self.assertEqual(len(XPDR_OUT),0)
+ self.assertEqual(len(expressLink), 0)
+ self.assertEqual(len(addLink), 0)
+ self.assertEqual(len(dropLink), 0)
+ self.assertEqual(len(XPDR_IN), 0)
+ self.assertEqual(len(XPDR_OUT), 0)
def test_13_connect_ROADMC(self):
- #Config ROADMC
+ # Config ROADMC
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-C1"
- .format(self.restconf_baseurl))
+ "network-topology/topology/topology-netconf/node/ROADM-C1"
+ .format(self.restconf_baseurl))
data = {"node": [{
- "node-id": "ROADM-C1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": "17843",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "node-id": "ROADM-C1",
+ "netconf-node-topology:username": "admin",
+ "netconf-node-topology:password": "admin",
+ "netconf-node-topology:host": "127.0.0.1",
+ "netconf-node-topology:port": "17843",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
def test_16_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbNode=len(res['network'][0]['node'])
- listNode=['NodeA','NodeC']
- for i in range(0,nbNode):
+ nbNode = len(res['network'][0]['node'])
+ listNode = ['NodeA', 'NodeC']
+ for i in range(0, nbNode):
nodeId = res['network'][0]['node'][i]['node-id']
- find= nodeId in listNode
+ find = nodeId in listNode
self.assertEqual(find, True)
- if(nodeId=='NodeA'):
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
+ if(nodeId == 'NodeA'):
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
else:
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
listNode.remove(nodeId)
- self.assertEqual(len(listNode),0)
+ self.assertEqual(len(listNode), 0)
def test_17_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,3)
- listNode=['XPDR-A1','ROADM-A1','ROADM-C1']
- for i in range(0,nbNode):
- self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
- nodeId=res['network'][0]['node'][i]['node-id']
- if(nodeId=='XPDR-A1'):
- self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'XPONDER')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'model2')
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 3)
+ listNode = ['XPDR-A1', 'ROADM-A1', 'ROADM-C1']
+ for i in range(0, nbNode):
+ self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
+ nodeId = res['network'][0]['node'][i]['node-id']
+ if(nodeId == 'XPDR-A1'):
+ self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1'):
- self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'model2')
+ elif(nodeId == 'ROADM-A1'):
+ self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
listNode.remove(nodeId)
- elif(nodeId=='ROADM-C1'):
- self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeC')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'model2')
+ elif(nodeId == 'ROADM-C1'):
+ self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeC')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
listNode.remove(nodeId)
else:
self.assertFalse(True)
- self.assertEqual(len(listNode),0)
+ self.assertEqual(len(listNode), 0)
def test_18_getROADMLinkOpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- #Tests related to links
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
- self.assertEqual(nbLink,20)
- expressLink=['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX','ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
- 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX','ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX']
- addLink=['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX','ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
- 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX','ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
- 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX','ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX']
- dropLink=['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX','ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
- 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX','ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
- 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX','ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX']
- R2RLink=['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX','ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
- XPDR_IN=['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
- XPDR_OUT=['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
- for i in range(0,nbLink):
- nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
- linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
- if(nodeType=='EXPRESS-LINK'):
- find= linkId in expressLink
+ # Tests related to links
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
+ self.assertEqual(nbLink, 20)
+ expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX', 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
+ 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX', 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX']
+ addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
+ 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
+ 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX', 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX']
+ dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
+ 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
+ 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX', 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX']
+ R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
+ 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
+ XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
+ XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
+ for i in range(0, nbLink):
+ nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
+ linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
+ if(nodeType == 'EXPRESS-LINK'):
+ find = linkId in expressLink
self.assertEqual(find, True)
expressLink.remove(linkId)
- elif(nodeType=='ADD-LINK'):
- find= linkId in addLink
+ elif(nodeType == 'ADD-LINK'):
+ find = linkId in addLink
self.assertEqual(find, True)
addLink.remove(linkId)
- elif(nodeType=='DROP-LINK'):
- find= linkId in dropLink
+ elif(nodeType == 'DROP-LINK'):
+ find = linkId in dropLink
self.assertEqual(find, True)
dropLink.remove(linkId)
- elif(nodeType=='ROADM-TO-ROADM'):
- find= linkId in R2RLink
+ elif(nodeType == 'ROADM-TO-ROADM'):
+ find = linkId in R2RLink
self.assertEqual(find, True)
R2RLink.remove(linkId)
- elif(nodeType=='XPONDER-INPUT'):
- find= linkId in XPDR_IN
+ elif(nodeType == 'XPONDER-INPUT'):
+ find = linkId in XPDR_IN
self.assertEqual(find, True)
XPDR_IN.remove(linkId)
- elif(nodeType=='XPONDER-OUTPUT'):
- find= linkId in XPDR_OUT
+ elif(nodeType == 'XPONDER-OUTPUT'):
+ find = linkId in XPDR_OUT
self.assertEqual(find, True)
XPDR_OUT.remove(linkId)
else:
self.assertFalse(True)
- self.assertEqual(len(expressLink),0)
- self.assertEqual(len(addLink),0)
- self.assertEqual(len(dropLink),0)
- self.assertEqual(len(R2RLink),0)
- self.assertEqual(len(XPDR_IN),0)
- self.assertEqual(len(XPDR_OUT),0)
+ self.assertEqual(len(expressLink), 0)
+ self.assertEqual(len(addLink), 0)
+ self.assertEqual(len(dropLink), 0)
+ self.assertEqual(len(R2RLink), 0)
+ self.assertEqual(len(XPDR_IN), 0)
+ self.assertEqual(len(XPDR_OUT), 0)
def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- #Tests related to links
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
- self.assertEqual(nbLink,20)
- R2RLink=['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
- 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
- for i in range(0,nbLink):
+ # Tests related to links
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
+ self.assertEqual(nbLink, 20)
+ R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
+ 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
+ for i in range(0, nbLink):
nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
- link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
+ link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
if(link_id in R2RLink):
find = False
spanLoss = res['network'][0]['ietf-network-topology:link'][i][
'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
length = res['network'][0]['ietf-network-topology:link'][i][
'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
- if((spanLoss!=None)&(length!=None)):
+ if((spanLoss != None) & (length != None)):
find = True
self.assertTrue(find)
R2RLink.remove(link_id)
- self.assertEqual(len(R2RLink),0)
+ self.assertEqual(len(R2RLink), 0)
def test_20_getNodes_OpenRoadmTopology(self):
- url = ("{}/config/ietf-network:networks/network/openroadm-topology"
+ 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'))
- res = response.json()
- #Tests related to nodes
- self.assertEqual(response.status_code, requests.codes.ok)
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,8)
- listNode=['XPDR-A1-XPDR1',
- 'ROADM-A1-SRG1','ROADM-A1-SRG3','ROADM-A1-DEG1','ROADM-A1-DEG2',
- 'ROADM-C1-SRG1','ROADM-C1-DEG1', 'ROADM-C1-DEG2']
- #************************Tests related to XPDRA nodes
- for i in range(0,nbNode):
- nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
- nodeId=res['network'][0]['node'][i]['node-id']
- if(nodeId=='XPDR-A1-XPDR1'):
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(nodeType,'XPONDER')
- nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertTrue(nbTps >= 4)
- client = 0
- network = 0
- for j in range(0,nbTps):
- tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
- if (tpType=='XPONDER-CLIENT'):
- client += 1
- elif (tpType=='XPONDER-NETWORK'):
- network += 1
- self.assertTrue(client == 2)
- self.assertTrue(network == 2)
- listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-SRG1'):
- #Test related to SRG1
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
- self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
- listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-SRG3'):
- #Test related to SRG1
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
- self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
- listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-DEG1'):
- #Test related to DEG1
- self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
- listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-DEG2'):
- #Test related to DEG2
- self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
- listNode.remove(nodeId)
- elif(nodeId=='ROADM-C1-SRG1'):
- #Test related to SRG1
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
- self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
- listNode.remove(nodeId)
- elif(nodeId=='ROADM-C1-DEG1'):
- #Test related to DEG1
- self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
- listNode.remove(nodeId)
- elif(nodeId=='ROADM-C1-DEG2'):
- #Test related to DEG1
- self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
- self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
- res['network'][0]['node'][i]['supporting-node'])
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
- listNode.remove(nodeId)
- else:
+ headers = {'content-type': 'application/json'}
+ response = requests.request(
+ "GET", url, headers=headers, auth=('admin', 'admin'))
+ res = response.json()
+ # Tests related to nodes
+ self.assertEqual(response.status_code, requests.codes.ok)
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 8)
+ listNode = ['XPDR-A1-XPDR1',
+ 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
+ 'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
+ # ************************Tests related to XPDRA nodes
+ for i in range(0, nbNode):
+ nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
+ nodeId = res['network'][0]['node'][i]['node-id']
+ if(nodeId == 'XPDR-A1-XPDR1'):
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(nodeType, 'XPONDER')
+ nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertTrue(nbTps >= 4)
+ client = 0
+ network = 0
+ for j in range(0, nbTps):
+ tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
+ if (tpType == 'XPONDER-CLIENT'):
+ client += 1
+ elif (tpType == 'XPONDER-NETWORK'):
+ network += 1
+ self.assertTrue(client == 2)
+ self.assertTrue(network == 2)
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADM-A1-SRG1'):
+ # Test related to SRG1
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
+ self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADM-A1-SRG3'):
+ # Test related to SRG1
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
+ self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADM-A1-DEG1'):
+ # Test related to DEG1
+ self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADM-A1-DEG2'):
+ # Test related to DEG2
+ self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADM-C1-SRG1'):
+ # Test related to SRG1
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
+ self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADM-C1-DEG1'):
+ # Test related to DEG1
+ self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
+ listNode.remove(nodeId)
+ elif(nodeId == 'ROADM-C1-DEG2'):
+ # Test related to DEG1
+ self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
+ res['network'][0]['node'][i]['supporting-node'])
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
+ listNode.remove(nodeId)
+ else:
self.assertFalse(True)
- self.assertEqual(len(listNode),0)
+ self.assertEqual(len(listNode), 0)
def test_21_connect_ROADMB(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-B1"
+ "network-topology/topology/topology-netconf/node/ROADM-B1"
.format(self.restconf_baseurl))
data = {"node": [{
- "node-id": "ROADM-B1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": "17842",
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
+ "node-id": "ROADM-B1",
+ "netconf-node-topology:username": "admin",
+ "netconf-node-topology:password": "admin",
+ "netconf-node-topology:host": "127.0.0.1",
+ "netconf-node-topology:port": "17842",
+ "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'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
time.sleep(20)
"pmd": 0.5}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
def test_23_omsAttributes_ROADMB_ROADMA(self):
"pmd": 0.5}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
def test_24_omsAttributes_ROADMB_ROADMC(self):
"pmd": 0.5}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.created)
def test_25_omsAttributes_ROADMC_ROADMB(self):
"pmd": 0.5}]}}
headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
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))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbNode=len(res['network'][0]['node'])
- listNode=['NodeA','NodeB','NodeC']
- for i in range(0,nbNode):
+ nbNode = len(res['network'][0]['node'])
+ listNode = ['NodeA', 'NodeB', 'NodeC']
+ for i in range(0, nbNode):
nodeId = res['network'][0]['node'][i]['node-id']
- find= nodeId in listNode
+ find = nodeId in listNode
self.assertEqual(find, True)
- if(nodeId=='NodeA'):
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeA')
- elif(nodeId=='NodeB'):
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeB')
+ if(nodeId == 'NodeA'):
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
+ elif(nodeId == 'NodeB'):
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeB')
else:
- self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
+ self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
listNode.remove(nodeId)
- self.assertEqual(len(listNode),0)
+ self.assertEqual(len(listNode), 0)
def test_27_verifyDegree(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- #Tests related to links
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
- listR2RLink=['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX','ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
- 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX','ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
- 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX','ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
- for i in range(0,nbLink):
+ # Tests related to links
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
+ listR2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX', 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
+ 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX', 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
+ 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX', 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
+ for i in range(0, nbLink):
if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
- find= link_id in listR2RLink
+ find = link_id in listR2RLink
self.assertEqual(find, True)
listR2RLink.remove(link_id)
- self.assertEqual(len(listR2RLink),0)
+ 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'))
+ "GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- #Tests related to links
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
- self.assertEqual(nbLink,26)
- for i in range(0,nbLink):
- link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
- link_type=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
- link_src=res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
- link_dest=res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
- 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
+ # Tests related to links
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
+ self.assertEqual(nbLink, 26)
+ for i in range(0, nbLink):
+ link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
+ link_type = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
+ link_src = res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
+ link_dest = res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
+ 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'))
self.assertEqual(response_oppLink.status_code, requests.codes.ok)
res_oppLink = response_oppLink.json()
- self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:opposite-link'],link_id)
- self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'],link_dest)
- self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'],link_src)
- oppLink_type=res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
- if link_type=='ADD-LINK':
+ self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
+ ['org-openroadm-common-network:opposite-link'], link_id)
+ self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'], link_dest)
+ self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'], link_src)
+ oppLink_type = res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
+ if link_type == 'ADD-LINK':
self.assertEqual(oppLink_type, 'DROP-LINK')
- elif link_type=='DROP-LINK':
+ elif link_type == 'DROP-LINK':
self.assertEqual(oppLink_type, 'ADD-LINK')
- elif link_type=='EXPRESS-LINK':
+ elif link_type == 'EXPRESS-LINK':
self.assertEqual(oppLink_type, 'EXPRESS-LINK')
- elif link_type=='ROADM-TO-ROADM':
+ elif link_type == 'ROADM-TO-ROADM':
self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
- elif link_type=='XPONDER-INPUT':
+ elif link_type == 'XPONDER-INPUT':
self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
- elif link_type=='XPONDER-OUTPUT':
+ elif link_type == 'XPONDER-OUTPUT':
self.assertEqual(oppLink_type, 'XPONDER-INPUT')
def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
- 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
- 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
- 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
- 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
- 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
- for i in range(0,nbLink):
+ 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
+ 'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
+ 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
+ 'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
+ 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
+ for i in range(0, nbLink):
nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
- link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
+ link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
if(link_id in R2RLink):
find = False
spanLoss = res['network'][0]['ietf-network-topology:link'][i][
'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
length = res['network'][0]['ietf-network-topology:link'][i][
'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
- if((spanLoss!=None)&(length!=None)):
+ if((spanLoss != None) & (length != None)):
find = True
self.assertTrue(find)
R2RLink.remove(link_id)
- self.assertEqual(len(R2RLink),0)
+ self.assertEqual(len(R2RLink), 0)
def test_30_disconnect_ROADMB(self):
- #Delete in the topology-netconf
+ # Delete in the topology-netconf
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-B1"
+ "network-topology/topology/topology-netconf/node/ROADM-B1"
.format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
- #Delete in the clli-network
+ # Delete in the clli-network
url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeB"
.format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
def test_31_disconnect_ROADMC(self):
- #Delete in the topology-netconf
+ # Delete in the topology-netconf
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-C1"
+ "network-topology/topology/topology-netconf/node/ROADM-C1"
.format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
- #Delete in the clli-network
+ # Delete in the clli-network
url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeC"
.format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
# def test_24_check_roadm2roadm_links_deletion(self):
def test_32_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
res = response.json()
- #Tests related to nodes
+ # Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,5)
- listNode=['XPDR-A1-XPDR1','ROADM-A1-SRG1', 'ROADM-A1-SRG3','ROADM-A1-DEG1','ROADM-A1-DEG2']
- for i in range(0,nbNode):
- nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
- nodeId=res['network'][0]['node'][i]['node-id']
- #Tests related to XPDRA nodes
- if(nodeId=='XPDR-A1-XPDR1'):
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 5)
+ listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
+ for i in range(0, nbNode):
+ nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
+ nodeId = res['network'][0]['node'][i]['node-id']
+ # Tests related to XPDRA nodes
+ if(nodeId == 'XPDR-A1-XPDR1'):
nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
for j in range(0, nbTp):
tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
'ROADM-A1-SRG1--SRG1-PP1-TXRX')
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
- res['network'][0]['node'][i]['supporting-node'])
+ res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-SRG1'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
+ elif(nodeId == 'ROADM-A1-SRG1'):
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-SRG3'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
+ elif(nodeId == 'ROADM-A1-SRG3'):
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-DEG1'):
- #Test related to DEG1
- self.assertEqual(nodeType,'DEGREE')
+ elif(nodeId == 'ROADM-A1-DEG1'):
+ # Test related to DEG1
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
- res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+ res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
- res['network'][0]['node'][i]['supporting-node'])
+ res['network'][0]['node'][i]['supporting-node'])
listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-DEG2'):
- #Test related to DEG2
- self.assertEqual(nodeType,'DEGREE')
+ elif(nodeId == 'ROADM-A1-DEG2'):
+ # Test related to DEG2
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
listNode.remove(nodeId)
else:
self.assertFalse(True)
- self.assertEqual(len(listNode),0)
- #Test related to SRG1 of ROADMC
- for i in range(0,nbNode):
- self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADM-C1-SRG1')
- self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADM-C1-DEG1')
- self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADM-C1-DEG2')
+ self.assertEqual(len(listNode), 0)
+ # Test related to SRG1 of ROADMC
+ for i in range(0, nbNode):
+ self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-SRG1')
+ self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG1')
+ self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG2')
def test_33_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,2)
- for i in range(0,nbNode-1):
- self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADM-C1')
- self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADM-B1')
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 2)
+ for i in range(0, nbNode-1):
+ self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1')
+ self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-B1')
def test_34_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,1)
- for i in range(0,nbNode-1):
- self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'],'NodeC')
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 1)
+ for i in range(0, nbNode-1):
+ 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/XPDR-A1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
def test_36_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,1)
- self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 1)
+ self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
def test_37_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,1)
- for i in range(0,nbNode):
- self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'XPDR-A1')
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 1)
+ for i in range(0, nbNode):
+ self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDR-A1')
def test_38_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
res = response.json()
- #Tests related to nodes
+ # Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
- nbNode=len(res['network'][0]['node'])
- self.assertEqual(nbNode,4)
- listNode=['ROADM-A1-SRG1','ROADM-A1-SRG3','ROADM-A1-DEG1','ROADM-A1-DEG2']
- for i in range(0,nbNode):
+ nbNode = len(res['network'][0]['node'])
+ self.assertEqual(nbNode, 4)
+ listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
+ for i in range(0, nbNode):
self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
res['network'][0]['node'][i]['supporting-node'])
- nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
- nodeId=res['network'][0]['node'][i]['node-id']
- if(nodeId=='ROADM-A1-SRG1'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
+ nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
+ nodeId = res['network'][0]['node'][i]['node-id']
+ if(nodeId == 'ROADM-A1-SRG1'):
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-SRG3'):
- #Test related to SRG1
- self.assertEqual(nodeType,'SRG')
- self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
+ elif(nodeId == 'ROADM-A1-SRG3'):
+ # Test related to SRG1
+ self.assertEqual(nodeType, 'SRG')
+ self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-DEG1'):
- #Test related to DEG1
- self.assertEqual(nodeType,'DEGREE')
+ elif(nodeId == 'ROADM-A1-DEG1'):
+ # Test related to DEG1
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
listNode.remove(nodeId)
- elif(nodeId=='ROADM-A1-DEG2'):
- #Test related to DEG2
- self.assertEqual(nodeType,'DEGREE')
+ elif(nodeId == 'ROADM-A1-DEG2'):
+ # Test related to DEG2
+ self.assertEqual(nodeType, 'DEGREE')
self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
listNode.remove(nodeId)
else:
self.assertFalse(True)
- self.assertEqual(len(listNode),0)
+ self.assertEqual(len(listNode), 0)
def test_39_disconnect_ROADM_XPDRA_link(self):
- #Link-1
+ # Link-1
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
- #Link-2
+ # Link-2
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
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))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
self.assertEqual(nbLink, 16)
- expressLink=['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX','ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
- addLink=['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX','ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
- 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX','ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
- dropLink=['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX','ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
- 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX','ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
+ expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
+ 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
+ addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
+ 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
+ dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
+ 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
roadmtoroadmLink = 0
- for i in range(0,nbLink):
- if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='EXPRESS-LINK'):
+ for i in range(0, nbLink):
+ if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
- find= link_id in expressLink
+ find = link_id in expressLink
self.assertEqual(find, True)
expressLink.remove(link_id)
- elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='ADD-LINK'):
+ elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
- find= link_id in addLink
+ find = link_id in addLink
self.assertEqual(find, True)
addLink.remove(link_id)
- elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='DROP-LINK'):
+ elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
- find= link_id in dropLink
+ find = link_id in dropLink
self.assertEqual(find, True)
dropLink.remove(link_id)
else:
roadmtoroadmLink += 1
- self.assertEqual(len(expressLink),0)
- self.assertEqual(len(addLink),0)
- self.assertEqual(len(dropLink),0)
+ self.assertEqual(len(expressLink), 0)
+ self.assertEqual(len(addLink), 0)
+ self.assertEqual(len(dropLink), 0)
self.assertEqual(roadmtoroadmLink, 6)
- for i in range(0,nbLink):
- self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'XPONDER-OUTPUT')
- self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'XPONDER-INPUT')
+ for i in range(0, nbLink):
+ self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
+ ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
+ self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
+ ['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
def test_41_disconnect_ROADMA(self):
url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-A1"
+ "network-topology/topology/topology-netconf/node/ROADM-A1"
.format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
- #Delete in the clli-network
+ # Delete in the clli-network
url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeA"
.format(self.restconf_baseurl))
data = {}
headers = {'content-type': 'application/json'}
response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "DELETE", url, data=json.dumps(data), headers=headers,
+ auth=('admin', 'admin'))
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))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
def test_43_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
def test_44_check_roadm2roadm_link_persistence(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(self.restconf_baseurl))
headers = {'content-type': 'application/json'}
response = requests.request(
"GET", url, headers=headers, auth=('admin', 'admin'))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- nbLink=len(res['network'][0]['ietf-network-topology:link'])
+ nbLink = len(res['network'][0]['ietf-network-topology:link'])
self.assertNotIn('node', res['network'][0])
self.assertEqual(nbLink, 6)
+
if __name__ == "__main__":
unittest.main(verbosity=2)
import os
import subprocess
-honeynode_executable=os.path.join(
- os.path.dirname(os.path.realpath(__file__)),
- "..", "..", "honeynode", "2.2.1", "honeynode-distribution", "target", "honeynode-distribution-1.19.04-hc",
- "honeynode-distribution-1.19.04", "honeycomb-tpce")
-samples_directory=os.path.join(
- os.path.dirname(os.path.realpath(__file__)),
- "..", "..", "sample_configs", "openroadm", "2.2.1")
+honeynode_executable = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "..", "..", "honeynode", "2.2.1", "honeynode-distribution", "target", "honeynode-distribution-1.19.04-hc",
+ "honeynode-distribution-1.19.04", "honeycomb-tpce")
+samples_directory = os.path.join(
+ os.path.dirname(os.path.realpath(__file__)),
+ "..", "..", "sample_configs", "openroadm", "2.2.1")
+
def start_xpdra_honeynode():
if os.path.isfile(honeynode_executable):
with open('honeynode1.log', 'w') as outfile:
return subprocess.Popen(
- [honeynode_executable, "17840", os.path.join(samples_directory,"oper-XPDRA.xml")],
+ [honeynode_executable, "17840", os.path.join(samples_directory, "oper-XPDRA.xml")],
stdout=outfile, stderr=outfile)
+
def start_roadma_honeynode():
if os.path.isfile(honeynode_executable):
with open('honeynode2.log', 'w') as outfile:
return subprocess.Popen(
- [honeynode_executable, "17841", os.path.join(samples_directory,"oper-ROADMA.xml")],
+ [honeynode_executable, "17841", os.path.join(samples_directory, "oper-ROADMA.xml")],
stdout=outfile, stderr=outfile)
+
def start_roadmb_honeynode():
if os.path.isfile(honeynode_executable):
with open('honeynode5.log', 'w') as outfile:
return subprocess.Popen(
- [honeynode_executable, "17842", os.path.join(samples_directory,"oper-ROADMB.xml")],
+ [honeynode_executable, "17842", os.path.join(samples_directory, "oper-ROADMB.xml")],
stdout=outfile, stderr=outfile)
+
def start_roadmc_honeynode():
if os.path.isfile(honeynode_executable):
with open('honeynode3.log', 'w') as outfile:
return subprocess.Popen(
- [honeynode_executable, "17843", os.path.join(samples_directory,"oper-ROADMC.xml")],
+ [honeynode_executable, "17843", os.path.join(samples_directory, "oper-ROADMC.xml")],
stdout=outfile, stderr=outfile)
+
def start_xpdrc_honeynode():
if os.path.isfile(honeynode_executable):
with open('honeynode4.log', 'w') as outfile:
return subprocess.Popen(
- [honeynode_executable, "17844", os.path.join(samples_directory,"oper-XPDRC.xml")],
+ [honeynode_executable, "17844", os.path.join(samples_directory, "oper-XPDRC.xml")],
stdout=outfile, stderr=outfile)
+
def start_spdra_honeynode():
if os.path.isfile(honeynode_executable):
with open('honeynode6.log', 'w') as outfile:
return subprocess.Popen(
- [honeynode_executable, "17845", os.path.join(samples_directory,"oper-SPDRAv2.xml")],
+ [honeynode_executable, "17845", os.path.join(samples_directory, "oper-SPDRAv2.xml")],
stdout=outfile, stderr=outfile)
+
def start_tpce():
if "USE_LIGHTY" in os.environ and os.environ['USE_LIGHTY'] == 'True':
- 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", "lighty-transportpce-12.0.0-SNAPSHOT",
- "clean-start-controller.sh")
+ os.path.dirname(os.path.realpath(__file__)),
+ "..", "..", "..", "lighty", "target", "lighty-transportpce-12.0.0-SNAPSHOT",
+ "clean-start-controller.sh")
with open('odl.log', 'w') as outfile:
return subprocess.Popen(
["sh", executable], stdout=outfile, stderr=outfile,
stdin=open(os.devnull))
else:
- print ("starting KARAF TransportPCE build...")
+ print("starting KARAF TransportPCE build...")
executable = os.path.join(
- os.path.dirname(os.path.realpath(__file__)),
- "..", "..", "..", "karaf", "target", "assembly", "bin", "karaf")
+ os.path.dirname(os.path.realpath(__file__)),
+ "..", "..", "..", "karaf", "target", "assembly", "bin", "karaf")
with open('odl.log', 'w') as outfile:
return subprocess.Popen(
["sh", executable, "server"], stdout=outfile, stderr=outfile,
Code Review / transportpce.git / commitdiff