class TransportPCEFulltesting(unittest.TestCase):
- headers = {'content-type': 'application/json'}
WAITING = 20 # nominal value is 300
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(cls):
# connect netconf devices
def test_01_connect_xpdrA(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDRA01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "XPDRA01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['xpdra']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("XPDRA01", 'xpdra')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_connect_xpdrC(self):
- url = ("{}/config/network-topology:"
- "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": test_utils.sims['xpdrc']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("XPDRC01", 'xpdrc')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_connect_rdmA(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": test_utils.sims['roadma-full']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADMA01", 'roadma-full')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_04_connect_rdmC(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMC01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "ROADMC01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['roadmc-full']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADMC01", 'roadmc-full')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
- format(self.restconf_baseurl)
+ format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully',
def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
- format(self.restconf_baseurl)
+ format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully',
def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
- format(self.restconf_baseurl)
+ format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully',
def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
- format(self.restconf_baseurl)
+ format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully',
"link/ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX/"
"org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"clfi": "fiber1",
"auto-spanloss": "true",
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
def test_10_add_omsAttributes_ROADMC_ROADMA(self):
"link/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX/"
"org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"clfi": "fiber1",
"auto-spanloss": "true",
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
# test service-create for Eth service from xpdr to xpdr
def test_11_create_eth_service1(self):
url = ("{}/operations/org-openroadm-service:service-create"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {
"input": {
"sdnc-request-header": {
"operator-contact": "pw1234"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
def test_12_get_eth_service1(self):
url = ("{}/operational/org-openroadm-service:service-list/services/"
- "service1".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ "service1".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
"node/ROADMA01/yang-ext:"
"mount/org-openroadm-device:org-openroadm-device/"
"roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
"node/ROADMC01/yang-ext:mount/org-openroadm-device:"
"org-openroadm-device/"
"roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
url1 = (
"{}/config/ietf-network:"
"networks/network/openroadm-topology/node/XPDRA01-XPDR1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
url1 = (
"{}/config/ietf-network:"
"networks/network/openroadm-topology/node/ROADMA01-SRG1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn({u'index': 1},
url1 = (
"{}/config/ietf-network:"
"networks/network/openroadm-topology/node/ROADMA01-DEG1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn({u'index': 1},
def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
- format(self.restconf_baseurl)
+ format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully',
def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
- format(self.restconf_baseurl)
+ format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully',
def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
- format(self.restconf_baseurl)
+ format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully',
def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
- format(self.restconf_baseurl)
+ format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully',
def test_22_create_eth_service2(self):
url = ("{}/operations/org-openroadm-service:service-create"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {
"input": {
"sdnc-request-header": {
"operator-contact": "pw1234"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
def test_23_get_eth_service2(self):
url = ("{}/operational/org-openroadm-service:"
"service-list/services/service2"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
"node/ROADMA01/yang-ext:"
"mount/org-openroadm-device:org-openroadm-device/"
"roadm-connections/DEG1-TTP-TXRX-SRG1-PP2-TXRX-2"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
url1 = (
"{}/config/ietf-network:"
"networks/network/openroadm-topology/node/XPDRA01-XPDR1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
url1 = (
"{}/config/ietf-network:"
"networks/network/openroadm-topology/node/ROADMA01-SRG1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn({u'index': 1}, res['node'][0][
url1 = (
"{}/config/ietf-network:"
"networks/network/openroadm-topology/node/ROADMA01-DEG1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn({u'index': 1}, res['node'][0][
# 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(test_utils.RESTCONF_BASE_URL))
data = {
"input": {
"sdnc-request-header": {
"operator-contact": "pw1234"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
def test_29_delete_eth_service3(self):
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
}
}
}
- 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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Service \'service3\' does not exist in datastore',
def test_30_delete_eth_service1(self):
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
}
}
}
- 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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Renderer service delete in progress',
def test_31_delete_eth_service2(self):
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
}
}
}
- 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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Renderer service delete in progress',
"network-topology/topology/topology-netconf/"
"node/ROADMA01/yang-ext:"
"mount/org-openroadm-device:org-openroadm-device/"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, auth=('admin', 'admin'))
+ "GET", url, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
self.assertEqual(response.status_code, requests.codes.ok)
self.assertNotIn('roadm-connections',
url1 = (
"{}/config/ietf-network:"
"networks/network/openroadm-topology/node/XPDRA01-XPDR1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
url1 = (
"{}/config/ietf-network:"
"networks/network/openroadm-topology/node/ROADMA01-SRG1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn({u'index': 1}, res['node'][0][
url1 = (
"{}/config/ietf-network:"
"networks/network/openroadm-topology/node/ROADMA01-DEG1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn({u'index': 1}, res['node'][0][
# 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(test_utils.RESTCONF_BASE_URL))
data = {
"input": {
"sdnc-request-header": {
"operator-contact": "pw1234"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
def test_37_get_oc_service1(self):
url = ("{}/operational/org-openroadm-service:"
"service-list/services/service1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
"node/ROADMA01/yang-ext:"
"mount/org-openroadm-device:org-openroadm-device/"
"roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
"node/ROADMC01/yang-ext:mount/org-openroadm-device:"
"org-openroadm-device/"
"roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
def test_40_create_oc_service2(self):
url = ("{}/operations/org-openroadm-service:service-create"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {
"input": {
"sdnc-request-header": {
"operator-contact": "pw1234"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
def test_41_get_oc_service2(self):
url = ("{}/operational/org-openroadm-service:"
"service-list/services/service2"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
"node/ROADMA01/yang-ext:mount/org-openroadm-device:"
"org-openroadm-device/"
"roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-2"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
def test_44_delete_oc_service1(self):
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
}
}
}
- 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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Renderer service delete in progress',
def test_45_delete_oc_service2(self):
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
}
}
}
- 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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Renderer service delete in progress',
def test_46_get_no_oc_services(self):
print("start test")
url = ("{}/operational/org-openroadm-service:service-list"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
"network-topology/topology/topology-netconf"
"/node/ROADMA01/yang-ext:mount/org-openroadm-device:"
"org-openroadm-device/"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
def test_50_loop_create_oc_service(self):
url = ("{}/operational/org-openroadm-service:"
"service-list/services/service1"
- .format(self.restconf_baseurl))
- response = requests.request("GET", url, auth=('admin', 'admin'))
+ .format(test_utils.RESTCONF_BASE_URL))
+ response = requests.request("GET", url, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
if response.status_code != 404:
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
}
}
}
- headers = {'content-type': 'application/json'}
requests.request("POST", url, data=json.dumps(data),
- headers=headers,
- auth=('admin', 'admin')
+ headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD)
)
time.sleep(5)
self.test_44_delete_oc_service1()
def test_51_disconnect_XPDRA(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("XPDRA01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_52_disconnect_XPDRC(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("XPDRC01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_53_disconnect_ROADMA(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("ROADMA01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_54_disconnect_ROADMC(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("ROADMC01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
if __name__ == "__main__":
os.remove("transportpce_tests/gnpy.log")
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(cls):
# Mount the different topologies
def test_01_connect_clliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
topo_cllinet_file = "sample_configs/gnpy/clliNetwork.json"
if os.path.isfile(topo_cllinet_file):
with open(topo_cllinet_file, 'r') as clli_net:
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
def test_02_connect_openroadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
topo_ordnet_file = "sample_configs/gnpy/openroadmNetwork.json"
if os.path.isfile(topo_ordnet_file):
with open(topo_ordnet_file, 'r') as ord_net:
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
def test_03_connect_openroadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
topo_ordtopo_file = "sample_configs/gnpy/openroadmTopology.json"
if os.path.isfile(topo_ordtopo_file):
with open(topo_ordtopo_file, 'r') as ord_topo:
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
# Path computed by PCE is feasible according to Gnpy
def test_04_path_computation_FeasibleWithPCE(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
body = {
"input": {
"service-name": "service-1",
}
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(body), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['output']['configuration-response-common'][
# another one (low SNR)
def test_05_path_computation_FoundByPCE_NotFeasibleByGnpy(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
body = {
"input": {
"service-name": "service-2",
}
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(body), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['output']['configuration-response-common'][
# #PCE cannot find a path while GNPy finds a feasible one
def test_06_path_computation_NotFoundByPCE_FoundByGNPy(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
body = {
"input": {
"service-name": "service-3",
}
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(body), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['output']['configuration-response-common'][
# Not found path by PCE and GNPy cannot find another one
def test_07_path_computation_FoundByPCE_NotFeasibleByGnpy(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
body = {
"input": {
"service-name": "service-4",
}
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(body), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['output']['configuration-response-common'][
# Disconnect the different topologies
def test_08_disconnect_openroadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
def test_09_disconnect_openroadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
def test_10_disconnect_clliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
class TransportOlmTesting(unittest.TestCase):
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(cls):
time.sleep(1)
def test_01_xpdrA_device_connected(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDRA01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "XPDRA01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['xpdra']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("XPDRA01", 'xpdra')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_xpdrC_device_connected(self):
- url = ("{}/config/network-topology:"
- "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": test_utils.sims['xpdrc']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("XPDRC01", 'xpdrc')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_rdmA_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": test_utils.sims['roadma-full']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADMA01", 'roadma-full')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_04_rdmC_device_connected(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMC01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "ROADMC01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['roadmc-full']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADMC01", 'roadmc-full')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_05_connect_xprdA_to_roadmA(self):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
def test_06_connect_roadmA_to_xpdrA(self):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
def test_07_connect_xprdC_to_roadmC(self):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
def test_08_connect_roadmC_to_xpdrC(self):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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)
+ url = "{}/operations/transportpce-device-renderer:create-ots-oms".format(test_utils.RESTCONF_BASE_URL)
data = {
"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'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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',
res["output"]["result"])
def test_10_create_OTS_ROADMC(self):
- url = "{}/operations/transportpce-device-renderer:create-ots-oms".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:create-ots-oms".format(test_utils.RESTCONF_BASE_URL)
data = {
"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'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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',
res["output"]["result"])
def test_11_get_PM_ROADMA(self):
- url = "{}/operations/transportpce-olm:get-pm".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:get-pm".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"node-id": "ROADMA01",
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn({
}, res["output"]["measurements"])
def test_12_get_PM_ROADMC(self):
- url = "{}/operations/transportpce-olm:get-pm".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:get-pm".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"node-id": "ROADMC01",
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn({
}, res["output"]["measurements"])
def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
- url = "{}/operations/transportpce-olm:calculate-spanloss-base".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:calculate-spanloss-base".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"src-type": "link",
"link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success',
time.sleep(5)
def test_14_calculate_span_loss_base_all(self):
- url = "{}/operations/transportpce-olm:calculate-spanloss-base".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:calculate-spanloss-base".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"src-type": "all"
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success',
def test_15_get_OTS_DEG1_TTP_TXRX_ROADMA(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/interface/OTS-DEG1-TTP-TXRX/"
- "org-openroadm-optical-transport-interfaces:ots".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ "org-openroadm-optical-transport-interfaces:ots".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(5.7, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit'])
def test_16_get_OTS_DEG2_TTP_TXRX_ROADMC(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/ROADMC01/yang-ext:mount/org-openroadm-device:org-openroadm-device/interface/OTS-DEG2-TTP-TXRX/"
- "org-openroadm-optical-transport-interfaces:ots".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ "org-openroadm-optical-transport-interfaces:ots".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(15.1, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit'])
self.assertEqual(5.7, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive'])
def test_17_servicePath_create_AToZ(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
]
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
time.sleep(10)
def test_18_servicePath_create_ZToA(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
]
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
time.sleep(10)
def test_19_service_power_setup_XPDRA_XPDRC(self):
- url = "{}/operations/transportpce-olm:service-power-setup".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:service-power-setup".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
]
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success', res["output"]["result"])
def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/XPDRA01/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/interface/XPDR1-NETWORK1-1/"
- "org-openroadm-optical-channel-interfaces:och".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ "org-openroadm-optical-channel-interfaces:och".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(0, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
def test_21_get_roadmconnection_ROADMA(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADMA01/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/roadm-connections/"
- "SRG1-PP1-TXRX-DEG1-TTP-TXRX-1".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ "SRG1-PP1-TXRX-DEG1-TTP-TXRX-1".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
def test_22_get_roadmconnection_ROADMC(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADMC01/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/roadm-connections/"
- "DEG2-TTP-TXRX-SRG1-PP1-TXRX-1".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ "DEG2-TTP-TXRX-SRG1-PP1-TXRX-1".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("power", res['roadm-connections'][0]['opticalControlMode'])
def test_23_service_power_setup_XPDRC_XPDRA(self):
- url = "{}/operations/transportpce-olm:service-power-setup".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:service-power-setup".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
]
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success', res["output"]["result"])
def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/XPDRC01/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/interface/XPDR1-NETWORK1-1/"
- "org-openroadm-optical-channel-interfaces:och".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ "org-openroadm-optical-channel-interfaces:och".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(0, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
def test_25_get_roadmconnection_ROADMC(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADMC01/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/roadm-connections/"
- "SRG1-PP1-TXRX-DEG2-TTP-TXRX-1".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ "SRG1-PP1-TXRX-DEG2-TTP-TXRX-1".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
self.assertEqual(2, res['roadm-connections'][0]['target-output-power'])
def test_26_service_power_turndown_XPDRA_XPDRC(self):
- url = "{}/operations/transportpce-olm:service-power-turndown".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:service-power-turndown".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
]
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success', res["output"]["result"])
def test_27_get_roadmconnection_ROADMA(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADMA01/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/roadm-connections/"
- "SRG1-PP1-TXRX-DEG1-TTP-TXRX-1".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ "SRG1-PP1-TXRX-DEG1-TTP-TXRX-1".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
def test_28_get_roadmconnection_ROADMC(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADMC01/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/roadm-connections/"
- "DEG2-TTP-TXRX-SRG1-PP1-TXRX-1".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ "DEG2-TTP-TXRX-SRG1-PP1-TXRX-1".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
def test_29_servicePath_delete_AToZ(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
]
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
time.sleep(10)
def test_30_servicePath_delete_ZToA(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
]
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
"""to test case where SRG where the xpdr is connected to has no optical range data"""
def test_31_connect_xprdA_to_roadmA(self):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
def test_32_connect_roadmA_to_xpdrA(self):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
def test_33_servicePath_create_AToZ(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test2",
]
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/XPDRA01/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/interface/XPDR1-NETWORK2-2/"
- "org-openroadm-optical-channel-interfaces:och".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ "org-openroadm-optical-channel-interfaces:och".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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(2, res['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
def test_35_servicePath_delete_AToZ(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
]
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
time.sleep(10)
def test_36_xpdrA_device_disconnected(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("XPDRA01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_37_xpdrC_device_disconnected(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("XPDRC01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_38_calculate_span_loss_current(self):
- url = "{}/operations/transportpce-olm:calculate-spanloss-current".format(self.restconf_baseurl)
- headers = {'content-type': 'application/json'}
+ url = "{}/operations/transportpce-olm:calculate-spanloss-current".format(test_utils.RESTCONF_BASE_URL)
response = requests.request(
- "POST", url, headers=headers, auth=('admin', 'admin'))
+ "POST", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success',
time.sleep(5)
def test_39_rdmA_device_disconnected(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("ROADMA01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_40_rdmC_device_disconnected(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("ROADMC01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
if __name__ == "__main__":
cls.complex_topo_uni_dir_data = topo_uni_dir_complex.read()
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(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(test_utils.RESTCONF_BASE_URL))
body = self.simple_topo_bi_dir_data
- headers = {'content-type': 'application/xml',
- "Accept": "application/xml"}
response = requests.request(
- "PUT", url, data=body, headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=body, headers=test_utils.TYPE_APPLICATION_XML,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
# Get existing nodeId
def test_02_get_nodeId(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
# 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))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
# Path Computation success
def test_04_path_computation_xpdr_bi(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
body = {"input": {
"service-name": "service-1",
"resource-reserve": "true",
}
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(body), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
# Path Computation success
def test_05_path_computation_rdm_bi(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
body = {"input": {
"service-name": "service-1",
"resource-reserve": "true",
}
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(body), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
# Delete topology
def test_06_delete_simple_topology_bi(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/xml',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "DELETE", url, headers=headers, auth=('admin', 'admin'))
+ "DELETE", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
# 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))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, 404)
time.sleep(1)
# 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(test_utils.RESTCONF_BASE_URL))
body = self.simple_topo_uni_dir_data
- headers = {'content-type': 'application/xml',
- "Accept": "application/xml"}
response = requests.request(
- "PUT", url, data=body, headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=body, headers=test_utils.TYPE_APPLICATION_XML,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, 201)
time.sleep(2)
# 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))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
# 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))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
# Path Computation success
def test_11_path_computation_xpdr_uni(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
body = {"input": {
"service-name": "service-1",
"resource-reserve": "true",
}
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(body), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
# Path Computation success
def test_12_path_computation_rdm_uni(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
body = {"input": {
"service-name": "service1",
"resource-reserve": "true",
"pce-metric": "hop-count"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(body), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
# Delete topology
def test_13_delete_simple_topology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/xml',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "DELETE", url, headers=headers, auth=('admin', 'admin'))
+ "DELETE", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
# 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))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, 404)
time.sleep(1)
# Load complex topology
def test_15_load_complex_topology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
body = self.complex_topo_uni_dir_data
- headers = {'content-type': 'application/xml',
- "Accept": "application/json"}
response = requests.request(
- "PUT", url, data=body, headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=body, headers=test_utils.TYPE_APPLICATION_XML,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, 201)
time.sleep(2)
# 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))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
# Test failed path computation
def test_17_fail_path_computation(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
body = {"input": {
"service-handler-header": {
"request-id": "request-1"
}
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(body), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Service Name is not set',
# Test1 success path computation
def test_18_success1_path_computation(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
body = {"input": {
"service-name": "service1",
"resource-reserve": "true",
"locally-protected-links": "true"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(body), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
# 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(test_utils.RESTCONF_BASE_URL))
body = {"input": {
"service-name": "service 1",
"resource-reserve": "true",
"pce-metric": "hop-count"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(body), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
# 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(test_utils.RESTCONF_BASE_URL))
body = {"input": {
"service-name": "service 1",
"resource-reserve": "true",
"pce-metric": "hop-count"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(body), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
# Path computation before deleting oms-attribute of the link :openroadm1-3 to openroadm1-2
def test_21_path_computation_before_oms_attribute_deletion(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
body = {"input": {
"service-name": "service 1",
"resource-reserve": "true",
"pce-metric": "hop-count"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(body), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
def test_22_delete_oms_attribute_in_openroadm13toopenroadm12_link(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"
"OpenROADM-1-3-DEG2-to-OpenROADM-1-2-DEG2/org-openroadm-network-topology:OMS-attributes/span"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/xml',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "DELETE", url, headers=headers, auth=('admin', 'admin'))
+ "DELETE", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
# Path computation after deleting oms-attribute of the link :openroadm1-3 to openroadm1-2
def test_23_path_computation_after_oms_attribute_deletion(self):
url = ("{}/operations/transportpce-pce:path-computation-request"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
body = {"input": {
"service-name": "service 1",
"resource-reserve": "true",
"pce-metric": "hop-count"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(body), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Path is calculated',
# Delete complex topology
def test_24_delete_complex_topology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/xml',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "DELETE", url, headers=headers, auth=('admin', 'admin'))
+ "DELETE", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
# Test deleted complex topology
def test_25_test_topology_complex_deleted(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPONDER-3-2"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, 404)
time.sleep(1)
class TransportPCEPortMappingTesting(unittest.TestCase):
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(cls):
# def test_01_restconfAPI(self):
# url = ("{}/operational/network-topology:network-topology/topology/"
-# "topology-netconf/node/controller-config".format(self.restconf_baseurl))
-# headers = {'content-type': 'application/json'}
-# response = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
+# "topology-netconf/node/controller-config".format(test_utils.RESTCONF_BASE_URL))
+# response = requests.request("GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
# self.assertEqual(response.status_code, requests.codes.ok)
# res = response.json()
# self.assertEqual(res['node'] [0] ['netconf-node-topology:connection-status'],
# 'connected')
# def test_02_restconfAPI(self):
-# url = ("{}/config/transportpce-portmapping:network/nodes/controller-config".format(self.restconf_baseurl))
-# headers = {'content-type': 'application/json'}
+# url = ("{}/config/transportpce-portmapping:network/nodes/controller-config".format(test_utils.RESTCONF_BASE_URL))
# response = requests.request(
-# "GET", url, headers=headers, auth=('admin', 'admin'))
+# "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
# self.assertEqual(response.status_code, requests.codes.not_found)
# res = response.json()
# self.assertIn(
# "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))
- data = {"node": [{
- "node-id": "ROADMA01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['roadma']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ def test_01_rdm_device_connection(self):
+ response = test_utils.mount_device("ROADMA01", 'roadma')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_rdm_device_connected(self):
url = ("{}/operational/network-topology:"
"network-topology/topology/topology-netconf/node/ROADMA01"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
def test_03_rdm_portmapping_info(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/ROADMA01/node-info"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
def test_04_rdm_portmapping_DEG1_TTP_TXRX(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/ROADMA01/mapping/DEG1-TTP-TXRX"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_05_rdm_portmapping_SRG1_PP7_TXRX(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/ROADMA01/mapping/SRG1-PP7-TXRX"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_06_rdm_portmapping_SRG3_PP1_TXRX(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/ROADMA01/mapping/SRG3-PP1-TXRX"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
'logical-connection-point': 'SRG3-PP1-TXRX', 'port-direction': 'bidirectional'},
res['mapping'])
- def test_07_xpdr_device_connected(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDRA01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "XPDRA01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['xpdra']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ def test_07_xpdr_device_connection(self):
+ response = test_utils.mount_device("XPDRA01", 'xpdra')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_08_xpdr_device_connected(self):
url = ("{}/operational/network-topology:"
"network-topology/topology/topology-netconf/node/XPDRA01"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
def test_09_xpdr_portmapping_info(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/XPDRA01/node-info"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
def test_10_xpdr_portmapping_NETWORK1(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/XPDRA01/mapping/XPDR1-NETWORK1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_11_xpdr_portmapping_NETWORK2(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/XPDRA01/mapping/XPDR1-NETWORK2"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_12_xpdr_portmapping_CLIENT1(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/XPDRA01/mapping/XPDR1-CLIENT1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_13_xpdr_portmapping_CLIENT2(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/XPDRA01/mapping/XPDR1-CLIENT2"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_14_xpdr_portmapping_CLIENT3(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/XPDRA01/mapping/XPDR1-CLIENT3"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_15_xpdr_portmapping_CLIENT4(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/XPDRA01/mapping/XPDR1-CLIENT4"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
'port-qual': 'xpdr-client', 'lcp-hash-val': '64b8effe7ba72211420bf267d0ca1ae0'},
res['mapping'])
- def test_16_xpdr_device_disconnected(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(20)
+ def test_16_xpdr_device_disconnection(self):
+ response = test_utils.unmount_device("XPDRA01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_17_xpdr_device_disconnected(self):
url = ("{}/operational/network-topology:network-topology/topology/"
- "topology-netconf/node/XPDRA01".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ "topology-netconf/node/XPDRA01".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
"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):
- url = ("{}/config/transportpce-portmapping:network/nodes/XPDRA01".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ def test_18_xpdr_device_not_connected(self):
+ url = ("{}/config/transportpce-portmapping:network/nodes/XPDRA01".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
"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):
- url = ("{}/config/network-topology: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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(20)
+ def test_19_rdm_device_disconnection(self):
+ response = test_utils.unmount_device("ROADMA01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_20_rdm_device_disconnected(self):
url = ("{}/operational/network-topology:network-topology/topology/topology-netconf/node/ROADMA01"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
"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):
- url = ("{}/config/transportpce-portmapping:network/nodes/ROADMA01".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ def test_21_rdm_device_not_connected(self):
+ url = ("{}/config/transportpce-portmapping:network/nodes/ROADMA01".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
class TransportPCERendererTesting(unittest.TestCase):
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(cls):
time.sleep(10)
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": test_utils.sims['roadma']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADMA01", 'roadma')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_xpdr_device_connected(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDRA01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "XPDRA01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['xpdra']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("XPDRA01", 'xpdra')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_rdm_portmapping(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/ROADMA01"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_04_xpdr_portmapping(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/XPDRA01"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
res['nodes'][0]['mapping'])
def test_05_service_path_create(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {"renderer:input": {
"renderer:service-name": "service_test",
"renderer:wave-number": "7",
{"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'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes: ROADMA01', res["output"]["result"])
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))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
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))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"roadm-connections/SRG1-PP7-TXRX-DEG1-TTP-TXRX-7"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
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))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
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))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
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))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the 2 following statements replace self.assertDictContainsSubset deprecated in python 3.2
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/XPDRA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-CLIENT1-ETHERNET"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
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))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {"renderer:input": {
"renderer:service-name": "service_test",
"renderer:wave-number": "7",
{"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'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(response.json(), {
'output': {'result': 'Request processed', 'success': True}})
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))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
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))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"roadm-connections/SRG1-PP7-TXRX-DEG1-TTP-TXRX-7"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
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))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
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))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
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))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/XPDRA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-CLIENT1-ETHERNET"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
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))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual('not-reserved-available', res["circuit-packs"][0]['equipment-state'])
def test_23_rdm_device_disconnected(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(20)
+ response = test_utils.unmount_device("ROADMA01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_24_xpdr_device_disconnected(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(20)
+ response = test_utils.unmount_device("XPDRA01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
if __name__ == "__main__":
class TransportPCEtesting(unittest.TestCase):
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(cls):
# Connect the ROADMA
def test_01_connect_rdm(self):
- # Config ROADMA
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMA01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "ROADMA01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['roadma']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADMA01", 'roadma')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
# 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))
- headers = {'content-type': 'application/json'}
- responseTopo = requests.request("GET", urlTopo, headers=headers, auth=('admin', 'admin'))
+ .format(test_utils.RESTCONF_BASE_URL))
+ responseTopo = requests.request("GET", urlTopo, headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
resTopo = responseTopo.json()
nbNode = len(resTopo['network'][0]['node'])
nbMapCumul = 0
nodeId = resTopo['network'][0]['node'][i]['node-id']
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'))
+ urlMapListFull = urlMapList.format(test_utils.RESTCONF_BASE_URL)
+ responseMapList = requests.request("GET", urlMapListFull, headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
resMapList = responseMapList.json()
nbMappings = len(resMapList['nodes'][0]['mapping']) - nbMapCumul
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'))
+ urlMapFull = urlMap.format(test_utils.RESTCONF_BASE_URL)
+ responseMap = requests.request("GET", urlMapFull, headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(responseMap.status_code, requests.codes.ok)
if responseMap.status_code == requests.codes.ok:
nbMapCurrent += 1
# Disconnect the ROADMA
def test_03_disconnect_rdm(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMA01"
- .format(self.restconf_baseurl))
- data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("ROADMA01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
# #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": test_utils.sims['xpdra']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("XPDRA01", 'xpdra')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
# #Verify the termination points related to XPDR
def test_05_compareOpenroadmTopologyPortMapping_xpdr(self):
# Disconnect the XPDRA
def test_06_disconnect_device(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDRA01"
- .format(self.restconf_baseurl))
- data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("XPDRA01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
if __name__ == "__main__":
class TransportPCETopologyTesting(unittest.TestCase):
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(cls):
time.sleep(5)
def test_01_connect_ROADMA(self):
- # Config ROADMA
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMA01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "ROADMA01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['roadma']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADMA01", 'roadma')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
def test_03_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADMA01')
def test_04_getLinks_OpenroadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
def test_05_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
+ .format(test_utils.RESTCONF_BASE_URL))
+ response = requests.request("GET", url, headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(len(listNode), 0)
def test_06_connect_XPDRA(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDRA01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "XPDRA01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['xpdra']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(30)
+ response = test_utils.mount_device("XPDRA01", 'xpdra')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_07_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
+ .format(test_utils.RESTCONF_BASE_URL))
+ response = requests.request("GET", url, headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
def test_08_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_09_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
def test_10_connect_tail_xpdr_rdm(self):
# Connect the tail: XPDRA to ROADMA
url = ("{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"networkutils:input": {
"networkutils:links-input": {
"networkutils:xpdr-node": "XPDRA01",
}
}
}
- 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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"networkutils:input": {
"networkutils:links-input": {
"networkutils:xpdr-node": "XPDRA01",
}
}
}
- 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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
self.assertEqual(len(XPDR_OUT), 0)
def test_13_connect_ROADMC(self):
- # Config ROADMC
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMC01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "ROADMC01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['roadmc']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADMC01", 'roadmc')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_14_omsAttributes_ROADMA_ROADMC(self):
# Config ROADMA01-ROADMC01 oms-attributes
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
def test_15_omsAttributes_ROADMC_ROADMA(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
def test_16_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_17_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_18_getROADMLinkOpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
def test_20_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(len(listNode), 0)
def test_21_connect_ROADMB(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMB01"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "ROADMB01",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['roadmb']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADMB01", 'roadmb')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_22_omsAttributes_ROADMA_ROADMB(self):
# Config ROADMA01-ROADMB01 oms-attributes
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
def test_23_omsAttributes_ROADMB_ROADMA(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADMB01-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
def test_24_omsAttributes_ROADMB_ROADMC(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADMB01-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
def test_25_omsAttributes_ROADMC_ROADMB(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
def test_26_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_27_verifyDegree(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
def test_28_verifyOppositeLinkTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
oppLink_id = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
# Find the opposite link
url_oppLink = "{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"+oppLink_id
- url = (url_oppLink.format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response_oppLink = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
+ url = (url_oppLink.format(test_utils.RESTCONF_BASE_URL))
+ response_oppLink = requests.request(
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response_oppLink.status_code, requests.codes.ok)
res_oppLink = response_oppLink.json()
self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbLink = len(res['network'][0]['ietf-network-topology:link'])
def test_30_disconnect_ROADMB(self):
# Delete in the topology-netconf
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMB01"
- .format(self.restconf_baseurl))
- data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("ROADMB01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
# Delete in the clli-network
url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeB"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
def test_31_disconnect_ROADMC(self):
- # Delete in the topology-netconf
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMC01"
- .format(self.restconf_baseurl))
- data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("ROADMC01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
# Delete in the clli-network
url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeC"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
def test_32_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
def test_33_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_34_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'], 'NodeC')
def test_35_disconnect_XPDRA(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDRA01"
- .format(self.restconf_baseurl))
- data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("XPDRA01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_36_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_37_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_38_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
# Link-1
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
# Link-2
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
def test_40_getLinks_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbLink = len(res['network'][0]['ietf-network-topology:link'])
['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
def test_41_disconnect_ROADMA(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADMA01"
- .format(self.restconf_baseurl))
- data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("ROADMA01")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
# Delete in the clli-network
url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeA"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
def test_42_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn('node', res['network'][0])
def test_43_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn('node', res['network'][0])
def test_44_check_roadm2roadm_link_persistence(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbLink = len(res['network'][0]['ietf-network-topology:link'])
class TransportPCEFulltesting(unittest.TestCase):
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
WAITING = 20 # nominal value is 300
@classmethod
def setUp(self): # instruction executed before each test method
print("execution of {}".format(self.id().split(".")[-1]))
-# 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))
- 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": test_utils.sims['xpdra']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("XPDR-A1", 'xpdra')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_connect_xpdrC(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-C1"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "XPDR-C1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['xpdrc']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("XPDR-C1", 'xpdrc')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_connect_rdmA(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": test_utils.sims['roadma']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADM-A1", 'roadma')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_04_connect_rdmC(self):
- url = ("{}/config/network-topology:"
- "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": test_utils.sims['roadmc']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADM-C1", 'roadmc')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
time.sleep(2)
def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
time.sleep(2)
def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
time.sleep(2)
def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"auto-spanloss": "true",
"spanloss-base": 11.4,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
def test_10_add_omsAttributes_ROADMC_ROADMA(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"auto-spanloss": "true",
"spanloss-base": 11.4,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
# test service-create for Eth service from xpdr to xpdr
def test_11_create_eth_service1(self):
url = ("{}/operations/org-openroadm-service:service-create"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
"operator-contact": "pw1234"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
def test_12_get_eth_service1(self):
url = ("{}/operational/org-openroadm-service:service-list/services/service1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/ROADM-C1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
def test_15_check_topo_XPDRA(self):
url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDR-A1-XPDR1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
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(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn({u'index': 1},
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(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn({u'index': 1},
time.sleep(3)
def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
time.sleep(2)
def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
time.sleep(2)
def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
time.sleep(2)
def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
}
}
}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
"operator-contact": "pw1234"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
def test_23_get_eth_service2(self):
url = ("{}/operational/org-openroadm-service:service-list/services/service2"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"roadm-connections/DEG2-TTP-TXRX-SRG1-PP2-TXRX-2"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
def test_25_check_topo_XPDRA(self):
url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDR-A1-XPDR1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
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(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn({u'index': 1}, res['node'][0]
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(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn({u'index': 1}, res['node'][0]
# 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(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
"operator-contact": "pw1234"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
# 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(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
}
}
}
- 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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Service \'service3\' does not exist in datastore',
def test_30_delete_eth_service1(self):
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
}
}
}
- 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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Renderer service delete in progress',
def test_31_delete_eth_service2(self):
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
}
}
}
- 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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Renderer service delete in progress',
def test_32_check_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(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, auth=('admin', 'admin'))
+ "GET", url, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
liste_tp = res['node'][0]['ietf-network-topology:termination-point']
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(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn({u'index': 1}, res['node'][0]
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(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url1, auth=('admin', 'admin'))
+ "GET", url1, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn({u'index': 1}, res['node'][0]
# 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(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
"operator-contact": "pw1234"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
def test_37_get_oc_service1(self):
url = ("{}/operational/org-openroadm-service:service-list/services/service1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/ROADM-C1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
def test_40_create_oc_service2(self):
url = ("{}/operations/org-openroadm-service:service-create"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
"operator-contact": "pw1234"
}
}
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
response = requests.request(
- "POST", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('PCE calculation in progress',
def test_41_get_oc_service2(self):
url = ("{}/operational/org-openroadm-service:service-list/services/service2"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"roadm-connections/SRG1-PP2-TXRX-DEG2-TTP-TXRX-2"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
def test_44_delete_oc_service1(self):
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
}
}
}
- 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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Renderer service delete in progress',
def test_45_delete_oc_service2(self):
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
}
}
}
- 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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Renderer service delete in progress',
def test_46_get_no_oc_services(self):
print("start test")
url = ("{}/operational/org-openroadm-service:service-list"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
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))
- headers = {'content-type': 'application/json',
- "Accept": "application/json"}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
def test_50_loop_create_oc_service(self):
url = ("{}/operational/org-openroadm-service:service-list/services/service1"
- .format(self.restconf_baseurl))
- response = requests.request("GET", url, auth=('admin', 'admin'))
+ .format(test_utils.RESTCONF_BASE_URL))
+ response = requests.request("GET", url, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
if response.status_code != 404:
url = ("{}/operations/org-openroadm-service:service-delete"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"input": {
"sdnc-request-header": {
"request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
}
}
}
- headers = {'content-type': 'application/json'}
- requests.request("POST", url, data=json.dumps(data), headers=headers, auth=('admin', 'admin'))
+ requests.request("POST", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
time.sleep(5)
for i in range(1, 6):
self.test_44_delete_oc_service1()
def test_51_disconnect_XPDRA(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("XPDR-A1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_52_disconnect_XPDRC(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("XPDR-C1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_53_disconnect_ROADMA(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("ROADM-A1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_54_disconnect_ROADMC(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("ROADM-C1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
if __name__ == "__main__":
class TransportOlmTesting(unittest.TestCase):
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(cls):
time.sleep(1)
def test_01_xpdrA_device_connected(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": test_utils.sims['xpdra']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("XPDR-A1", 'xpdra')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_xpdrC_device_connected(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-C1"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "XPDR-C1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['xpdrc']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("XPDR-C1", 'xpdrc')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_rdmA_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": test_utils.sims['roadma']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADM-A1", 'roadma')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_04_rdmC_device_connected(self):
- url = ("{}/config/network-topology:"
- "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": test_utils.sims['roadmc']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADM-C1", 'roadmc')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_05_connect_xprdA_to_roadmA(self):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
def test_06_connect_roadmA_to_xpdrA(self):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
def test_07_connect_xprdC_to_roadmC(self):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
def test_08_connect_roadmC_to_xpdrC(self):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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)
+ url = "{}/operations/transportpce-device-renderer:create-ots-oms".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"node-id": "ROADM-A1",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
time.sleep(10)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
res["output"]["result"])
def test_10_create_OTS_ROADMC(self):
- url = "{}/operations/transportpce-device-renderer:create-ots-oms".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:create-ots-oms".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"node-id": "ROADM-C1",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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',
res["output"]["result"])
def test_11_get_PM_ROADMA(self):
- url = "{}/operations/transportpce-olm:get-pm".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:get-pm".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"node-id": "ROADM-A1",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn({
}, res["output"]["measurements"])
def test_12_get_PM_ROADMC(self):
- url = "{}/operations/transportpce-olm:get-pm".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:get-pm".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"node-id": "ROADM-C1",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn({
}, res["output"]["measurements"])
def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
- url = "{}/operations/transportpce-olm:calculate-spanloss-base".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:calculate-spanloss-base".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"src-type": "link",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success',
time.sleep(5)
def test_14_calculate_span_loss_base_all(self):
- url = "{}/operations/transportpce-olm:calculate-spanloss-base".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:calculate-spanloss-base".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"src-type": "all"
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success',
def test_15_get_OTS_DEG2_TTP_TXRX_ROADMA(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/interface/OTS-DEG2-TTP-TXRX/"
- "org-openroadm-optical-transport-interfaces:ots".format(self.restconf_baseurl))
+ "org-openroadm-optical-transport-interfaces:ots".format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(17.6, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit'])
def test_16_get_OTS_DEG1_TTP_TXRX_ROADMC(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/ROADM-C1/yang-ext:mount/org-openroadm-device:org-openroadm-device/interface/OTS-DEG1-TTP-TXRX/"
- "org-openroadm-optical-transport-interfaces:ots".format(self.restconf_baseurl))
+ "org-openroadm-optical-transport-interfaces:ots".format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(25.7, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit'])
self.assertEqual(17.6, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive'])
def test_17_servicePath_create_AToZ(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
time.sleep(10)
def test_18_servicePath_create_ZToA(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
time.sleep(10)
def test_19_service_power_setup_XPDRA_XPDRC(self):
- url = "{}/operations/transportpce-olm:service-power-setup".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:service-power-setup".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success', res["output"]["result"])
def test_20_get_interface_XPDRA_XPDR1_NETWORK1(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-1/"
- "org-openroadm-optical-channel-interfaces:och".format(self.restconf_baseurl))
+ "org-openroadm-optical-channel-interfaces:och".format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(-5, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
def test_21_get_roadmconnection_ROADMA(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADM-A1/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/roadm-connections/"
- "SRG1-PP1-TXRX-DEG2-TTP-TXRX-1".format(self.restconf_baseurl))
+ "SRG1-PP1-TXRX-DEG2-TTP-TXRX-1".format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
def test_22_get_roadmconnection_ROADMC(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADM-C1/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/roadm-connections/"
- "DEG1-TTP-TXRX-SRG1-PP1-TXRX-1".format(self.restconf_baseurl))
+ "DEG1-TTP-TXRX-SRG1-PP1-TXRX-1".format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("power", res['roadm-connections'][0]['opticalControlMode'])
def test_23_service_power_setup_XPDRC_XPDRA(self):
- url = "{}/operations/transportpce-olm:service-power-setup".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:service-power-setup".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success', res["output"]["result"])
def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/XPDR-C1/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/interface/XPDR1-NETWORK1-1/"
- "org-openroadm-optical-channel-interfaces:och".format(self.restconf_baseurl))
+ "org-openroadm-optical-channel-interfaces:och".format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(-5, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
def test_25_get_roadmconnection_ROADMC(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADM-C1/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/roadm-connections/"
- "SRG1-PP1-TXRX-DEG1-TTP-TXRX-1".format(self.restconf_baseurl))
+ "SRG1-PP1-TXRX-DEG1-TTP-TXRX-1".format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
self.assertEqual(2.0, res['roadm-connections'][0]['target-output-power'])
def test_26_service_power_turndown_XPDRA_XPDRC(self):
- url = "{}/operations/transportpce-olm:service-power-turndown".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:service-power-turndown".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success', res["output"]["result"])
def test_27_get_roadmconnection_ROADMA(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADM-A1/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/roadm-connections/"
- "SRG1-PP1-TXRX-DEG2-TTP-TXRX-1".format(self.restconf_baseurl))
+ "SRG1-PP1-TXRX-DEG2-TTP-TXRX-1".format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
def test_28_get_roadmconnection_ROADMC(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADM-C1/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/roadm-connections/"
- "DEG1-TTP-TXRX-SRG1-PP1-TXRX-1".format(self.restconf_baseurl))
+ "DEG1-TTP-TXRX-SRG1-PP1-TXRX-1".format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
def test_29_servicePath_delete_AToZ(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
time.sleep(10)
def test_30_servicePath_delete_ZToA(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
"""to test case where SRG where the xpdr is connected to has no optical range data"""
def test_31_connect_xprdA_to_roadmA(self):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
def test_32_connect_roadmA_to_xpdrA(self):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(test_utils.RESTCONF_BASE_URL)
data = {
"networkutils:input": {
"networkutils:links-input": {
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
def test_33_servicePath_create_AToZ(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test2",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/XPDR-A1/yang-ext:mount/"
"org-openroadm-device:org-openroadm-device/interface/XPDR1-NETWORK2-2/"
- "org-openroadm-optical-channel-interfaces:och".format(self.restconf_baseurl))
+ "org-openroadm-optical-channel-interfaces:och".format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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(2, res['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
def test_35_servicePath_delete_AToZ(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {
"input": {
"service-name": "test",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
time.sleep(10)
def test_36_xpdrA_device_disconnected(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("XPDR-A1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_37_xpdrC_device_disconnected(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("XPDR-C1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_38_calculate_span_loss_current(self):
- url = "{}/operations/transportpce-olm:calculate-spanloss-current".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-olm:calculate-spanloss-current".format(test_utils.RESTCONF_BASE_URL)
headers = {'content-type': 'application/json'}
response = requests.request(
- "POST", url, headers=headers, auth=('admin', 'admin'))
+ "POST", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success',
time.sleep(5)
def test_39_rdmA_device_disconnected(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("ROADM-A1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_40_rdmC_device_disconnected(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(10)
+ response = test_utils.unmount_device("ROADM-C1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
if __name__ == "__main__":
class TransportPCEtesting(unittest.TestCase):
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(cls):
time.sleep(5)
def test_01_connect_SPDR_SA1(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/SPDR-SA1"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "SPDR-SA1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['spdrav2']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
+ response = test_utils.mount_device("SPDR-SA1", 'spdrav2')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
time.sleep(10)
+
url = ("{}/operational/network-topology:"
"network-topology/topology/topology-netconf/node/SPDR-SA1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
def test_02_get_portmapping_CLIENT1(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/SPDR-SA1/mapping/XPDR1-CLIENT1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_03_get_portmapping_NETWORK1(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/SPDR-SA1/mapping/XPDR1-NETWORK1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
res['mapping'])
def test_04_service_path_create_OCH_OTU4(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {"renderer:input": {
"service-name": "service_ODU4",
"wave-number": "1",
"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'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
time.sleep(3)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
def test_05_get_portmapping_NETWORK1(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/SPDR-SA1/mapping/XPDR1-NETWORK1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-NETWORK1-1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-NETWORK1-OTU"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
input_dict = {'name': 'XPDR1-NETWORK1-OTU',
res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
def test_08_otn_service_path_create_ODU4(self):
- url = "{}/operations/transportpce-device-renderer:otn-service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:otn-service-path".format(test_utils.RESTCONF_BASE_URL)
data = {"renderer:input": {
"service-name": "service_ODU4",
"operation": "create",
"nodes": [
{"node-id": "SPDR-SA1",
"network-tp": "XPDR1-NETWORK1"}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
time.sleep(3)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
def test_09_get_portmapping_NETWORK1(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/SPDR-SA1/mapping/XPDR1-NETWORK1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-NETWORK1-ODU4"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4', 'administrative-state': 'inService',
res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
def test_11_otn_service_path_create_10GE(self):
- url = "{}/operations/transportpce-device-renderer:otn-service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:otn-service-path".format(test_utils.RESTCONF_BASE_URL)
data = {"renderer:input": {
"service-name": "service1",
"operation": "create",
{"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'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
time.sleep(3)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-CLIENT1-ETHERNET10G"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-CLIENT1-ODU2e-service1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-NETWORK1-ODU2e-service1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-service1', 'administrative-state': 'inService',
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"odu-connection/XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
input_dict_1 = {
res['odu-connection'][0]['source'])
def test_16_otn_service_path_delete_10GE(self):
- url = "{}/operations/transportpce-device-renderer:otn-service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:otn-service-path".format(test_utils.RESTCONF_BASE_URL)
data = {"renderer:input": {
"service-name": "service1",
"operation": "delete",
{"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'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
time.sleep(3)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"odu-connection/XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
def test_18_check_no_interface_ODU2E_NETWORK(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-NETWORK1-ODU2e-service1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
def test_19_check_no_interface_ODU2E_CLIENT(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-CLIENT1-ODU2e-service1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
def test_20_check_no_interface_10GE_CLIENT(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-CLIENT1-ETHERNET10G"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
def test_21_otn_service_path_delete_ODU4(self):
- url = "{}/operations/transportpce-device-renderer:otn-service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:otn-service-path".format(test_utils.RESTCONF_BASE_URL)
data = {"renderer:input": {
"service-name": "service_ODU4",
"operation": "delete",
"nodes": [
{"node-id": "SPDR-SA1",
"network-tp": "XPDR1-NETWORK1"}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
time.sleep(3)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-NETWORK1-ODU4"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
def test_23_service_path_delete_OCH_OTU4(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {"renderer:input": {
"service-name": "service_OTU4",
"wave-number": "1",
"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'))
+ headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
time.sleep(3)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-NETWORK1-OTU"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
def test_25_check_no_interface_OCH(self):
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-NETWORK1-1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
def test_26_disconnect_SPDR_SA1(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/SPDR-SA1"
- .format(self.restconf_baseurl))
- data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("SPDR-SA1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
if __name__ == "__main__":
class TransportPCEtesting(unittest.TestCase):
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(cls):
time.sleep(5)
def test_01_connect_SPDR_SA1(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/SPDR-SA1"
- .format(self.restconf_baseurl))
- data = {"node": [{
- "node-id": "SPDR-SA1",
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
- "netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": test_utils.sims['spdrav2']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
+ response = test_utils.mount_device("SPDR-SA1", 'spdrav2')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
time.sleep(10)
+
url = ("{}/operational/network-topology:"
"network-topology/topology/topology-netconf/node/SPDR-SA1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
def test_02_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
logging.info(res)
def test_03_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['network'][0]['node'][0]['node-id'], 'SPDR-SA1')
def test_04_getLinks_OpenroadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
def test_05_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
def test_06_getLinks_OtnTopology(self):
url = ("{}/config/ietf-network:networks/network/otn-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn('ietf-network-topology:link', res['network'][0])
def test_07_getNodes_OtnTopology(self):
url = ("{}/config/ietf-network:networks/network/otn-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
self.assertEqual(response.status_code, requests.codes.ok)
nbNode = len(res['network'][0]['node'])
self.assertEqual(len(listNode), 0)
def test_08_disconnect_SPDR_SA1(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/SPDR-SA1"
- .format(self.restconf_baseurl))
- data = {}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "DELETE", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("SPDR-SA1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_09_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_10_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn('node', res['network'][0])
def test_11_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
self.assertNotIn('node', res['network'][0])
def test_12_getNodes_OtnTopology(self):
url = ("{}/config/ietf-network:networks/network/otn-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
self.assertNotIn('node', res['network'][0])
class TransportPCEPortMappingTesting(unittest.TestCase):
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(cls):
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))
- 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": test_utils.sims['roadma']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ def test_01_rdm_device_connection(self):
+ response = test_utils.mount_device("ROADM-A1", 'roadma')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_rdm_device_connected(self):
url = ("{}/operational/network-topology:"
"network-topology/topology/topology-netconf/node/ROADM-A1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
def test_03_rdm_portmapping_info(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/ROADM-A1/node-info"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
def test_04_rdm_portmapping_DEG1_TTP_TXRX(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/ROADM-A1/mapping/DEG1-TTP-TXRX"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_05_rdm_portmapping_DEG2_TTP_TXRX_with_ots_oms(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/ROADM-A1/mapping/DEG2-TTP-TXRX"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_06_rdm_portmapping_SRG1_PP3_TXRX(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/ROADM-A1/mapping/SRG1-PP3-TXRX"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_07_rdm_portmapping_SRG3_PP1_TXRX(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/ROADM-A1/mapping/SRG3-PP1-TXRX"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
'logical-connection-point': 'SRG3-PP1-TXRX', 'port-direction': 'bidirectional'},
res['mapping'])
- def test_08_xpdr_device_connected(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": test_utils.sims['xpdra']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ def test_08_xpdr_device_connection(self):
+ response = test_utils.mount_device("XPDR-A1", 'xpdra')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_09_xpdr_device_connected(self):
url = ("{}/operational/network-topology:"
"network-topology/topology/topology-netconf/node/XPDR-A1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
def test_10_xpdr_portmapping_info(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/XPDR-A1/node-info"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(
def test_11_xpdr_portmapping_NETWORK1(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/XPDR-A1/mapping/XPDR1-NETWORK1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_12_xpdr_portmapping_NETWORK2(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/XPDR-A1/mapping/XPDR1-NETWORK2"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_13_xpdr_portmapping_CLIENT1(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/XPDR-A1/mapping/XPDR1-CLIENT1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_14_xpdr_portmapping_CLIENT2(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/XPDR-A1/mapping/XPDR1-CLIENT2"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
'lcp-hash-val': '3ed8ed1336784ac7c2f66c22f2f03db'},
res['mapping'])
- def test_15_xpdr_device_disconnected(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(20)
+ def test_15_xpdr_device_disconnection(self):
+ response = test_utils.unmount_device("XPDR-A1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_16_xpdr_device_disconnected(self):
url = ("{}/operational/network-topology:network-topology/topology/"
- "topology-netconf/node/XPDR-A1".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ "topology-netconf/node/XPDR-A1".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
"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):
- url = ("{}/config/transportpce-portmapping:network/nodes/XPDR-A1".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ def test_17_xpdr_device_not_connected(self):
+ url = ("{}/config/transportpce-portmapping:network/nodes/XPDR-A1".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
"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):
- url = ("{}/config/network-topology: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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(20)
+ def test_18_rdm_device_disconnection(self):
+ response = test_utils.unmount_device("ROADM-A1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_19_rdm_device_disconnected(self):
url = ("{}/operational/network-topology:network-topology/topology/topology-netconf/node/ROADM-A1"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
"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):
- url = ("{}/config/transportpce-portmapping:network/nodes/ROADM-A1".format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ def test_20_rdm_device_not_connected(self):
+ url = ("{}/config/transportpce-portmapping:network/nodes/ROADM-A1".format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
class TransportPCERendererTesting(unittest.TestCase):
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(cls):
print("all processes killed")
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": test_utils.sims['roadma']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertIn(response.status_code, [requests.codes.created,
- requests.codes.ok])
- # self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADM-A1", 'roadma')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_xpdr_device_connected(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": test_utils.sims['xpdra']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- # self.assertEqual(response.status_code, requests.codes.created)
- self.assertIn(response.status_code, [requests.codes.created,
- requests.codes.ok])
- time.sleep(20)
+ response = test_utils.mount_device("XPDR-A1", 'xpdra')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_03_rdm_portmapping(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/ROADM-A1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
def test_04_xpdr_portmapping(self):
url = ("{}/config/transportpce-portmapping:network/"
"nodes/XPDR-A1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
res['nodes'][0]['mapping'])
def test_05_service_path_create(self):
- url = "{}/operations/transportpce-device-renderer:service-path".format(self.restconf_baseurl)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {"renderer:input": {
"renderer:service-name": "service_test",
"renderer:wave-number": "7",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes: ROADM-A1', res["output"]["result"])
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"roadm-connections/SRG1-PP3-TXRX-DEG1-TTP-TXRX-7"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the 2 following statements replace self.assertDictContainsSubset deprecated in python 3.2
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-CLIENT1-ETHERNET"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('not-reserved-inuse', res['circuit-packs'][0]["equipment-state"])
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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)
+ url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
data = {"renderer:input": {
"renderer:service-name": "service_test",
"renderer:wave-number": "7",
headers = {'content-type': 'application/json'}
response = requests.request(
"POST", url, data=json.dumps(data),
- headers=headers, auth=('admin', 'admin'))
+ headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(response.json(), {
'output': {'result': 'Request processed', 'success': True}})
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"roadm-connections/SRG1-PP3-TXRX-DEG1-TTP-TXRX-7"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
"node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
"interface/XPDR1-CLIENT1-ETHERNET"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.not_found)
res = response.json()
self.assertIn(
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual('not-reserved-available', res["circuit-packs"][0]['equipment-state'])
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))
+ .format(test_utils.RESTCONF_BASE_URL))
headers = {'content-type': 'application/json'}
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual('not-reserved-available', res["circuit-packs"][0]['equipment-state'])
def test_29_rdm_device_disconnected(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(20)
+ response = test_utils.unmount_device("ROADM-A1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_30_xpdr_device_disconnected(self):
- url = ("{}/config/network-topology:"
- "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'))
- self.assertEqual(response.status_code, requests.codes.ok)
- time.sleep(20)
+ response = test_utils.unmount_device("XPDR-A1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
if __name__ == "__main__":
from common import test_utils
-RESTCONF_BASE_URL = "http://localhost:8181/restconf"
-
-CODE_SHOULD_BE_200 = 'Http status code should be 200'
-
-CODE_SHOULD_BE_201 = 'Http status code should be 201'
CREATED_SUCCESSFULLY = 'Result message should contain Xponder Roadm Link created successfully'
self.fail('Feature installation failed')
print("execution of {}".format(self.id().split(".")[-1]))
- # connect netconf devices
-
def test_00_connect_spdr_sa1(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/SPDR-SA1"
- .format(RESTCONF_BASE_URL))
- data = test_utils.generate_connect_data("SPDR-SA1", test_utils.sims['spdrav2']['port'])
- response = test_utils.put_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.created, CODE_SHOULD_BE_201) # pylint: disable=no-member
+ response = test_utils.mount_device("SPDR-SA1", 'spdrav2')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
time.sleep(10)
+ # TODO replace connect and disconnect timers with test_utils.wait_until_log_contains
def test_01_connect_xpdra(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-A1"
- .format(RESTCONF_BASE_URL))
- data = test_utils.generate_connect_data("XPDR-A1", test_utils.sims['xpdra']['port'])
- response = test_utils.put_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.created, CODE_SHOULD_BE_201) # pylint: disable=no-member
+ response = test_utils.mount_device("XPDR-A1", 'xpdra')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
time.sleep(10)
def test_02_connect_xpdrc(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-C1"
- .format(RESTCONF_BASE_URL))
- data = test_utils.generate_connect_data("XPDR-C1", test_utils.sims['xpdrc']['port'])
- response = test_utils.put_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.created, CODE_SHOULD_BE_201) # pylint: disable=no-member
+ response = test_utils.mount_device("XPDR-C1", 'xpdrc')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
time.sleep(10)
def test_03_connect_rdma(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-A1"
- .format(RESTCONF_BASE_URL))
- data = test_utils.generate_connect_data("ROADM-A1", test_utils.sims['roadma']['port'])
- response = test_utils.put_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.created, CODE_SHOULD_BE_201) # pylint: disable=no-member
+ response = test_utils.mount_device("ROADM-A1", 'roadma')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
time.sleep(20)
def test_04_connect_rdmc(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-C1"
- .format(RESTCONF_BASE_URL))
- data = test_utils.generate_connect_data("ROADM-C1", test_utils.sims['roadmc']['port'])
- response = test_utils.put_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.created, CODE_SHOULD_BE_201) # pylint: disable=no-member
+ response = test_utils.mount_device("ROADM-C1", 'roadmc')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
time.sleep(20)
def test_05_connect_xprda_n1_to_roadma_pp1(self):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(RESTCONF_BASE_URL)
+ url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(test_utils.RESTCONF_BASE_URL)
data = test_utils.generate_link_data("XPDR-A1", "1", "1", "ROADM-A1", "1", "SRG1-PP1-TXRX")
- response = test_utils.post_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.post_request(url, data, test_utils.ODL_LOGIN, test_utils.ODL_PWD)
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"],
CREATED_SUCCESSFULLY)
time.sleep(2)
def test_06_connect_roadma_pp1_to_xpdra_n1(self):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(RESTCONF_BASE_URL)
+ url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(test_utils.RESTCONF_BASE_URL)
data = test_utils.generate_link_data("XPDR-A1", "1", "1", "ROADM-A1", "1", "SRG1-PP1-TXRX")
- response = test_utils.post_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.post_request(url, data, test_utils.ODL_LOGIN, test_utils.ODL_PWD)
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"],
CREATED_SUCCESSFULLY)
time.sleep(2)
def test_07_connect_xprdc_n1_to_roadmc_pp1(self):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(RESTCONF_BASE_URL)
+ url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(test_utils.RESTCONF_BASE_URL)
data = test_utils.generate_link_data("XPDR-C1", "1", "1", "ROADM-C1", "1", "SRG1-PP1-TXRX")
- response = test_utils.post_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.post_request(url, data, test_utils.ODL_LOGIN, test_utils.ODL_PWD)
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"],
CREATED_SUCCESSFULLY)
time.sleep(2)
def test_08_connect_roadmc_pp1_to_xpdrc_n1(self):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(RESTCONF_BASE_URL)
+ url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(test_utils.RESTCONF_BASE_URL)
data = test_utils.generate_link_data("XPDR-C1", "1", "1", "ROADM-C1", "1", "SRG1-PP1-TXRX")
- response = test_utils.post_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.post_request(url, data, test_utils.ODL_LOGIN, test_utils.ODL_PWD)
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"],
CREATED_SUCCESSFULLY)
time.sleep(2)
def test_09_connect_xprda_n2_to_roadma_pp2(self):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(RESTCONF_BASE_URL)
+ url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(test_utils.RESTCONF_BASE_URL)
data = test_utils.generate_link_data("XPDR-A1", "1", "2", "ROADM-A1", "1", "SRG1-PP2-TXRX")
- response = test_utils.post_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.post_request(url, data, test_utils.ODL_LOGIN, test_utils.ODL_PWD)
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"],
CREATED_SUCCESSFULLY)
time.sleep(2)
def test_10_connect_roadma_pp2_to_xpdra_n2(self):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(RESTCONF_BASE_URL)
+ url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(test_utils.RESTCONF_BASE_URL)
data = test_utils.generate_link_data("XPDR-A1", "1", "2", "ROADM-A1", "1", "SRG1-PP2-TXRX")
- response = test_utils.post_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.post_request(url, data, test_utils.ODL_LOGIN, test_utils.ODL_PWD)
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"],
CREATED_SUCCESSFULLY)
time.sleep(2)
def test_11_connect_xprdc_n2_to_roadmc_pp2(self):
- url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(RESTCONF_BASE_URL)
+ url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(test_utils.RESTCONF_BASE_URL)
data = test_utils.generate_link_data("XPDR-C1", "1", "2", "ROADM-C1", "1", "SRG1-PP2-TXRX")
- response = test_utils.post_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.post_request(url, data, test_utils.ODL_LOGIN, test_utils.ODL_PWD)
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
res = response.json()
self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"],
CREATED_SUCCESSFULLY)
time.sleep(2)
def test_12_connect_roadmc_pp2_to_xpdrc_n2(self):
- url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(RESTCONF_BASE_URL)
+ url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(test_utils.RESTCONF_BASE_URL)
data = test_utils.generate_link_data("XPDR-C1", "1", "2", "ROADM-C1", "1", "SRG1-PP2-TXRX")
- response = test_utils.post_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.post_request(url, data, test_utils.ODL_LOGIN, test_utils.ODL_PWD)
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
res = response.json()
self.assertIn('Roadm Xponder links created successfully', res["output"]["result"],
CREATED_SUCCESSFULLY)
time.sleep(2)
def test_13_get_tapi_openroadm_topology(self):
- url = "{}/operations/tapi-topology:get-topology-details".format(RESTCONF_BASE_URL)
+ url = "{}/operations/tapi-topology:get-topology-details".format(test_utils.RESTCONF_BASE_URL)
data = {
"tapi-topology:input": {
"tapi-topology:topology-id-or-name": "openroadm-topology"
}
}
- response = test_utils.post_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.post_request(url, data, test_utils.ODL_LOGIN, test_utils.ODL_PWD)
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
res = response.json()
self.assertEqual(len(res["output"]["topology"]["node"]), 1, 'There should be 1 node')
self.assertEqual(len(res["output"]["topology"]["node"][0]["owned-node-edge-point"]), 4,
'There should be 4 owned-node-edge-points')
def test_14_get_tapi_otn_topology(self):
- url = "{}/operations/tapi-topology:get-topology-details".format(RESTCONF_BASE_URL)
+ url = "{}/operations/tapi-topology:get-topology-details".format(test_utils.RESTCONF_BASE_URL)
data = {
"tapi-topology:input": {
"tapi-topology:topology-id-or-name": "otn-topology"
}
}
- response = test_utils.post_request(url, data, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.post_request(url, data, test_utils.ODL_LOGIN, test_utils.ODL_PWD)
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
res = response.json()
self.assertEqual(len(res["output"]["topology"]["node"]), 4, 'There should be 4 nodes')
self.assertEqual(len(res["output"]["topology"]["link"]), 5, 'There should be 5 links')
self.fail('Wrong layer protocol name')
def test_15_disconnect_xpdra(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-A1"
- .format(RESTCONF_BASE_URL))
-
- response = test_utils.delete_request(url, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.unmount_device("XPDR-A1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
time.sleep(10)
def test_16_disconnect_xpdrc(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-C1"
- .format(RESTCONF_BASE_URL))
-
- response = test_utils.delete_request(url, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.unmount_device("XPDR-C1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
time.sleep(10)
def test_17_disconnect_roadma(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-A1"
- .format(RESTCONF_BASE_URL))
-
- response = test_utils.delete_request(url, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.unmount_device("ROADM-A1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
time.sleep(10)
def test_18_disconnect_roadmc(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/ROADM-C1"
- .format(RESTCONF_BASE_URL))
-
- response = test_utils.delete_request(url, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.unmount_device("ROADM-C1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
time.sleep(10)
def test_19_disconnect_spdr_sa1(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/SPDR-SA1"
- .format(RESTCONF_BASE_URL))
- response = test_utils.delete_request(url, 'admin', 'admin')
- self.assertEqual(response.status_code, requests.codes.ok, CODE_SHOULD_BE_200) # pylint: disable=no-member
+ response = test_utils.unmount_device("SPDR-SA1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def find_object_with_key(list_dicts, key, value):
class TransportPCEtesting(unittest.TestCase):
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(cls):
# Connect the ROADMA
def test_01_connect_rdm(self):
- # Config ROADMA
- 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": test_utils.sims['roadma']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADM-A1", 'roadma')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
# Verify the termination points of the ROADMA
def test_02_compareOpenroadmTopologyPortMapping_rdm(self):
urlTopo = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
responseTopo = requests.request(
- "GET", urlTopo, headers=headers, auth=('admin', 'admin'))
+ "GET", urlTopo, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
resTopo = responseTopo.json()
nbNode = len(resTopo['network'][0]['node'])
nbMapCumul = 0
nodeMapId = nodeId.split("-")[0] + "-" + nodeId.split("-")[1]
print("nodeMapId={}".format(nodeMapId))
urlMapList = "{}/config/transportpce-portmapping:network/nodes/" + nodeMapId
- urlMapListFull = urlMapList.format(self.restconf_baseurl)
+ urlMapListFull = urlMapList.format(test_utils.RESTCONF_BASE_URL)
responseMapList = requests.request(
- "GET", urlMapListFull, headers=headers, auth=('admin', 'admin'))
+ "GET", urlMapListFull, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
resMapList = responseMapList.json()
nbMappings = len(resMapList['nodes'][0]['mapping']) - nbMapCumul
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)
+ urlMapFull = urlMap.format(test_utils.RESTCONF_BASE_URL)
responseMap = requests.request(
- "GET", urlMapFull, headers=headers, auth=('admin', 'admin'))
+ "GET", urlMapFull, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(responseMap.status_code, requests.codes.ok)
if(responseMap.status_code == requests.codes.ok):
nbMapCurrent += 1
def test_03_disconnect_rdm(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/ROADM-A1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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": test_utils.sims['xpdra']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("XPDR-A1", 'xpdra')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
# #Verify the termination points related to XPDR
def test_05_compareOpenroadmTopologyPortMapping_xpdr(self):
def test_06_disconnect_device(self):
url = ("{}/config/network-topology:"
"network-topology/topology/topology-netconf/node/XPDR-A1"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
class TransportPCEtesting(unittest.TestCase):
processes = None
- restconf_baseurl = "http://localhost:8181/restconf"
@classmethod
def setUpClass(cls):
time.sleep(5)
def test_01_connect_ROADM_A1(self):
- # Config ROADMA
- 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": test_utils.sims['roadma']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADM-A1", 'roadma')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_02_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
logging.info(res)
def test_03_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADM-A1')
def test_04_getLinks_OpenroadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
def test_05_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(len(listNode), 0)
def test_06_connect_XPDRA(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/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": test_utils.sims['xpdra']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(30)
+ response = test_utils.mount_device("XPDR-A1", 'xpdra')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_07_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
def test_08_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_09_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
def test_10_connect_tail_xpdr_rdm(self):
# Connect the tail: XPDRA to ROADMA
url = ("{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"networkutils:input": {
"networkutils:links-input": {
"networkutils:xpdr-node": "XPDR-A1",
}
}
}
- 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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"networkutils:input": {
"networkutils:links-input": {
"networkutils:xpdr-node": "XPDR-A1",
}
}
}
- 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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
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'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
self.assertEqual(len(XPDR_OUT), 0)
def test_13_connect_ROADMC(self):
- # Config ROADMC
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/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": test_utils.sims['roadmc']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADM-C1", 'roadmc')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_14_omsAttributes_ROADMA_ROADMC(self):
# Config ROADMA-ROADMC oms-attributes
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
def test_15_omsAttributes_ROADMC_ROADMA(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
def test_16_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_17_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_18_getROADMLinkOpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
def test_20_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(len(listNode), 0)
def test_21_connect_ROADMB(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/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": test_utils.sims['roadmb']['port'],
- "netconf-node-topology:tcp-only": "false",
- "netconf-node-topology:pass-through": {}}]}
- headers = {'content-type': 'application/json'}
- response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
- self.assertEqual(response.status_code, requests.codes.created)
- time.sleep(20)
+ response = test_utils.mount_device("ROADM-B1", 'roadmb')
+ self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
def test_22_omsAttributes_ROADMA_ROADMB(self):
# Config ROADM-A1-ROADM-B1 oms-attributes
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
def test_23_omsAttributes_ROADMB_ROADMA(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
def test_24_omsAttributes_ROADMB_ROADMC(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
def test_25_omsAttributes_ROADMC_ROADMB(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
"OMS-attributes/span"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
data = {"span": {
"auto-spanloss": "true",
"engineered-spanloss": 12.2,
"fiber-type": "smf",
"SRLG-length": 100000,
"pmd": 0.5}]}}
- headers = {'content-type': 'application/json'}
response = requests.request(
- "PUT", url, data=json.dumps(data), headers=headers,
- auth=('admin', 'admin'))
+ "PUT", url, data=json.dumps(data), headers=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.created)
def test_26_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_27_verifyDegree(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
def test_28_verifyOppositeLinkTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# Tests related to links
oppLink_id = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
# Find the opposite link
url_oppLink = "{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"+oppLink_id
- url = (url_oppLink.format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
- response_oppLink = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
+ url = (url_oppLink.format(test_utils.RESTCONF_BASE_URL))
+ response_oppLink = requests.request(
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response_oppLink.status_code, requests.codes.ok)
res_oppLink = response_oppLink.json()
self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbLink = len(res['network'][0]['ietf-network-topology:link'])
def test_30_disconnect_ROADMB(self):
# Delete in the topology-netconf
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/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'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("ROADM-B1")
# Delete in the clli-network
url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeB"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
def test_31_disconnect_ROADMC(self):
# Delete in the topology-netconf
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/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'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("ROADM-C1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
# Delete in the clli-network
url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeC"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
# def test_24_check_roadm2roadm_links_deletion(self):
# url = ("{}/config/ietf-network:networks/network/openroadm-topology"
-# .format(self.restconf_baseurl))
-# headers = {'content-type': 'application/json'}
+# .format(test_utils.RESTCONF_BASE_URL))
# response = requests.request(
-# "GET", url, headers=headers, auth=('admin', 'admin'))
+# "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
# self.assertEqual(response.status_code, requests.codes.ok)
# res = response.json()
# #Write the response in the log
def test_32_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
def test_33_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_34_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'], 'NodeC')
def test_35_disconnect_XPDRA(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/XPDR-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'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("XPDR-A1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
def test_36_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_37_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbNode = len(res['network'][0]['node'])
def test_38_getNodes_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
res = response.json()
# Tests related to nodes
self.assertEqual(response.status_code, requests.codes.ok)
# Link-1
url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
"link/XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
# 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(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
def test_40_getLinks_OpenRoadmTopology(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbLink = len(res['network'][0]['ietf-network-topology:link'])
['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
def test_41_disconnect_ROADMA(self):
- url = ("{}/config/network-topology:"
- "network-topology/topology/topology-netconf/node/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'))
- self.assertEqual(response.status_code, requests.codes.ok)
+ response = test_utils.unmount_device("ROADM-A1")
+ self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
# Delete in the clli-network
url = ("{}/config/ietf-network:networks/network/clli-network/node/NodeA"
- .format(self.restconf_baseurl))
+ .format(test_utils.RESTCONF_BASE_URL))
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=test_utils.TYPE_APPLICATION_JSON,
+ auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
def test_42_getClliNetwork(self):
url = ("{}/config/ietf-network:networks/network/clli-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn('node', res['network'][0])
def test_43_getOpenRoadmNetwork(self):
url = ("{}/config/ietf-network:networks/network/openroadm-network"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertNotIn('node', res['network'][0])
def test_44_check_roadm2roadm_link_persistence(self):
url = ("{}/config/ietf-network:networks/network/openroadm-topology"
- .format(self.restconf_baseurl))
- headers = {'content-type': 'application/json'}
+ .format(test_utils.RESTCONF_BASE_URL))
response = requests.request(
- "GET", url, headers=headers, auth=('admin', 'admin'))
+ "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
nbLink = len(res['network'][0]['ietf-network-topology:link'])
honeynode_executable = simulators.honeynode_executable
samples_directory = simulators.samples_directory
-HONEYNODE_OK_START_MSG = re.escape("Netconf SSH endpoint started successfully at 0.0.0.0")
-KARAF_OK_START_MSG = re.escape("Blueprint container for bundle "
- "org.opendaylight.netconf.restconf") + ".* was successfully created"
+HONEYNODE_OK_START_MSG = "Netconf SSH endpoint started successfully at 0.0.0.0"
+KARAF_OK_START_MSG = re.escape(
+ "Blueprint container for bundle org.opendaylight.netconf.restconf")+".* was successfully created"
-TYPE_APPLICATION_JSON = {'content-type': 'application/json'}
+
+RESTCONF_BASE_URL = "http://localhost:8181/restconf"
+ODL_LOGIN = "admin"
+ODL_PWD = "admin"
+NODES_LOGIN = "admin"
+NODES_PWD = "admin"
+
+TYPE_APPLICATION_JSON = {'Content-Type': 'application/json', 'Accept': 'application/json'}
+TYPE_APPLICATION_XML = {'Content-Type': 'application/xml', 'Accept': 'application/xml'}
+
+CODE_SHOULD_BE_200 = 'Http status code should be 200'
+CODE_SHOULD_BE_201 = 'Http status code should be 201'
log_directory = os.path.dirname(os.path.realpath(__file__))
process_list = []
+if "USE_LIGHTY" in os.environ and os.environ['USE_LIGHTY'] == 'True':
+ tpce_log = 'odl.log'
+else:
+ tpce_log = karaf_log
def start_sims(sims_list):
for sim in sims_list:
def start_tpce():
- print("starting opendaylight...")
+ print("starting OpenDaylight...")
if "USE_LIGHTY" in os.environ and os.environ['USE_LIGHTY'] == 'True':
process = start_lighty()
# TODO: add some sort of health check similar to Karaf below
else:
process = start_karaf()
if wait_until_log_contains(karaf_log, KARAF_OK_START_MSG, time_to_wait=60):
- print("opendaylight started")
+ print("OpenDaylight started !")
else:
- print("opendaylight failed to start")
+ print("OpenDaylight failed to start !")
shutdown_process(process)
for pid in process_list:
shutdown_process(pid)
auth=(username, password))
-def generate_connect_data(node_id: str, node_port: str):
- data = {"node": [{
+def mount_device(node_id, sim):
+ url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/"
+ + node_id).format(RESTCONF_BASE_URL)
+ headers = {"node": [{
"node-id": node_id,
- "netconf-node-topology:username": "admin",
- "netconf-node-topology:password": "admin",
+ "netconf-node-topology:username": NODES_LOGIN,
+ "netconf-node-topology:password": NODES_PWD,
"netconf-node-topology:host": "127.0.0.1",
- "netconf-node-topology:port": node_port,
+ "netconf-node-topology:port": sims[sim]['port'],
"netconf-node-topology:tcp-only": "false",
"netconf-node-topology:pass-through": {}}]}
- return data
+ response = put_request(url, headers, ODL_LOGIN, ODL_PWD)
+ if wait_until_log_contains(tpce_log, re.escape("Triggering notification stream NETCONF for node "+node_id), 60):
+ print("Node "+node_id+" correctly added to tpce topology", end='... ', flush=True)
+ else:
+ print("Node "+node_id+" still not added to tpce topology", end='... ', flush=True)
+ if response.status_code == requests.codes.ok:
+ print("It was probably loaded at start-up", end='... ', flush=True)
+ # TODO an else-clause to abort test would probably be nice here
+ return response
+
+
+def unmount_device(node_id):
+ url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/"
+ + node_id).format(RESTCONF_BASE_URL)
+ response = delete_request(url, ODL_LOGIN, ODL_PWD)
+ if wait_until_log_contains(tpce_log, re.escape("onDeviceDisConnected: "+node_id), 60):
+ print("Node "+node_id+" correctly deleted from tpce topology", end='... ', flush=True)
+ else:
+ print("Node "+node_id+" still not deleted from tpce topology", end='... ', flush=True)
+ return response
def generate_link_data(xpdr_node: str, xpdr_num: str, network_num: str, rdm_node: str, srg_num: str,
stdout=outfile, stderr=outfile)
-def wait_until_log_contains(log_file, searched_string, time_to_wait=20):
+def wait_until_log_contains(log_file, regexp, time_to_wait=20):
found = False
tail = None
try:
with timeout(seconds=time_to_wait):
- print("Waiting for " + searched_string)
+ print("Searching for pattern '"+regexp+"' in "+os.path.basename(log_file), end='... ', flush=True)
tail = subprocess.Popen(['tail', '-F', log_file], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
- regexp = re.compile(searched_string)
+ compiled_regexp = re.compile(regexp)
while True:
line = tail.stdout.readline().decode('utf-8')
- if regexp.search(line):
- print("Searched string found.")
+ if compiled_regexp.search(line):
+ print("String found!", end=' ')
found = True
break
except TimeoutError:
- print("Cannot find string "+searched_string+" after waiting for "+str(time_to_wait))
+ print("String not found after "+str(time_to_wait), end=" seconds! ", flush=True)
finally:
if tail is not None:
- print("Stopping tail command")
+ print("Stopping tail command", end='... ', flush=True)
tail.stderr.close()
tail.stdout.close()
tail.kill()
tail.wait()
return found
+# TODO try to find an alternative to subprocess+tail -f (such as https://pypi.org/project/tailhead/)
class timeout:
Code Review / transportpce.git / commitdiff