Code Review / transportpce.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Flexgrid for pce and network model
[transportpce.git] / tests / transportpce_tests / 1.2.1 / test_end2end.py
diff --git a/tests/transportpce_tests/1.2.1/test_end2end.py b/tests/transportpce_tests/1.2.1/test_end2end.py
index 42bb94e5580a7cb6423133aa9eb00a29d2713071..ce1191068729608b21e616f39778a47773256d29 100644 (file)
--- a/tests/transportpce_tests/1.2.1/test_end2end.py
+++ b/tests/transportpce_tests/1.2.1/test_end2end.py
@@ -17,8 +17,6 @@ import unittest
 
 import requests
 from common import test_utils
-from common.flexgrid_utils import INDEX_1_USED_FREQ_MAP, INDEX_1_2_USED_FREQ_MAP, AVAILABLE_FREQ_MAP, check_freq_map
-
 
 class TransportPCEFulltesting(unittest.TestCase):
     cr_serv_sample_data = {"input": {
@@ -296,16 +294,13 @@ class TransportPCEFulltesting(unittest.TestCase):
         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
         for ele in liste_tp:
             if ele['tp-id'] == 'XPDR1-NETWORK1':
-                self.assertEqual({u'frequency': 196.1, u'width': 40},
+                self.assertEqual({u'frequency': 196.1,
+                                  u'width': 40},
                                  ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
-            if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3':
-                self.assertNotIn(
-                    'org-openroadm-network-topology:xpdr-client-attributes',
-                    dict.keys(ele))
+            if ele['tp-id'] == 'XPDR1-CLIENT2' or ele['tp-id'] == 'XPDR1-CLIENT1':
+                self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
             if ele['tp-id'] == 'XPDR1-NETWORK2':
-                self.assertNotIn(
-                    'org-openroadm-network-topology:xpdr-network-attributes',
-                    dict.keys(ele))
+                self.assertNotIn('org-openroadm-network-topology:xpdr-network-attributes', dict.keys(ele))
         time.sleep(3)
 
     def test_16_check_topo_ROADMA_SRG1(self):
@@ -315,16 +310,16 @@ class TransportPCEFulltesting(unittest.TestCase):
         freq_map = base64.b64decode(
             res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
         freq_map_array = [int(x) for x in freq_map]
-        self.assertEqual(freq_map_array[0], 0, "Index 1 should not be available")
+        self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
         for ele in liste_tp:
             if ele['tp-id'] == 'SRG1-PP1-TXRX':
-                self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
-                              ele['org-openroadm-network-topology:'
-                                  'pp-attributes']['used-wavelength']
-                              )
+                freq_map = base64.b64decode(
+                    ele['org-openroadm-network-topology:pp-attributes']['avail-freq-maps'][0]['freq-map'])
+                freq_map_array = [int(x) for x in freq_map]
+                self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
             if ele['tp-id'] == 'SRG1-PP2-TXRX':
-                self.assertNotIn('used-wavelength', dict.keys(ele))
+                self.assertNotIn('avail-freq-maps', dict.keys(ele))
         time.sleep(3)
 
     def test_17_check_topo_ROADMA_DEG1(self):
@@ -334,20 +329,19 @@ class TransportPCEFulltesting(unittest.TestCase):
         freq_map = base64.b64decode(
             res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
         freq_map_array = [int(x) for x in freq_map]
-        self.assertEqual(freq_map_array[0], 0, "Index 1 should not be available")
+        self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
         for ele in liste_tp:
-            if ele['tp-id'] == 'DEG1-CTP-TXRX':
-                self.assertIn({u'map-name': 'cband', u'freq-map-granularity': 6.25, u'start-edge-freq': 191.325,
-                               u'effective-bits': 768, u'freq-map': INDEX_1_USED_FREQ_MAP},
-                              ele['org-openroadm-network-topology:'
-                                  'ctp-attributes'][
-                                  'avail-freq-maps'])
-            if ele['tp-id'] == 'DEG1-TTP-TXRX':
-                self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
-                              ele['org-openroadm-network-topology:'
-                                  'tx-ttp-attributes'][
-                                  'used-wavelengths'])
+            if ele['tp-id'] == 'DEG2-CTP-TXRX':
+                freq_map = base64.b64decode(
+                    ele['org-openroadm-network-topology:ctp-attributes']['avail-freq-maps'][0]['freq-map'])
+                freq_map_array = [int(x) for x in freq_map]
+                self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
+            if ele['tp-id'] == 'DEG2-TTP-TXRX':
+                    freq_map = base64.b64decode(
+                        ele['org-openroadm-network-topology:tx-ttp-attributes']['avail-freq-maps'][0]['freq-map'])
+                    freq_map_array = [int(x) for x in freq_map]
+                    self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
         time.sleep(3)
 
     def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
@@ -438,20 +432,15 @@ class TransportPCEFulltesting(unittest.TestCase):
         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
         for ele in liste_tp:
             if ele['tp-id'] == 'XPDR1-NETWORK1':
-                self.assertEqual({u'frequency': 196.1, u'width': 40},
-                                 ele['org-openroadm-network-topology:'
-                                     'xpdr-network-attributes'][
-                                     'wavelength'])
+                self.assertEqual({u'frequency': 196.1,
+                                  u'width': 40},
+                                 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
             if ele['tp-id'] == 'XPDR1-NETWORK2':
-                self.assertEqual({u'frequency': 196.05, u'width': 40},
-                                 ele['org-openroadm-network-topology:'
-                                     'xpdr-network-attributes'][
-                                     'wavelength'])
-            if ele['tp-id'] == 'XPDR1-CLIENT1' or \
-                    ele['tp-id'] == 'XPDR1-CLIENT3':
-                self.assertNotIn(
-                    'org-openroadm-network-topology:xpdr-client-attributes',
-                    dict.keys(ele))
+                self.assertEqual({u'frequency': 196.05,
+                                  u'width': 40},
+                                 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
+            if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT2':
+                self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
         time.sleep(10)
 
     def test_26_check_topo_ROADMA_SRG1(self):
@@ -461,29 +450,24 @@ class TransportPCEFulltesting(unittest.TestCase):
         freq_map = base64.b64decode(
             res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
         freq_map_array = [int(x) for x in freq_map]
-        self.assertEqual(freq_map_array[0], 0, "Index 1 should not be available")
-        self.assertEqual(freq_map_array[1], 0, "Index 2 should not be available")
+        self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
+        self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available")
         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
         for ele in liste_tp:
             if ele['tp-id'] == 'SRG1-PP1-TXRX':
-                self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
-                              ele['org-openroadm-network-topology:'
-                                  'pp-attributes']['used-wavelength'])
-                self.assertNotIn({u'index': 2, u'frequency': 196.05,
-                                  u'width': 40},
-                                 ele['org-openroadm-network-topology:'
-                                     'pp-attributes']['used-wavelength'])
+                freq_map = base64.b64decode(
+                    ele['org-openroadm-network-topology:pp-attributes']['avail-freq-maps'][0]['freq-map'])
+                freq_map_array = [int(x) for x in freq_map]
+                self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
+                self.assertEqual(freq_map_array[94], 255, "Lambda 2 should be available")
             if ele['tp-id'] == 'SRG1-PP2-TXRX':
-                self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
-                              ele['org-openroadm-network-topology:'
-                                  'pp-attributes']['used-wavelength'])
-                self.assertNotIn({u'index': 1, u'frequency': 196.1,
-                                  u'width': 40},
-                                 ele['org-openroadm-network-topology:'
-                                     'pp-attributes']['used-wavelength'])
+                freq_map = base64.b64decode(
+                    ele['org-openroadm-network-topology:pp-attributes']['avail-freq-maps'][0]['freq-map'])
+                freq_map_array = [int(x) for x in freq_map]
+                self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available")
+                self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available")
             if ele['tp-id'] == 'SRG1-PP3-TXRX':
-                self.assertNotIn('org-openroadm-network-topology:pp-attributes',
-                                 dict.keys(ele))
+                self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
         time.sleep(10)
 
     def test_27_check_topo_ROADMA_DEG1(self):
@@ -493,23 +477,22 @@ class TransportPCEFulltesting(unittest.TestCase):
         freq_map = base64.b64decode(
             res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
         freq_map_array = [int(x) for x in freq_map]
-        self.assertEqual(freq_map_array[0], 0, "Index 1 should not be available")
-        self.assertEqual(freq_map_array[1], 0, "Index 2 should not be available")
+        self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
+        self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available")
         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
         for ele in liste_tp:
-            if ele['tp-id'] == 'DEG1-CTP-TXRX':
-                self.assertIn({u'map-name': 'cband', u'freq-map-granularity': 6.25, u'start-edge-freq': 191.325,
-                               u'effective-bits': 768, u'freq-map': INDEX_1_2_USED_FREQ_MAP},
-                              ele['org-openroadm-network-topology:'
-                                  'ctp-attributes'][
-                                  'avail-freq-maps'])
-            if ele['tp-id'] == 'DEG1-TTP-TXRX':
-                self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
-                              ele['org-openroadm-network-topology:'
-                                  'tx-ttp-attributes']['used-wavelengths'])
-                self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
-                              ele['org-openroadm-network-topology:'
-                                  'tx-ttp-attributes']['used-wavelengths'])
+            if ele['tp-id'] == 'DEG2-CTP-TXRX':
+                freq_map = base64.b64decode(
+                    ele['org-openroadm-network-topology:ctp-attributes']['avail-freq-maps'][0]['freq-map'])
+                freq_map_array = [int(x) for x in freq_map]
+                self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
+                self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available")
+            if ele['tp-id'] == 'DEG2-TTP-TXRX':
+                freq_map = base64.b64decode(
+                    ele['org-openroadm-network-topology:tx-ttp-attributes']['avail-freq-maps'][0]['freq-map'])
+                freq_map_array = [int(x) for x in freq_map]
+                self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
+                self.assertEqual(freq_map_array[94], 0, "Lambda 2 should not be available")
         time.sleep(10)
 
     #     creation service test on a non-available resource
@@ -594,10 +577,25 @@ class TransportPCEFulltesting(unittest.TestCase):
         res = response.json()
         freq_map = base64.b64decode(
             res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
-        self.assertTrue(check_freq_map(freq_map), "Index 1 and 2 should be available")
+        freq_map_array = [int(x) for x in freq_map]
+        self.assertEqual(freq_map_array[95], 255, "Lambda 1 should  be available")
+        self.assertEqual(freq_map_array[94], 255, "Lambda 2 should  be available")
         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
         for ele in liste_tp:
-            self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
+            if ele['tp-id'] == 'SRG1-PP1-TXRX' or ele['tp-id'] == 'SRG1-PP2-TXRX':
+                freq_map = base64.b64decode(
+                    ele['org-openroadm-network-topology:pp-attributes']['avail-freq-maps'][0]['freq-map'])
+                freq_map_array = [int(x) for x in freq_map]
+                self.assertEqual(freq_map_array[95], 255, "Lambda 1 should  be available")
+                self.assertEqual(freq_map_array[94], 255, "Lambda 2 should  be available")
+            elif ele['tp-id'] == 'SRG1-CP-TXRX':
+                freq_map = base64.b64decode(
+                    ele['org-openroadm-network-topology:cp-attributes']['avail-freq-maps'][0]['freq-map'])
+                freq_map_array = [int(x) for x in freq_map]
+                self.assertEqual(freq_map_array[95], 255, "Lambda 1 should  be available")
+                self.assertEqual(freq_map_array[94], 255, "Lambda 2 should  be available")
+            else:
+                self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
         time.sleep(10)
 
     def test_35_check_topo_ROADMA_DEG1(self):
@@ -606,15 +604,23 @@ class TransportPCEFulltesting(unittest.TestCase):
         res = response.json()
         freq_map = base64.b64decode(
             res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
-        self.assertTrue(check_freq_map(freq_map), "Index 1 and 2 should be available")
+        freq_map_array = [int(x) for x in freq_map]
+        self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available")
+        self.assertEqual(freq_map_array[94], 255, "Lambda 2 should be available")
         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
         for ele in liste_tp:
-            if ele['tp-id'] == 'DEG1-CTP-TXRX':
-                self.assertEqual(ele['org-openroadm-network-topology:ctp-attributes']['avail-freq-maps'][0]['freq-map'],
-                                 AVAILABLE_FREQ_MAP)
-            if ele['tp-id'] == 'DEG1-TTP-TXRX':
-                self.assertNotIn('org-openroadm-network-topology:'
-                                 'tx-ttp-attributes', dict.keys(ele))
+            if ele['tp-id'] == 'DEG2-CTP-TXRX':
+                freq_map = base64.b64decode(
+                    ele['org-openroadm-network-topology:ctp-attributes']['avail-freq-maps'][0]['freq-map'])
+                freq_map_array = [int(x) for x in freq_map]
+                self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available")
+                self.assertEqual(freq_map_array[94], 255, "Lambda 2 should be available")
+            if ele['tp-id'] == 'DEG2-TTP-TXRX':
+                freq_map = base64.b64decode(
+                    ele['org-openroadm-network-topology:tx-ttp-attributes']['avail-freq-maps'][0]['freq-map'])
+                freq_map_array = [int(x) for x in freq_map]
+                self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available")
+                self.assertEqual(freq_map_array[94], 255, "Lambda 2 should be available")
         time.sleep(10)
 
     # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
Repository for Transport PCE project.