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