def test_04_check_tapi_topos(self):
url = "{}/operations/tapi-topology:get-topology-details"
data = {
"tapi-topology:input": {
"tapi-topology:topology-id-or-name": "Transponder 100GE"
}
}
response = test_utils.post_request(url, data)
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,
'Topology should contain 1 node')
self.assertNotIn("link", res["output"]["topology"],
'Topology should contain no link')
url = "{}/operations/tapi-topology:get-topology-details"
data = {
"tapi-topology:input": {
"tapi-topology:topology-id-or-name":
"T0 - Multi-layer topology"
}
}
response = test_utils.post_request(url, data)
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,
'Topology should contain 1 node')
self.assertNotIn("link", res["output"]["topology"],
'Topology should contain no link')
def test_18_check_tapi_topology_T100G(self):
url = "{}/operations/tapi-topology:get-topology-details"
data = {
"tapi-topology:input": {
"tapi-topology:topology-id-or-name": "Transponder 100GE"
}
}
response = test_utils.post_request(url, data)
self.assertEqual(response.status_code, requests.codes.ok,
test_utils.CODE_SHOULD_BE_200)
res = response.json()
self.assertEqual(
2,
len(res["output"]["topology"]["node"][0]["owned-node-edge-point"]),
'Node should contain 2 owned-node-edge-points')
self.assertEqual(
"XPDR-C1-XPDR1+DSR+XPDR1-CLIENT1", res["output"]["topology"]
["node"][0]["owned-node-edge-point"][0]["name"][0]["value"],
'name of owned-node-edge-points should be XPDR-C1-XPDR1+DSR+XPDR1-CLIENT1'
)
self.assertEqual(
"XPDR-A1-XPDR1+DSR+XPDR1-CLIENT1", res["output"]["topology"]
["node"][0]["owned-node-edge-point"][1]["name"][0]["value"],
'name of owned-node-edge-points should be XPDR-A1-XPDR1+DSR+XPDR1-CLIENT1'
)
def test_10_check_tapi_topos(self):
self.test_01_get_tapi_topology_T100G()
url = "{}/operations/tapi-topology:get-topology-details"
data = {
"tapi-topology:input": {
"tapi-topology:topology-id-or-name":
"T0 - Multi-layer topology"
}
}
response = test_utils.post_request(url, data)
self.assertEqual(response.status_code, requests.codes.ok,
test_utils.CODE_SHOULD_BE_200)
res = response.json()
self.assertEqual(1, len(res["output"]["topology"]["node"]),
'Topology should contain 1 node')
self.assertNotIn("link", res["output"]["topology"],
'Topology should contain no link')
self.assertEqual(
"ROADM-infra",
res["output"]["topology"]["node"][0]["name"][0]["value"],
'node name should be: ROADM-infra')
self.assertIn(
"PHOTONIC_MEDIA",
res["output"]["topology"]["node"][0]["layer-protocol-name"],
'Node layer protocol should contain PHOTONIC_MEDIA')
self.assertEqual(
1, len(res["output"]["topology"]["node"][0]["node-rule-group"]),
'node should contain 1 node rule group')
def test_01_get_tapi_topology_T100G(self):
url = "{}/operations/tapi-topology:get-topology-details"
data = {
"tapi-topology:input": {
"tapi-topology:topology-id-or-name": "Transponder 100GE"
}
}
response = test_utils.post_request(url, data)
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,
'Topology should contain 1 node')
self.assertNotIn("link", res["output"]["topology"],
'Topology should contain no link')
self.assertNotIn("owned-node-edge-point",
res["output"]["topology"]["node"][0],
'Node should contain no owned-node-edge-points')
self.assertEqual(
"Tpdr100g over WDM node",
res["output"]["topology"]["node"][0]["name"][0]["value"],
'node name should be: Tpdr100g over WDM node')
self.assertIn(
"ETH", res["output"]["topology"]["node"][0]["layer-protocol-name"],
'Node layer protocol should contain ETH')
self.assertEqual(
1, len(res["output"]["topology"]["node"][0]["node-rule-group"]),
'node should contain 1 node rule group')
def test_12_get_PM_ROADMC(self):
url = "{}/operations/transportpce-olm:get-pm"
data = {
"input": {
"node-id": "ROADMC01",
"resource-type": "interface",
"granularity": "15min",
"resource-identifier": {
"resource-name": "OTS-DEG2-TTP-TXRX"
}
}
}
response = test_utils.post_request(url, data)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn({
"pmparameter-name": "OpticalPowerOutput",
"pmparameter-value": "18.1"
}, res["output"]["measurements"])
self.assertIn({
"pmparameter-name": "OpticalReturnLoss",
"pmparameter-value": "48.8"
}, res["output"]["measurements"])
self.assertIn({
"pmparameter-name": "OpticalPowerInput",
"pmparameter-value": "-3.2"
}, res["output"]["measurements"])
def test_38_calculate_span_loss_current(self):
url = "{}/operations/transportpce-olm:calculate-spanloss-current"
response = test_utils.post_request(url, None)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success',
res["output"]["result"])
time.sleep(5)
def test_17_fail_path_computation(self):
response = test_utils.post_request(test_utils.URL_PATH_COMPUTATION_REQUEST,
{"input": {"service-handler-header": {"request-id": "request-1"}}})
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Service Name is not set',
res['output']['configuration-response-common']['response-message'])
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)
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
res = response.json()
self.assertIn('Roadm Xponder links created successfully',
res["output"]["result"], CREATED_SUCCESSFULLY)
time.sleep(2)
def test_34_check_tapi_topology_T0(self):
url = "{}/operations/tapi-topology:get-topology-details"
data = {
"tapi-topology:input": {
"tapi-topology:topology-id-or-name":
"T0 - Multi-layer topology"
}
}
response = test_utils.post_request(url, data)
self.assertEqual(response.status_code, requests.codes.ok,
test_utils.CODE_SHOULD_BE_200)
res = response.json()
nodes = res["output"]["topology"]["node"]
links = res["output"]["topology"]["link"]
self.assertEqual(9, len(nodes), 'Topology should contain 9 nodes')
self.assertEqual(10, len(links), 'Topology should contain 10 links')
self.assertEqual(
4,
count_object_with_double_key(links, "name", "value-name",
"transitional link name"),
'Topology should contain 4 transitional links')
self.assertEqual(
4,
count_object_with_double_key(links, "name", "value-name",
"OMS link name"),
'Topology should contain 4 oms links')
self.assertEqual(
2,
count_object_with_double_key(links, "name", "value-name",
"otn link name"),
'Topology should contain 2 otn links')
for link in links:
if link["name"][0][
"value"] == "OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1":
self.assertEqual(
0, link["available-capacity"]["total-size"]["value"],
'OTU4 link should have an available capacity of 0 Mbps')
elif link["name"][0][
"value"] == "ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1":
self.assertEqual(
100000, link["available-capacity"]["total-size"]["value"],
'ODU4 link should have an available capacity of 100 000 Mbps'
)
elif link["name"][0]["value-name"] == "transitional link name":
self.assertEqual(
100, link["available-capacity"]["total-size"]["value"],
'link should have an available capacity of 100 Gbps')
self.assertEqual(2, len(link["node-edge-point"]),
'link should have 2 neps')
def test_13_get_tapi_openroadm_topology(self):
url = "{}/operations/tapi-topology:get-topology-details".format(
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
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_43_get_tapi_topology_T100G(self):
url = "{}/operations/tapi-topology:get-topology-details"
data = {
"tapi-topology:input": {
"tapi-topology:topology-id-or-name": "Transponder 100GE"
}
}
response = test_utils.post_request(url, data)
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,
'Topology should contain 1 node')
self.assertNotIn("link", res["output"]["topology"],
'Topology should contain no link')
self.assertNotIn("owned-node-edge-point",
res["output"]["topology"]["node"][0],
'Node should contain no owned-node-edge-points')
def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
url = "{}/operations/transportpce-olm:calculate-spanloss-base"
data = {
"input": {
"src-type": "link",
"link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
}
}
response = test_utils.post_request(url, data)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success',
res["output"]["result"])
self.assertIn({
"spanloss": "5.7",
"link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
}, res["output"]["spans"])
time.sleep(5)
def test_42_check_tapi_topology_T0(self):
url = "{}/operations/tapi-topology:get-topology-details"
data = {
"tapi-topology:input": {
"tapi-topology:topology-id-or-name":
"T0 - Multi-layer topology"
}
}
response = test_utils.post_request(url, data)
self.assertEqual(response.status_code, requests.codes.ok,
test_utils.CODE_SHOULD_BE_200)
res = response.json()
nodes = res["output"]["topology"]["node"]
self.assertEqual(1, len(nodes), 'Topology should contain 1 node')
self.assertNotIn("link", res["output"]["topology"],
'Topology should contain no link')
self.assertEqual(
"ROADM-infra",
res["output"]["topology"]["node"][0]["name"][0]["value"],
'node name should be: ROADM-infra')
def test_37_check_tapi_topology_T0(self):
url = "{}/operations/tapi-topology:get-topology-details"
data = {
"tapi-topology:input": {
"tapi-topology:topology-id-or-name":
"T0 - Multi-layer topology"
}
}
response = test_utils.post_request(url, data)
self.assertEqual(response.status_code, requests.codes.ok,
test_utils.CODE_SHOULD_BE_200)
res = response.json()
nodes = res["output"]["topology"]["node"]
links = res["output"]["topology"]["link"]
self.assertEqual(11, len(nodes), 'Topology should contain 11 nodes')
self.assertEqual(12, len(links), 'Topology should contain 12 links')
self.assertEqual(
6,
count_object_with_double_key(nodes, "name", "value-name",
"otsi node name"),
'Topology should contain 6 otsi nodes')
self.assertEqual(
5,
count_object_with_double_key(nodes, "name", "value-name",
"dsr/odu node name"),
'Topology should contain 5 dsr nodes')
self.assertEqual(
5,
count_object_with_double_key(links, "name", "value-name",
"transitional link name"),
'Topology should contain 5 transitional links')
self.assertEqual(
5,
count_object_with_double_key(links, "name", "value-name",
"OMS link name"),
'Topology should contain 5 oms links')
self.assertEqual(
2,
count_object_with_double_key(links, "name", "value-name",
"otn link name"),
'Topology should contain 2 otn links')
def test_26_service_power_turndown_XPDRA_XPDRC(self):
url = "{}/operations/transportpce-olm:service-power-turndown"
data = {
"input": {
"service-name": "test",
"wave-number": 1,
"nodes": [
{
"dest-tp": "XPDR1-NETWORK1",
"src-tp": "XPDR1-CLIENT1",
"node-id": "XPDRA01"
},
{
"dest-tp": "DEG1-TTP-TXRX",
"src-tp": "SRG1-PP1-TXRX",
"node-id": "ROADMA01"
},
{
"dest-tp": "SRG1-PP1-TXRX",
"src-tp": "DEG2-TTP-TXRX",
"node-id": "ROADMC01"
},
{
"dest-tp": "XPDR1-CLIENT1",
"src-tp": "XPDR1-NETWORK1",
"node-id": "XPDRC01"
}
],
"center-freq": 196.1,
"width": 40,
"min-freq": 196.075,
"max-freq": 196.125,
"lower-spectral-slot-number": 761,
"higher-spectral-slot-number": 768
}
}
response = test_utils.post_request(url, data)
print(response.json())
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success', res["output"]["result"])
def test_07_device_renderer(self):
data = {
"transportpce-device-renderer:input": {
"transportpce-device-renderer:modulation-format":
"dp-qpsk",
"transportpce-device-renderer:operation":
"create",
"transportpce-device-renderer:service-name":
"testNMC-MC",
"transportpce-device-renderer:wave-number":
"0",
"transportpce-device-renderer:center-freq":
"196.05",
"transportpce-device-renderer:width":
"80",
"transportpce-device-renderer:nodes": [{
"transportpce-device-renderer:node-id":
"ROADM-D1",
"transportpce-device-renderer:src-tp":
"SRG1-PP1-TXRX",
"transportpce-device-renderer:dest-tp":
"DEG1-TTP-TXRX"
}],
"transportpce-device-renderer:min-freq":
196.00625,
"transportpce-device-renderer:max-freq":
196.09375,
"transportpce-device-renderer:lower-spectral-slot-number":
749,
"transportpce-device-renderer:higher-spectral-slot-number":
763
}
}
url = test_utils.RESTCONF_BASE_URL + \
"/operations/transportpce-device-renderer:service-path"
response = test_utils.post_request(url, data)
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_40_check_tapi_topology_T0(self):
url = "{}/operations/tapi-topology:get-topology-details"
data = {
"tapi-topology:input": {
"tapi-topology:topology-id-or-name":
"T0 - Multi-layer topology"
}
}
response = test_utils.post_request(url, data)
self.assertEqual(response.status_code, requests.codes.ok,
test_utils.CODE_SHOULD_BE_200)
res = response.json()
nodes = res["output"]["topology"]["node"]
links = res["output"]["topology"]["link"]
self.assertEqual(11, len(nodes), 'Topology should contain 11 nodes')
self.assertEqual(10, len(links), 'Topology should contain 10 links')
self.assertEqual(
0,
count_object_with_double_key(links, "name", "value-name",
"otn link name"),
'Topology should contain 0 otn link')
def test_03_service_create_OTU4(self):
url = "{}/operations/transportpce-renderer:service-implementation-request"
data = {
"transportpce-renderer:input": {
"transportpce-renderer:service-name": "SPDRA-SPDRC-OTU4-ODU4",
"transportpce-renderer:connection-type": "infrastructure",
"transportpce-renderer:service-handler-header": {
"transportpce-renderer:request-id": "abcd12-efgh34"
},
"transportpce-renderer:service-a-end": {
"transportpce-renderer:service-format": "OTU",
"transportpce-renderer:otu-service-rate": "org-openroadm-otn-common-types:OTU4",
"transportpce-renderer:clli": "nodeSA",
"transportpce-renderer:node-id": "SPDR-SA1"
},
"transportpce-renderer:service-z-end": {
"transportpce-renderer:service-format": "OTU",
"transportpce-renderer:otu-service-rate": "org-openroadm-otn-common-types:OTU4",
"transportpce-renderer:clli": "nodeSC",
"transportpce-renderer:node-id": "SPDR-SC1"
},
"transportpce-renderer:path-description": {
"aToZ-direction": {
"rate": 100,
"transportpce-renderer:modulation-format": "dp-qpsk",
"aToZ-wavelength-number": 1,
"aToZ": [
{
"id": "0",
"resource": {
"tp-node-id": "SPDR-SA1-XPDR1",
"tp-id": ""
}
},
{
"id": "1",
"resource": {
"tp-node-id": "SPDR-SA1-XPDR1",
"tp-id": "XPDR1-NETWORK1"
}
},
{
"id": "2",
"resource": {
"tp-node-id": "SPDR-SC1-XPDR1",
"tp-id": "XPDR1-NETWORK1"
}
},
{
"id": "3",
"resource": {
"tp-node-id": "SPDR-SC1-XPDR1",
"tp-id": ""
}
}
],
"transportpce-renderer:aToZ-min-frequency": 196.075,
"transportpce-renderer:aToZ-max-frequency": 196.125
},
"transportpce-renderer:zToA-direction": {
"transportpce-renderer:zToA-wavelength-number": "1",
"transportpce-renderer:rate": "100",
"transportpce-renderer:modulation-format": "dp-qpsk",
"zToA": [
{
"id": "0",
"resource": {
"tp-node-id": "SPDR-SC1-XPDR1",
"tp-id": ""
}
},
{
"id": "1",
"resource": {
"tp-node-id": "SPDR-SC1-XPDR1",
"tp-id": "XPDR1-NETWORK1"
}
},
{
"id": "2",
"resource": {
"tp-node-id": "SPDR-SA1-XPDR1",
"tp-id": "XPDR1-NETWORK1"
}
},
{
"id": "3",
"resource": {
"tp-node-id": "SPDR-SA1-XPDR1",
"tp-id": ""
}
}
],
"transportpce-renderer:zToA-min-frequency": 196.075,
"transportpce-renderer:zToA-max-frequency": 196.125
}
}
}
}
response = test_utils.post_request(url, data)
time.sleep(3)
print(response.json())
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Operation Successful',
res["output"]["configuration-response-common"]["response-message"])
def test_14_get_tapi_otn_topology(self):
url = "{}/operations/tapi-topology:get-topology-details".format(
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
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')
link_to_check = res["output"]["topology"]["link"][0]
# get info from first link to do deeper check
node1_uid = link_to_check["node-edge-point"][0]["node-uuid"]
node2_uid = link_to_check["node-edge-point"][1]["node-uuid"]
node_edge_point1_uid = link_to_check["node-edge-point"][0][
"node-edge-point-uuid"]
node_edge_point2_uid = link_to_check["node-edge-point"][1][
"node-edge-point-uuid"]
# get node associated to link info
nodes = res["output"]["topology"]["node"]
node1 = find_object_with_key(nodes, "uuid", node1_uid)
self.assertIsNotNone(
node1, 'Node with uuid ' + node1_uid + ' should not be null')
node2 = find_object_with_key(nodes, "uuid", node2_uid)
self.assertIsNotNone(
node2, 'Node with uuid ' + node2_uid + ' should not be null')
# get edge-point associated to nodes
node1_edge_point = node1["owned-node-edge-point"]
node2_edge_point = node2["owned-node-edge-point"]
node_edge_point1 = find_object_with_key(node1_edge_point, "uuid",
node_edge_point1_uid)
self.assertIsNotNone(
node_edge_point1, 'Node edge point with uuid ' +
node_edge_point1_uid + 'should not be '
'null')
node_edge_point2 = find_object_with_key(node2_edge_point, "uuid",
node_edge_point2_uid)
self.assertIsNotNone(
node_edge_point2, 'Node edge point with uuid ' +
node_edge_point2_uid + 'should not be '
'null')
self.assertEqual(len(node_edge_point1["name"]), 1,
'There should be 1 name')
self.assertEqual(len(node_edge_point2["name"]), 1,
'There should be 1 name')
if node_edge_point1["layer-protocol-name"] == 'ODU':
self.assertIn('NodeEdgePoint_N',
node_edge_point1["name"][0]["value-name"],
'Value name should be '
'NodeEdgePoint_NX')
elif node_edge_point1["layer-protocol-name"] == 'PHOTONIC_MEDIA':
self.assertIn('iNodeEdgePoint_',
node_edge_point1["name"][0]["value-name"],
'Value name should be '
'iNodeEdgePoint_X')
else:
self.fail('Wrong layer protocol name')
if node_edge_point2["layer-protocol-name"] == 'ODU':
self.assertIn('NodeEdgePoint_N',
node_edge_point2["name"][0]["value-name"],
'Value name should be '
'NodeEdgePoint_NX')
elif node_edge_point2["layer-protocol-name"] == 'PHOTONIC_MEDIA':
self.assertIn('iNodeEdgePoint_',
node_edge_point2["name"][0]["value-name"],
'Value name should be '
'iNodeEdgePoint_X')
else:
self.fail('Wrong layer protocol name')
def test_11_service_create_10GE(self):
url = "{}/operations/transportpce-renderer:service-implementation-request"
data = {
"transportpce-renderer:input": {
"transportpce-renderer:service-name": "SPDRA-SPDRC-10G",
"transportpce-renderer:connection-type": "service",
"transportpce-renderer:service-handler-header": {
"transportpce-renderer:request-id": "abcd12-efgh34"
},
"transportpce-renderer:service-a-end": {
"transportpce-renderer:service-format": "Ethernet",
"transportpce-renderer:service-rate": "10",
"transportpce-renderer:clli": "nodeSA",
"transportpce-renderer:node-id": "SPDR-SA1"
},
"transportpce-renderer:service-z-end": {
"transportpce-renderer:service-format": "Ethernet",
"transportpce-renderer:service-rate": "10",
"transportpce-renderer:clli": "nodeSC",
"transportpce-renderer:node-id": "SPDR-SC1"
},
"transportpce-renderer:path-description": {
"aToZ-direction": {
"rate": 10,
"trib-port-number": 1,
"trib-slot-number": 1,
"aToZ": [
{
"id": "0",
"resource": {
"tp-node-id": "SPDR-SA1-XPDR1",
"tp-id": "XPDR1-CLIENT1"
}
},
{
"id": "1",
"resource": {
"tp-node-id": "SPDR-SA1-XPDR1",
"tp-id": "XPDR1-NETWORK1"
}
},
{
"id": "2",
"resource": {
"tp-node-id": "SPDR-SC1-XPDR1",
"tp-id": "XPDR1-NETWORK1"
}
},
{
"id": "3",
"resource": {
"tp-node-id": "SPDR-SC1-XPDR1",
"tp-id": "XPDR1-CLIENT1"
}
}
]
},
"transportpce-renderer:zToA-direction": {
"rate": "10",
"trib-port-number": 1,
"trib-slot-number": 1,
"zToA": [
{
"id": "0",
"resource": {
"tp-node-id": "SPDR-SC1-XPDR1",
"tp-id": "XPDR1-CLIENT1"
}
},
{
"id": "1",
"resource": {
"tp-node-id": "SPDR-SC1-XPDR1",
"tp-id": "XPDR1-NETWORK1"
}
},
{
"id": "2",
"resource": {
"tp-node-id": "SPDR-SA1-XPDR1",
"tp-id": "XPDR1-NETWORK1"
}
},
{
"id": "3",
"resource": {
"tp-node-id": "SPDR-SA1-XPDR1",
"tp-id": "XPDR1-CLIENT1"
}
}
]
}
}
}
}
response = test_utils.post_request(url, data)
time.sleep(3)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Operation Successful',
res["output"]["configuration-response-common"]
["response-message"])
