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