tests/transportpce_tests/2.2.1/test05_flex_grid.py

   1 #!/usr/bin/env python
   2
   3 ##############################################################################
   4 # Copyright (c) 2019 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 import unittest
  13 import time
  14 import requests
  15 # pylint: disable=wrong-import-order
  16 import sys
  17 sys.path.append('transportpce_tests/common/')
  18 # pylint: disable=wrong-import-position
  19 # pylint: disable=import-error
  20 import test_utils  # nopep8
  21
  22
  23 class TransportPCEPortMappingTesting(unittest.TestCase):
  24
  25     processes = None
  26     NODE_VERSION = '2.2.1'
  27
  28     @classmethod
  29     def setUpClass(cls):
  30         cls.processes = test_utils.start_tpce()
  31         cls.processes = test_utils.start_sims([('roadmd', cls.NODE_VERSION)])
  32
  33     @classmethod
  34     def tearDownClass(cls):
  35         for process in cls.processes:
  36             test_utils.shutdown_process(process)
  37         print("all processes killed")
  38
  39     def setUp(self):
  40         # pylint: disable=consider-using-f-string
  41         print("execution of {}".format(self.id().split(".")[-1]))
  42         time.sleep(10)
  43
  44     def test_01_rdm_device_connection(self):
  45         response = test_utils.mount_device("ROADM-D1", ('roadmd', self.NODE_VERSION))
  46         self.assertEqual(response.status_code, requests.codes.created,
  47                          test_utils.CODE_SHOULD_BE_201)
  48
  49     def test_02_rdm_device_connected(self):
  50         response = test_utils.get_netconf_oper_request("ROADM-D1")
  51         self.assertEqual(response.status_code, requests.codes.ok)
  52         res = response.json()
  53         self.assertEqual(
  54             res['node'][0]['netconf-node-topology:connection-status'],
  55             'connected')
  56         time.sleep(10)
  57
  58     def test_03_rdm_portmapping_info(self):
  59         response = test_utils.portmapping_request("ROADM-D1/node-info")
  60         self.assertEqual(response.status_code, requests.codes.ok)
  61         res = response.json()
  62         self.assertEqual(
  63             {'node-info': {'node-type': 'rdm',
  64                            'node-ip-address': '127.0.0.14',
  65                            'node-clli': 'NodeD',
  66                            'openroadm-version': '2.2.1',
  67                            'node-vendor': 'vendorD',
  68                            'node-model': 'model2',
  69                            }},
  70             res)
  71         time.sleep(3)
  72
  73     def test_04_rdm_deg1_lcp(self):
  74         response = test_utils.portmapping_request("ROADM-D1/mc-capabilities/DEG1-TTP")
  75         self.assertEqual(response.status_code, requests.codes.ok)
  76         res = response.json()
  77         self.assertEqual(
  78             {
  79                 "mc-capabilities": [
  80                     {
  81                         "mc-node-name": "DEG1-TTP",
  82                         "center-freq-granularity": 6.25,
  83                         "slot-width-granularity": 12.5
  84                     }
  85                 ]
  86             }, res)
  87         time.sleep(3)
  88
  89     def test_05_rdm_deg2_lcp(self):
  90         response = test_utils.portmapping_request("ROADM-D1/mc-capabilities/DEG2-TTP")
  91         self.assertEqual(response.status_code, requests.codes.ok)
  92         res = response.json()
  93         self.assertEqual(
  94             {
  95                 "mc-capabilities": [
  96                     {
  97                         "mc-node-name": "DEG2-TTP",
  98                         "center-freq-granularity": 6.25,
  99                         "slot-width-granularity": 12.5
 100                     }
 101                 ]
 102             }, res)
 103         time.sleep(3)
 104
 105     def test_06_rdm_srg1_lcp(self):
 106         response = test_utils.portmapping_request("ROADM-D1/mc-capabilities/SRG1-PP")
 107         self.assertEqual(response.status_code, requests.codes.ok)
 108         res = response.json()
 109         self.assertEqual(
 110             {
 111                 "mc-capabilities": [
 112                     {
 113                         "mc-node-name": "SRG1-PP",
 114                         "center-freq-granularity": 6.25,
 115                         "slot-width-granularity": 12.5
 116                     }
 117                 ]
 118             }, res)
 119         time.sleep(3)
 120
 121     # Renderer interface creations
 122     def test_07_device_renderer(self):
 123         data = {
 124             "transportpce-device-renderer:input": {
 125                 "transportpce-device-renderer:modulation-format": "dp-qpsk",
 126                 "transportpce-device-renderer:operation": "create",
 127                 "transportpce-device-renderer:service-name": "testNMC-MC",
 128                 "transportpce-device-renderer:wave-number": "0",
 129                 "transportpce-device-renderer:center-freq": "196.05",
 130                 "transportpce-device-renderer:width": "80",
 131                 "transportpce-device-renderer:nodes": [
 132                     {
 133                         "transportpce-device-renderer:node-id": "ROADM-D1",
 134                         "transportpce-device-renderer:src-tp": "SRG1-PP1-TXRX",
 135                         "transportpce-device-renderer:dest-tp": "DEG1-TTP-TXRX"
 136                     }
 137                 ],
 138                 "transportpce-device-renderer:min-freq": 196.00625,
 139                 "transportpce-device-renderer:max-freq": 196.09375,
 140                 "transportpce-device-renderer:lower-spectral-slot-number": 749,
 141                 "transportpce-device-renderer:higher-spectral-slot-number": 763
 142             }
 143         }
 144         url = test_utils.RESTCONF_BASE_URL + \
 145             "/operations/transportpce-device-renderer:service-path"
 146         response = test_utils.post_request(url, data)
 147         self.assertEqual(response.status_code, requests.codes.ok)
 148         res = response.json()
 149         self.assertIn('Roadm-connection successfully created for nodes',
 150                       res['output']['result'])
 151         time.sleep(10)
 152
 153     # Get Degree MC interface and check
 154     def test_08_degree_mc_interface(self):
 155         response = test_utils.check_netconf_node_request("ROADM-D1",
 156                                                          "interface/DEG1-TTP-TXRX-mc-749:763")
 157         self.assertEqual(response.status_code, requests.codes.ok)
 158         res = response.json()
 159         self.assertDictEqual(
 160             dict({"name": "DEG1-TTP-TXRX-mc-749:763",
 161                   "supporting-interface": "OMS-DEG1-TTP-TXRX",
 162                   "supporting-circuit-pack-name": "1/0",
 163                   "circuit-id": "TBD",
 164                   "description": "TBD",
 165                   "supporting-port": "L1",
 166                   "type": "org-openroadm-interfaces:mediaChannelTrailTerminationPoint"},
 167                  **res['interface'][0]),
 168             res['interface'][0])
 169
 170         # Check the mc-ttp max and min-freq
 171         self.assertEqual({
 172             "min-freq": 196.00625,
 173             "max-freq": 196.09375
 174         },
 175             res['interface'][0]['org-openroadm-media-channel-interfaces:mc-ttp'])
 176         time.sleep(3)
 177
 178     # get DEG-NMC interface and check
 179     def test_09_degree_nmc_interface(self):
 180         response = test_utils.check_netconf_node_request("ROADM-D1",
 181                                                          "interface/DEG1-TTP-TXRX-nmc-749:763")
 182         self.assertEqual(response.status_code, requests.codes.ok)
 183         res = response.json()
 184         self.assertDictEqual(
 185             dict({"name": "DEG1-TTP-TXRX-nmc-749:763",
 186                   "supporting-interface": "DEG1-TTP-TXRX-mc-749:763",
 187                   "supporting-circuit-pack-name": "1/0",
 188                   "circuit-id": "TBD",
 189                   "description": "TBD",
 190                   "supporting-port": "L1",
 191                   "type": "org-openroadm-interfaces:networkMediaChannelConnectionTerminationPoint"},
 192                  **res['interface'][0]),
 193             res['interface'][0])
 194
 195         # Check the mc-ttp max and min-freq
 196         self.assertEqual({
 197             "frequency": 196.05,
 198             "width": 80
 199         },
 200             res['interface'][0]['org-openroadm-network-media-channel-interfaces:nmc-ctp'])
 201         time.sleep(3)
 202
 203     # get SRG-NMC interface
 204     def test_10_srg_nmc_interface(self):
 205         response = test_utils.check_netconf_node_request("ROADM-D1",
 206                                                          "interface/SRG1-PP1-TXRX-nmc-749:763")
 207         res = response.json()
 208         self.assertEqual(response.status_code, requests.codes.ok)
 209         self.assertEqual(
 210             dict({"name": "SRG1-PP1-TXRX-nmc-749:763",
 211                   "supporting-circuit-pack-name": "3/0",
 212                   "circuit-id": "TBD",
 213                   "description": "TBD",
 214                   "supporting-port": "C1",
 215                   "type": "org-openroadm-interfaces:networkMediaChannelConnectionTerminationPoint"},
 216                  **res['interface'][0]), res['interface'][0])
 217         self.assertEqual({"frequency": 196.05, "width": 80},
 218                          res['interface'][0]['org-openroadm-network-media-channel-interfaces:nmc-ctp'])
 219         time.sleep(3)
 220
 221     # Create ROADM-connection
 222     def test_11_roadm_connection(self):
 223         response = test_utils.check_netconf_node_request("ROADM-D1",
 224                                                          "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-749:763")
 225         self.assertEqual(response.status_code, requests.codes.ok)
 226         res = response.json()
 227         self.assertEqual("SRG1-PP1-TXRX-DEG1-TTP-TXRX-749:763",
 228                          res['roadm-connections'][0]['connection-name'])
 229         self.assertEqual("SRG1-PP1-TXRX-nmc-749:763",
 230                          res['roadm-connections'][0]['source']['src-if'])
 231         self.assertEqual("DEG1-TTP-TXRX-nmc-749:763",
 232                          res['roadm-connections'][0]['destination']['dst-if'])
 233         time.sleep(3)
 234
 235     # Delete ROADM connections and interfaces
 236
 237     # delete ROADM connection
 238     def test_12_delete_roadm_connection(self):
 239         response = test_utils.delete_request(test_utils.URL_CONFIG_NETCONF_TOPO +
 240                                              "node/ROADM-D1/yang-ext:mount/" +
 241                                              "org-openroadm-device:org-openroadm-device/" +
 242                                              "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-749:763")
 243         self.assertEqual(response.status_code, requests.codes.ok)
 244         time.sleep(3)
 245
 246     # Delete NMC SRG interface
 247     def test_13_delete_srg_interface(self):
 248         response = test_utils.delete_request(test_utils.URL_CONFIG_NETCONF_TOPO +
 249                                              "node/ROADM-D1/yang-ext:mount/" +
 250                                              "org-openroadm-device:org-openroadm-device/" +
 251                                              "interface/SRG1-PP1-TXRX-nmc-749:763")
 252         self.assertEqual(response.status_code, requests.codes.ok)
 253         time.sleep(3)
 254
 255     # Delete NMC Degree interface
 256     def test_14_delete_degree_interface(self):
 257         response = test_utils.delete_request(test_utils.URL_CONFIG_NETCONF_TOPO +
 258                                              "node/ROADM-D1/yang-ext:mount/" +
 259                                              "org-openroadm-device:org-openroadm-device/" +
 260                                              "interface/DEG1-TTP-TXRX-nmc-749:763")
 261         self.assertEqual(response.status_code, requests.codes.ok)
 262         time.sleep(3)
 263
 264     # Delete MC Degree interface
 265     def test_15_delete_degree_interface(self):
 266         response = test_utils.delete_request(test_utils.URL_CONFIG_NETCONF_TOPO +
 267                                              "node/ROADM-D1/yang-ext:mount/" +
 268                                              "org-openroadm-device:org-openroadm-device/" +
 269                                              "interface/DEG1-TTP-TXRX-mc-749:763")
 270         self.assertEqual(response.status_code, requests.codes.ok)
 271         time.sleep(3)
 272
 273
 274 if __name__ == "__main__":
 275     unittest.main(verbosity=2)