tests/transportpce_tests/1.2.1/test_renderer_service_path_nominal.py

   1 #!/usr/bin/env python
   2
   3 #############################################################################
   4 # Copyright (c) 2017 Orange, Inc. and others.  All rights reserved.
   5 #
   6 # All rights reserved. This program and the accompanying materials
   7 # are made available under the terms of the Apache License, Version 2.0
   8 # which accompanies this distribution, and is available at
   9 # http://www.apache.org/licenses/LICENSE-2.0
  10 #############################################################################
  11
  12 # pylint: disable=no-member
  13 # pylint: disable=too-many-public-methods
  14
  15 import unittest
  16 import time
  17 import requests
  18 import sys
  19 sys.path.append('transportpce_tests/common/')
  20 import test_utils
  21
  22 class TransportPCERendererTesting(unittest.TestCase):
  23
  24     processes = None
  25     NODE_VERSION = '1.2.1'
  26
  27     @classmethod
  28     def setUpClass(cls):
  29         cls.processes = test_utils.start_tpce()
  30         cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION)])
  31
  32     @classmethod
  33     def tearDownClass(cls):
  34         # pylint: disable=not-an-iterable
  35         for process in cls.processes:
  36             test_utils.shutdown_process(process)
  37         print("all processes killed")
  38
  39     def setUp(self):
  40         print("execution of {}".format(self.id().split(".")[-1]))
  41         time.sleep(10)
  42
  43     def test_01_rdm_device_connected(self):
  44         response = test_utils.mount_device("ROADMA01", ('roadma', self.NODE_VERSION))
  45         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  46
  47     def test_02_xpdr_device_connected(self):
  48         response = test_utils.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION))
  49         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  50
  51     def test_03_rdm_portmapping(self):
  52         response = test_utils.portmapping_request("ROADMA01")
  53         self.assertEqual(response.status_code, requests.codes.ok)
  54         res = response.json()
  55         self.assertIn(
  56             {'supporting-port': 'L1', 'supporting-circuit-pack-name': '2/0',
  57              'logical-connection-point': 'DEG1-TTP-TXRX', 'port-direction': 'bidirectional',
  58              'port-admin-state': 'InService', 'port-oper-state': 'InService'},
  59             res['nodes'][0]['mapping'])
  60         self.assertIn(
  61             {'supporting-port': 'C7', 'supporting-circuit-pack-name': '4/0',
  62              'logical-connection-point': 'SRG1-PP7-TXRX', 'port-direction': 'bidirectional',
  63              'port-admin-state': 'InService', 'port-oper-state': 'InService'},
  64             res['nodes'][0]['mapping'])
  65
  66     def test_04_xpdr_portmapping(self):
  67         response = test_utils.portmapping_request("XPDRA01")
  68         self.assertEqual(response.status_code, requests.codes.ok)
  69         res = response.json()
  70         self.assertIn(
  71             {'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
  72              'logical-connection-point': 'XPDR1-NETWORK1', 'port-direction': 'bidirectional',
  73              'connection-map-lcp': 'XPDR1-CLIENT1', 'port-qual': 'xpdr-network',
  74              'lcp-hash-val': 'OSvMgUyP+mE=',
  75              'port-admin-state': 'InService', 'port-oper-state': 'InService'},
  76             res['nodes'][0]['mapping'])
  77         self.assertIn(
  78             {'supporting-port': 'C1',
  79              'supporting-circuit-pack-name': '1/0/C1-PLUG-CLIENT',
  80              'logical-connection-point': 'XPDR1-CLIENT1', 'port-direction': 'bidirectional',
  81              'connection-map-lcp': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-client',
  82              'lcp-hash-val': 'AO9UFkY/TLYw',
  83              'port-admin-state': 'InService', 'port-oper-state': 'InService'},
  84             res['nodes'][0]['mapping'])
  85
  86     def test_05_service_path_create(self):
  87         response = test_utils.service_path_request("create", "service_test", "7",
  88                                                    [{"renderer:node-id": "ROADMA01",
  89                                                      "renderer:src-tp": "SRG1-PP7-TXRX",
  90                                                      "renderer:dest-tp": "DEG1-TTP-TXRX"},
  91                                                     {"renderer:node-id": "XPDRA01",
  92                                                      "renderer:src-tp": "XPDR1-CLIENT1",
  93                                                      "renderer:dest-tp": "XPDR1-NETWORK1"}],
  94                                                    195.8, 40, 195.775, 195.825, 713,
  95                                                    720)
  96         print(response.json())
  97         self.assertEqual(response.status_code, requests.codes.ok)
  98         res = response.json()
  99         self.assertIn('Roadm-connection successfully created for nodes: ROADMA01', res["output"]["result"])
 100
 101     def test_06_service_path_create_rdm_check(self):
 102         response = test_utils.check_netconf_node_request("ROADMA01", "interface/DEG1-TTP-TXRX-713:720")
 103         self.assertEqual(response.status_code, requests.codes.ok)
 104         res = response.json()
 105         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
 106         self.assertDictEqual(
 107             dict({
 108                 'name': 'DEG1-TTP-TXRX-713:720',
 109                 'administrative-state': 'inService',
 110                 'supporting-circuit-pack-name': '2/0',
 111                 'type': 'org-openroadm-interfaces:opticalChannel',
 112                 'supporting-port': 'L1'
 113             }, **res['interface'][0]),
 114             res['interface'][0]
 115         )
 116         self.assertDictEqual(
 117             {'wavelength-number': 7},
 118             res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
 119
 120     def test_07_service_path_create_rdm_check(self):
 121         response = test_utils.check_netconf_node_request("ROADMA01", "interface/SRG1-PP7-TXRX-713:720")
 122         self.assertEqual(response.status_code, requests.codes.ok)
 123         res = response.json()
 124         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
 125         self.assertDictEqual(
 126             dict({
 127                 'name': 'SRG1-PP7-TXRX-713:720',
 128                 'administrative-state': 'inService',
 129                 'supporting-circuit-pack-name': '4/0',
 130                 'type': 'org-openroadm-interfaces:opticalChannel',
 131                 'supporting-port': 'C7'
 132             }, **res['interface'][0]),
 133             res['interface'][0]
 134         )
 135         self.assertDictEqual(
 136             {'wavelength-number': 7},
 137             res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
 138
 139     def test_08_service_path_create_rdm_check(self):
 140         response = test_utils.check_netconf_node_request(
 141             "ROADMA01", "roadm-connections/SRG1-PP7-TXRX-DEG1-TTP-TXRX-713:720")
 142         self.assertEqual(response.status_code, requests.codes.ok)
 143         res = response.json()
 144         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
 145         self.assertDictEqual(
 146             dict({
 147                 'connection-number': 'SRG1-PP7-TXRX-DEG1-TTP-TXRX-713:720',
 148                 'wavelength-number': 7,
 149                 'opticalControlMode': 'off'
 150             }, **res['roadm-connections'][0]),
 151             res['roadm-connections'][0]
 152         )
 153         self.assertDictEqual(
 154             {'src-if': 'SRG1-PP7-TXRX-713:720'},
 155             res['roadm-connections'][0]['source'])
 156         self.assertDictEqual(
 157             {'dst-if': 'DEG1-TTP-TXRX-713:720'},
 158             res['roadm-connections'][0]['destination'])
 159
 160     def test_09_service_path_create_xpdr_check(self):
 161         response = test_utils.check_netconf_node_request("XPDRA01", "interface/XPDR1-NETWORK1-713:720")
 162         self.assertEqual(response.status_code, requests.codes.ok)
 163         res = response.json()
 164         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
 165         self.assertDictEqual(
 166             dict({
 167                 'name': 'XPDR1-NETWORK1-713:720',
 168                 'administrative-state': 'inService',
 169                 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
 170                 'type': 'org-openroadm-interfaces:opticalChannel',
 171                 'supporting-port': '1'
 172             }, **res['interface'][0]),
 173             res['interface'][0]
 174         )
 175         self.assertDictEqual(
 176             {u'rate': u'org-openroadm-optical-channel-interfaces:R100G',
 177              u'transmit-power': -5,
 178              u'wavelength-number': 7,
 179              u'modulation-format': u'dp-qpsk'},
 180             res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
 181
 182     def test_10_service_path_create_xpdr_check(self):
 183         response = test_utils.check_netconf_node_request("XPDRA01", "interface/XPDR1-NETWORK1-OTU")
 184         self.assertEqual(response.status_code, requests.codes.ok)
 185         res = response.json()
 186         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
 187         self.assertDictEqual(
 188             dict({
 189                 'name': 'XPDR1-NETWORK1-OTU',
 190                 'administrative-state': 'inService',
 191                 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
 192                 'type': 'org-openroadm-interfaces:otnOtu',
 193                 'supporting-port': '1',
 194                 'supporting-interface': 'XPDR1-NETWORK1-713:720'
 195             }, **res['interface'][0]),
 196             res['interface'][0]
 197         )
 198         self.assertDictEqual(
 199             {u'rate': u'org-openroadm-otn-otu-interfaces:OTU4',
 200              u'fec': u'scfec'},
 201             res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
 202
 203     def test_11_service_path_create_xpdr_check(self):
 204         response = test_utils.check_netconf_node_request("XPDRA01", "interface/XPDR1-NETWORK1-ODU")
 205         self.assertEqual(response.status_code, requests.codes.ok)
 206         res = response.json()
 207         # the 2 following statements replace self.assertDictContainsSubset deprecated in python 3.2
 208         self.assertDictEqual(
 209             dict({
 210                 'name': 'XPDR1-NETWORK1-ODU',
 211                 'administrative-state': 'inService',
 212                 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
 213                 'type': 'org-openroadm-interfaces:otnOdu',
 214                 'supporting-port': '1',
 215                 'supporting-interface': 'XPDR1-NETWORK1-OTU'
 216             }, **res['interface'][0]),
 217             res['interface'][0]
 218         )
 219         self.assertDictEqual(
 220             dict({
 221                 'rate': 'org-openroadm-otn-odu-interfaces:ODU4',
 222                 u'monitoring-mode': u'terminated'
 223             }, **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 224             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 225         )
 226         self.assertDictEqual({u'exp-payload-type': u'07', u'payload-type': u'07'},
 227                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 228
 229     def test_12_service_path_create_xpdr_check(self):
 230         response = test_utils.check_netconf_node_request("XPDRA01", "interface/XPDR1-CLIENT1-ETHERNET")
 231         self.assertEqual(response.status_code, requests.codes.ok)
 232         res = response.json()
 233         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
 234         self.assertDictEqual(
 235             dict({
 236                 'name': 'XPDR1-CLIENT1-ETHERNET',
 237                 'administrative-state': 'inService',
 238                 'supporting-circuit-pack-name': '1/0/C1-PLUG-CLIENT',
 239                 'type': 'org-openroadm-interfaces:ethernetCsmacd',
 240                 'supporting-port': 'C1'
 241             }, **res['interface'][0]),
 242             res['interface'][0]
 243         )
 244         self.assertDictEqual(
 245             {'speed': 100000,
 246              'mtu': 9000,
 247              'auto-negotiation': 'enabled',
 248              'duplex': 'full',
 249              'fec': 'off'},
 250             res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
 251
 252     def test_13_service_path_create_xpdr_check(self):
 253         response = test_utils.check_netconf_node_request("XPDRA01", "circuit-packs/1%2F0%2F1-PLUG-NET")
 254         self.assertEqual(response.status_code, requests.codes.ok)
 255         res = response.json()
 256         self.assertIn('not-reserved-inuse', res['circuit-packs'][0]["equipment-state"])
 257
 258     def test_14_service_path_delete(self):
 259         response = test_utils.service_path_request("delete", "service_test", "7",
 260                                                    [{"renderer:node-id": "ROADMA01",
 261                                                      "renderer:src-tp": "SRG1-PP7-TXRX",
 262                                                      "renderer:dest-tp": "DEG1-TTP-TXRX"},
 263                                                     {"renderer:node-id": "XPDRA01",
 264                                                      "renderer:src-tp": "XPDR1-CLIENT1",
 265                                                      "renderer:dest-tp": "XPDR1-NETWORK1"}],
 266                                                    195.8, 40, 195.775, 195.825, 713,
 267                                                    720)
 268         self.assertEqual(response.status_code, requests.codes.ok)
 269         self.assertEqual(response.json(), {
 270             'output': {'result': 'Request processed', 'success': True}})
 271
 272     def test_15_service_path_delete_rdm_check(self):
 273         response = test_utils.check_netconf_node_request("ROADMA01", "interface/DEG1-TTP-TXRX-713:720")
 274         self.assertEqual(response.status_code, requests.codes.conflict)
 275         res = response.json()
 276         self.assertIn(
 277             {"error-type": "application", "error-tag": "data-missing",
 278              "error-message": "Request could not be completed because the relevant data model content does not exist"},
 279             res['errors']['error'])
 280
 281     def test_16_service_path_delete_rdm_check(self):
 282         response = test_utils.check_netconf_node_request("ROADMA01", "interface/SRG1-PP7-TXRX-713:720")
 283         self.assertEqual(response.status_code, requests.codes.conflict)
 284         res = response.json()
 285         self.assertIn(
 286             {"error-type": "application", "error-tag": "data-missing",
 287                 "error-message":
 288                     "Request could not be completed because the relevant data model content does not exist"},
 289             res['errors']['error'])
 290
 291     def test_17_service_path_delete_rdm_check(self):
 292         response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP7-TXRX-DEG1-TTP-TXRX-713:720")
 293         self.assertEqual(response.status_code, requests.codes.conflict)
 294         res = response.json()
 295         self.assertIn(
 296             {"error-type": "application", "error-tag": "data-missing",
 297                 "error-message":
 298                     "Request could not be completed because the relevant data model content does not exist"},
 299             res['errors']['error'])
 300
 301     def test_18_service_path_delete_xpdr_check(self):
 302         response = test_utils.check_netconf_node_request("XPDRA01", "interface/XPDR1-NETWORK1-713:720")
 303         self.assertEqual(response.status_code, requests.codes.conflict)
 304         res = response.json()
 305         self.assertIn(
 306             {"error-type": "application", "error-tag": "data-missing",
 307                 "error-message":
 308                     "Request could not be completed because the relevant data model content does not exist"},
 309             res['errors']['error'])
 310
 311     def test_19_service_path_delete_xpdr_check(self):
 312         response = test_utils.check_netconf_node_request("XPDRA01", "interface/XPDR1-NETWORK1-OTU")
 313         self.assertEqual(response.status_code, requests.codes.conflict)
 314         res = response.json()
 315         self.assertIn(
 316             {"error-type": "application", "error-tag": "data-missing",
 317                 "error-message":
 318                     "Request could not be completed because the relevant data model content does not exist"},
 319             res['errors']['error'])
 320
 321     def test_20_service_path_delete_xpdr_check(self):
 322         response = test_utils.check_netconf_node_request("XPDRA01", "interface/XPDR1-NETWORK1-ODU")
 323         self.assertEqual(response.status_code, requests.codes.conflict)
 324         res = response.json()
 325         self.assertIn(
 326             {"error-type": "application", "error-tag": "data-missing",
 327                 "error-message":
 328                     "Request could not be completed because the relevant data model content does not exist"},
 329             res['errors']['error'])
 330
 331     def test_21_service_path_delete_xpdr_check(self):
 332         response = test_utils.check_netconf_node_request("XPDRA01", "interface/XPDR1-CLIENT1-ETHERNET")
 333         self.assertEqual(response.status_code, requests.codes.conflict)
 334         res = response.json()
 335         self.assertIn(
 336             {"error-type": "application", "error-tag": "data-missing",
 337                 "error-message":
 338                     "Request could not be completed because the relevant data model content does not exist"},
 339             res['errors']['error'])
 340
 341     def test_22_service_path_delete_xpdr_check(self):
 342         response = test_utils.check_netconf_node_request("XPDRA01", "circuit-packs/1%2F0%2F1-PLUG-NET")
 343         self.assertEqual(response.status_code, requests.codes.ok)
 344         res = response.json()
 345         self.assertEqual('not-reserved-available', res["circuit-packs"][0]['equipment-state'])
 346
 347     def test_23_rdm_device_disconnected(self):
 348         response = test_utils.unmount_device("ROADMA01")
 349         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 350
 351     def test_24_xpdr_device_disconnected(self):
 352         response = test_utils.unmount_device("XPDRA01")
 353         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 354
 355
 356 if __name__ == "__main__":
 357     unittest.main(verbosity=2, failfast=False)