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