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