diff --git a/src/tests/ofc22/tests/Objects.py b/src/tests/ofc22/tests/Objects.py
index d2fb32ebb20b7bcdda9ac12b7a7390c46e6fb1d1..47f0a262465fbd562da3048b7e6c0e06cfddda2d 100644
--- a/src/tests/ofc22/tests/Objects.py
+++ b/src/tests/ofc22/tests/Objects.py
@@ -1,3 +1,5 @@
+##### LLUIS GIFRE (CTTC): CODE UNDER REARRANGEMENT #####
+
# Copyright 2021-2023 H2020 TeraFlow (https://www.teraflow-h2020.eu/)
#
# Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,6 +14,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+import os, uuid
from typing import Dict, List, Tuple
from common.Constants import DEFAULT_CONTEXT_UUID, DEFAULT_TOPOLOGY_UUID
from common.tools.object_factory.Context import json_context, json_context_id
@@ -23,6 +26,66 @@ from common.tools.object_factory.Link import json_link, json_link_id
from common.tools.object_factory.Topology import json_topology, json_topology_id
from common.proto.kpi_sample_types_pb2 import KpiSampleType
+import os, uuid
+from common.Constants import DEFAULT_CONTEXT_UUID, DEFAULT_TOPOLOGY_UUID
+from common.tools.object_factory.Context import json_context, json_context_id
+from common.tools.object_factory.Device import (
+ json_device_emulated_connect_rules, json_device_emulated_datacenter_disabled,
+ json_device_emulated_packet_router_disabled, json_device_emulated_tapi_disabled, json_device_id)
+from common.tools.object_factory.EndPoint import json_endpoints
+from common.tools.object_factory.Link import get_link_uuid, json_link, json_link_id
+from common.tools.object_factory.Service import get_service_uuid, json_service_l3nm_planned
+from common.tools.object_factory.Topology import json_topology, json_topology_id
+
+
+
+
+# if true, Device component is present and will infeer the endpoints from connect-rules
+# if false, Device component is not present and device objects must contain preconfigured endpoints
+ADD_CONNECT_RULES_TO_DEVICES = os.environ.get('ADD_CONNECT_RULES_TO_DEVICES', 'True')
+ADD_CONNECT_RULES_TO_DEVICES = ADD_CONNECT_RULES_TO_DEVICES.upper() in {'T', 'TRUE', '1', 'Y', 'YES'}
+
+
+
+def compose_router(device_uuid, endpoint_uuids, topology_id=None):
+ device_id = json_device_id(device_uuid)
+ r_endpoints = [(endpoint_uuid, 'copper', []) for endpoint_uuid in endpoint_uuids]
+ config_rules = json_device_emulated_connect_rules(r_endpoints) if ADD_CONNECT_RULES_TO_DEVICES else []
+ endpoints = json_endpoints(device_id, r_endpoints, topology_id=topology_id)
+ j_endpoints = [] if ADD_CONNECT_RULES_TO_DEVICES else endpoints
+ device = json_device_emulated_packet_router_disabled(device_uuid, config_rules=config_rules, endpoints=j_endpoints)
+ return device_id, endpoints, device
+
+def compose_ols(device_uuid, endpoint_uuids, topology_id=None):
+ device_id = json_device_id(device_uuid)
+ r_endpoints = [(endpoint_uuid, 'optical', []) for endpoint_uuid in endpoint_uuids]
+ config_rules = json_device_emulated_connect_rules(r_endpoints) if ADD_CONNECT_RULES_TO_DEVICES else []
+ endpoints = json_endpoints(device_id, r_endpoints, topology_id=topology_id)
+ j_endpoints = [] if ADD_CONNECT_RULES_TO_DEVICES else endpoints
+ device = json_device_emulated_tapi_disabled(device_uuid, config_rules=config_rules, endpoints=j_endpoints)
+ return device_id, endpoints, device
+
+def compose_datacenter(device_uuid, endpoint_uuids, topology_id=None):
+ device_id = json_device_id(device_uuid)
+ r_endpoints = [(endpoint_uuid, 'copper', []) for endpoint_uuid in endpoint_uuids]
+ config_rules = json_device_emulated_connect_rules(r_endpoints) if ADD_CONNECT_RULES_TO_DEVICES else []
+ endpoints = json_endpoints(device_id, r_endpoints, topology_id=topology_id)
+ j_endpoints = [] if ADD_CONNECT_RULES_TO_DEVICES else endpoints
+ device = json_device_emulated_datacenter_disabled(device_uuid, config_rules=config_rules, endpoints=j_endpoints)
+ return device_id, endpoints, device
+
+def compose_link(endpoint_a, endpoint_z):
+ link_uuid = get_link_uuid(endpoint_a['endpoint_id'], endpoint_z['endpoint_id'])
+ link_id = json_link_id(link_uuid)
+ link = json_link(link_uuid, [endpoint_a['endpoint_id'], endpoint_z['endpoint_id']])
+ return link_id, link
+
+def compose_service(endpoint_a, endpoint_z, constraints=[]):
+ service_uuid = get_service_uuid(endpoint_a['endpoint_id'], endpoint_z['endpoint_id'])
+ endpoint_ids = [endpoint_a['endpoint_id'], endpoint_z['endpoint_id']]
+ service = json_service_l3nm_planned(service_uuid, endpoint_ids=endpoint_ids, constraints=constraints)
+ return service
+
# ----- Context --------------------------------------------------------------------------------------------------------
CONTEXT_ID = json_context_id(DEFAULT_CONTEXT_UUID)
CONTEXT = json_context(DEFAULT_CONTEXT_UUID)
@@ -31,6 +94,39 @@ CONTEXT = json_context(DEFAULT_CONTEXT_UUID)
TOPOLOGY_ID = json_topology_id(DEFAULT_TOPOLOGY_UUID, context_id=CONTEXT_ID)
TOPOLOGY = json_topology(DEFAULT_TOPOLOGY_UUID, context_id=CONTEXT_ID)
+# ----- Domains --------------------------------------------------------------------------------------------------------
+# Overall network topology
+TOPO_ADMIN_UUID = DEFAULT_TOPOLOGY_UUID
+TOPO_ADMIN_ID = json_topology_id(TOPO_ADMIN_UUID, context_id=CONTEXT_ID)
+TOPO_ADMIN = json_topology(TOPO_ADMIN_UUID, context_id=CONTEXT_ID)
+
+# DataCenter #1 Network
+TOPO_DC1_UUID = 'DC1'
+TOPO_DC1_ID = json_topology_id(TOPO_DC1_UUID, context_id=CONTEXT_ID)
+TOPO_DC1 = json_topology(TOPO_DC1_UUID, context_id=CONTEXT_ID)
+
+# DataCenter #2 Network
+TOPO_DC2_UUID = 'DC2'
+TOPO_DC2_ID = json_topology_id(TOPO_DC2_UUID, context_id=CONTEXT_ID)
+TOPO_DC2 = json_topology(TOPO_DC2_UUID, context_id=CONTEXT_ID)
+
+# CellSite #1 Network
+TOPO_CS1_UUID = 'CS1'
+TOPO_CS1_ID = json_topology_id(TOPO_CS1_UUID, context_id=CONTEXT_ID)
+TOPO_CS1 = json_topology(TOPO_CS1_UUID, context_id=CONTEXT_ID)
+
+# CellSite #2 Network
+TOPO_CS2_UUID = 'CS2'
+TOPO_CS2_ID = json_topology_id(TOPO_CS2_UUID, context_id=CONTEXT_ID)
+TOPO_CS2 = json_topology(TOPO_CS2_UUID, context_id=CONTEXT_ID)
+
+# Transport Network Network
+TOPO_TN_UUID = 'TN'
+TOPO_TN_ID = json_topology_id(TOPO_TN_UUID, context_id=CONTEXT_ID)
+TOPO_TN = json_topology(TOPO_TN_UUID, context_id=CONTEXT_ID)
+
+
+
# ----- Monitoring Samples ---------------------------------------------------------------------------------------------
PACKET_PORT_SAMPLE_TYPES = [
KpiSampleType.KPISAMPLETYPE_PACKETS_TRANSMITTED,
@@ -161,6 +257,29 @@ DEVICE_O1_CONNECT_RULES = json_device_connect_rules(DEVICE_O1_ADDRESS, DEVICE_O1
}) if USE_REAL_DEVICES else json_device_emulated_connect_rules(DEVICE_O1_ENDPOINT_DEFS)
+# ----- Devices --------------------------------------------------------------------------------------------------------
+# DataCenters
+DEV_DC1GW_ID, DEV_DC1GW_EPS, DEV_DC1GW = compose_datacenter('DC1-GW', ['eth1', 'eth2', 'int'])
+DEV_DC2GW_ID, DEV_DC2GW_EPS, DEV_DC2GW = compose_datacenter('DC2-GW', ['eth1', 'eth2', 'int'])
+
+# CellSites
+DEV_CS1GW1_ID, DEV_CS1GW1_EPS, DEV_CS1GW1 = compose_router('CS1-GW1', ['10/1', '1/1', '1/2'])
+DEV_CS1GW2_ID, DEV_CS1GW2_EPS, DEV_CS1GW2 = compose_router('CS1-GW2', ['10/1', '1/1', '1/2'])
+DEV_CS2GW1_ID, DEV_CS2GW1_EPS, DEV_CS2GW1 = compose_router('CS2-GW1', ['10/1', '1/1', '1/2'])
+DEV_CS2GW2_ID, DEV_CS2GW2_EPS, DEV_CS2GW2 = compose_router('CS2-GW2', ['10/1', '1/1', '1/2'])
+
+# Transport Network
+DEV_TNR1_ID, DEV_TNR1_EPS, DEV_TNR1 = compose_router('TN-R1', ['1/1', '1/2', '2/1'])
+DEV_TNR2_ID, DEV_TNR2_EPS, DEV_TNR2 = compose_router('TN-R2', ['1/1', '1/2', '2/1'])
+DEV_TNR3_ID, DEV_TNR3_EPS, DEV_TNR3 = compose_router('TN-R3', ['1/1', '1/2', '2/1'])
+DEV_TNR4_ID, DEV_TNR4_EPS, DEV_TNR4 = compose_router('TN-R4', ['1/1', '1/2', '2/1'])
+
+#tols_ep_uuids = [str(uuid.uuid4()).split('-')[-1] for _ in range(4)]
+tols_ep_uuids = ['afd8ffbb5403', '04b84e213e83', '3169ae676ac6', '93506f786270']
+DEV_TOLS_ID, DEV_TOLS_EPS, DEV_TOLS = compose_ols('TN-OLS', tols_ep_uuids)
+
+
+
# ----- Links ----------------------------------------------------------------------------------------------------------
LINK_R1_O1_UUID = get_link_uuid(DEVICE_R1_ID, ENDPOINT_ID_R1_13_0_0, DEVICE_O1_ID, ENDPOINT_ID_O1_EP1)
LINK_R1_O1_ID = json_link_id(LINK_R1_O1_UUID)
@@ -179,7 +298,34 @@ LINK_R4_O1_ID = json_link_id(LINK_R4_O1_UUID)
LINK_R4_O1 = json_link(LINK_R4_O1_UUID, [ENDPOINT_ID_R4_13_0_0, ENDPOINT_ID_O1_EP4])
+# ----- Links ----------------------------------------------------------------------------------------------------------
+# InterDomain DC-CSGW
+LINK_DC1GW_CS1GW1_ID, LINK_DC1GW_CS1GW1 = compose_link(DEV_DC1GW_EPS[0], DEV_CS1GW1_EPS[0])
+LINK_DC1GW_CS1GW2_ID, LINK_DC1GW_CS1GW2 = compose_link(DEV_DC1GW_EPS[1], DEV_CS1GW2_EPS[0])
+LINK_DC2GW_CS2GW1_ID, LINK_DC2GW_CS2GW1 = compose_link(DEV_DC2GW_EPS[0], DEV_CS2GW1_EPS[0])
+LINK_DC2GW_CS2GW2_ID, LINK_DC2GW_CS2GW2 = compose_link(DEV_DC2GW_EPS[1], DEV_CS2GW2_EPS[0])
+
+# InterDomain CSGW-TN
+LINK_CS1GW1_TNR1_ID, LINK_CS1GW1_TNR1 = compose_link(DEV_CS1GW1_EPS[1], DEV_TNR1_EPS[0])
+LINK_CS1GW2_TNR2_ID, LINK_CS1GW2_TNR2 = compose_link(DEV_CS1GW2_EPS[1], DEV_TNR2_EPS[0])
+LINK_CS1GW1_TNR2_ID, LINK_CS1GW1_TNR2 = compose_link(DEV_CS1GW1_EPS[2], DEV_TNR2_EPS[1])
+LINK_CS1GW2_TNR1_ID, LINK_CS1GW2_TNR1 = compose_link(DEV_CS1GW2_EPS[2], DEV_TNR1_EPS[1])
+LINK_CS2GW1_TNR3_ID, LINK_CS2GW1_TNR3 = compose_link(DEV_CS2GW1_EPS[1], DEV_TNR3_EPS[0])
+LINK_CS2GW2_TNR4_ID, LINK_CS2GW2_TNR4 = compose_link(DEV_CS2GW2_EPS[1], DEV_TNR4_EPS[0])
+LINK_CS2GW1_TNR4_ID, LINK_CS2GW1_TNR4 = compose_link(DEV_CS2GW1_EPS[2], DEV_TNR4_EPS[1])
+LINK_CS2GW2_TNR3_ID, LINK_CS2GW2_TNR3 = compose_link(DEV_CS2GW2_EPS[2], DEV_TNR3_EPS[1])
+
+# IntraDomain TN
+LINK_TNR1_TOLS_ID, LINK_TNR1_TOLS = compose_link(DEV_TNR1_EPS[2], DEV_TOLS_EPS[0])
+LINK_TNR2_TOLS_ID, LINK_TNR2_TOLS = compose_link(DEV_TNR2_EPS[2], DEV_TOLS_EPS[1])
+LINK_TNR3_TOLS_ID, LINK_TNR3_TOLS = compose_link(DEV_TNR3_EPS[2], DEV_TOLS_EPS[2])
+LINK_TNR4_TOLS_ID, LINK_TNR4_TOLS = compose_link(DEV_TNR4_EPS[2], DEV_TOLS_EPS[3])
+
+
+
# ----- WIM Service Settings -------------------------------------------------------------------------------------------
+WIM_USERNAME = 'admin'
+WIM_PASSWORD = 'admin'
def compose_service_endpoint_id(endpoint_id):
device_uuid = endpoint_id['device_id']['device_uuid']['uuid']
@@ -196,9 +342,6 @@ WIM_SEP_R3_SITE_ID = '2'
WIM_SEP_R3_BEARER = WIM_SEP_R3_ID
WIM_SRV_R3_VLAN_ID = 500
-WIM_USERNAME = 'admin'
-WIM_PASSWORD = 'admin'
-
WIM_MAPPING = [
{'device-id': DEVICE_R1_UUID, 'service_endpoint_id': WIM_SEP_R1_ID,
'service_mapping_info': {'bearer': {'bearer-reference': WIM_SEP_R1_BEARER}, 'site-id': WIM_SEP_R1_SITE_ID}},
@@ -215,17 +358,82 @@ WIM_SERVICE_CONNECTION_POINTS = [
'service_endpoint_encapsulation_info': {'vlan': WIM_SRV_R3_VLAN_ID}},
]
-# ----- Object Collections ---------------------------------------------------------------------------------------------
+# New code:
+def mapping(site_id, ce_endpoint_id, pe_device_id, priority=None, redundant=[]):
+ ce_endpoint_id = ce_endpoint_id['endpoint_id']
+ ce_device_uuid = ce_endpoint_id['device_id']['device_uuid']['uuid']
+ ce_endpoint_uuid = ce_endpoint_id['endpoint_uuid']['uuid']
+ pe_device_uuid = pe_device_id['device_uuid']['uuid']
+ service_endpoint_id = '{:s}:{:s}:{:s}'.format(site_id, ce_device_uuid, ce_endpoint_uuid)
+ bearer = '{:s}:{:s}'.format(ce_device_uuid, pe_device_uuid)
+ _mapping = {
+ 'service_endpoint_id': service_endpoint_id,
+ 'datacenter_id': site_id, 'device_id': ce_device_uuid, 'device_interface_id': ce_endpoint_uuid,
+ 'service_mapping_info': {
+ 'site-id': site_id,
+ 'bearer': {'bearer-reference': bearer},
+ }
+ }
+ if priority is not None: _mapping['service_mapping_info']['priority'] = priority
+ if len(redundant) > 0: _mapping['service_mapping_info']['redundant'] = redundant
+ return service_endpoint_id, _mapping
+
+WIM_SEP_DC1_PRI, WIM_MAP_DC1_PRI = mapping('DC1', DEV_DC1GW_EPS[0], DEV_CS1GW1_ID, priority=10, redundant=['DC1:DC1-GW:eth2'])
+WIM_SEP_DC1_SEC, WIM_MAP_DC1_SEC = mapping('DC1', DEV_DC1GW_EPS[1], DEV_CS1GW2_ID, priority=20, redundant=['DC1:DC1-GW:eth1'])
+WIM_SEP_DC2_PRI, WIM_MAP_DC2_PRI = mapping('DC2', DEV_DC2GW_EPS[0], DEV_CS2GW1_ID, priority=10, redundant=['DC2:DC2-GW:eth2'])
+WIM_SEP_DC2_SEC, WIM_MAP_DC2_SEC = mapping('DC2', DEV_DC2GW_EPS[1], DEV_CS2GW2_ID, priority=20, redundant=['DC2:DC2-GW:eth1'])
+
+WIM_MAPPING = [WIM_MAP_DC1_PRI, WIM_MAP_DC1_SEC, WIM_MAP_DC2_PRI, WIM_MAP_DC2_SEC]
+
+WIM_SRV_VLAN_ID = 300
+WIM_SERVICE_TYPE = 'ELAN'
+WIM_SERVICE_CONNECTION_POINTS = [
+ {'service_endpoint_id': WIM_SEP_DC1_PRI,
+ 'service_endpoint_encapsulation_type': 'dot1q',
+ 'service_endpoint_encapsulation_info': {'vlan': WIM_SRV_VLAN_ID}},
+ {'service_endpoint_id': WIM_SEP_DC2_PRI,
+ 'service_endpoint_encapsulation_type': 'dot1q',
+ 'service_endpoint_encapsulation_info': {'vlan': WIM_SRV_VLAN_ID}},
+]
+
-CONTEXTS = [CONTEXT]
-TOPOLOGIES = [TOPOLOGY]
-DEVICES = [
- (DEVICE_R1, DEVICE_R1_CONNECT_RULES),
- (DEVICE_R2, DEVICE_R2_CONNECT_RULES),
- (DEVICE_R3, DEVICE_R3_CONNECT_RULES),
- (DEVICE_R4, DEVICE_R4_CONNECT_RULES),
- (DEVICE_O1, DEVICE_O1_CONNECT_RULES),
-]
-LINKS = [LINK_R1_O1, LINK_R2_O1, LINK_R3_O1, LINK_R4_O1]
\ No newline at end of file
+# ----- Containers -----------------------------------------------------------------------------------------------------
+CONTEXTS = [CONTEXT ]
+TOPOLOGIES = [TOPOLOGY]
+DEVICES = [DEVICE_R1, DEVICE_R2, DEVICE_R3, DEVICE_R4, DEVICE_O1]
+LINKS = [LINK_R1_O1, LINK_R2_O1, LINK_R3_O1, LINK_R4_O1]
+
+OBJECTS_PER_TOPOLOGY = [
+ (TOPO_ADMIN_ID,
+ [ DEV_DC1GW_ID, DEV_DC2GW_ID,
+ DEV_CS1GW1_ID, DEV_CS1GW2_ID, DEV_CS2GW1_ID, DEV_CS2GW2_ID,
+ DEV_TNR1_ID, DEV_TNR2_ID, DEV_TNR3_ID, DEV_TNR4_ID,
+ DEV_TOLS_ID,
+ ],
+ [ LINK_DC1GW_CS1GW1_ID, LINK_DC1GW_CS1GW2_ID, LINK_DC2GW_CS2GW1_ID, LINK_DC2GW_CS2GW2_ID,
+ LINK_CS1GW1_TNR1_ID, LINK_CS1GW2_TNR2_ID, LINK_CS1GW1_TNR2_ID, LINK_CS1GW2_TNR1_ID,
+ LINK_CS2GW1_TNR3_ID, LINK_CS2GW2_TNR4_ID, LINK_CS2GW1_TNR4_ID, LINK_CS2GW2_TNR3_ID,
+ LINK_TNR1_TOLS_ID, LINK_TNR2_TOLS_ID, LINK_TNR3_TOLS_ID, LINK_TNR4_TOLS_ID,
+ ],
+ ),
+ (TOPO_DC1_ID,
+ [DEV_DC1GW_ID],
+ []),
+ (TOPO_DC2_ID,
+ [DEV_DC2GW_ID],
+ []),
+ (TOPO_CS1_ID,
+ [DEV_CS1GW1_ID, DEV_CS1GW2_ID],
+ []),
+ (TOPO_CS2_ID,
+ [DEV_CS2GW1_ID, DEV_CS2GW2_ID],
+ []),
+ (TOPO_TN_ID,
+ [ DEV_TNR1_ID, DEV_TNR2_ID, DEV_TNR3_ID, DEV_TNR4_ID,
+ DEV_TOLS_ID,
+ ],
+ [ LINK_TNR1_TOLS_ID, LINK_TNR2_TOLS_ID, LINK_TNR3_TOLS_ID, LINK_TNR4_TOLS_ID,
+ ]),
+]
diff --git a/src/tests/ofc22/tests/test_functional_bootstrap.py b/src/tests/ofc22/tests/test_functional_bootstrap.py
index 65b7cece1625032d8e02a5962d49d892e29d615a..f2f0dcb68d47c0c807ae214e2eb388b03bd9a676 100644
--- a/src/tests/ofc22/tests/test_functional_bootstrap.py
+++ b/src/tests/ofc22/tests/test_functional_bootstrap.py
@@ -1,3 +1,5 @@
+##### LLUIS GIFRE (CTTC): CODE UNDER REARRANGEMENT #####
+
# Copyright 2021-2023 H2020 TeraFlow (https://www.teraflow-h2020.eu/)
#
# Licensed under the Apache License, Version 2.0 (the "License");
@@ -44,138 +46,24 @@ def test_scenario_empty(context_client : ContextClient): # pylint: disable=rede
assert len(response.links) == 0
-def test_prepare_scenario(context_client : ContextClient): # pylint: disable=redefined-outer-name
-
- # ----- Start the EventsCollector ----------------------------------------------------------------------------------
- #events_collector = EventsCollector(context_client)
- #events_collector.start()
-
- #expected_events = []
-
- # ----- Create Contexts and Topologies -----------------------------------------------------------------------------
- for context in CONTEXTS:
- context_uuid = context['context_id']['context_uuid']['uuid']
- LOGGER.info('Adding Context {:s}'.format(context_uuid))
- response = context_client.SetContext(Context(**context))
- assert response.context_uuid.uuid == context_uuid
- #expected_events.append(('ContextEvent', EVENT_CREATE, json_context_id(context_uuid)))
-
- for topology in TOPOLOGIES:
- context_uuid = topology['topology_id']['context_id']['context_uuid']['uuid']
- topology_uuid = topology['topology_id']['topology_uuid']['uuid']
- LOGGER.info('Adding Topology {:s}/{:s}'.format(context_uuid, topology_uuid))
- response = context_client.SetTopology(Topology(**topology))
- assert response.context_id.context_uuid.uuid == context_uuid
- assert response.topology_uuid.uuid == topology_uuid
- context_id = json_context_id(context_uuid)
- #expected_events.append(('TopologyEvent', EVENT_CREATE, json_topology_id(topology_uuid, context_id=context_id)))
-
- # ----- Validate Collected Events ----------------------------------------------------------------------------------
- #check_events(events_collector, expected_events)
-
- # ----- Stop the EventsCollector -----------------------------------------------------------------------------------
- #events_collector.stop()
-
-
-def test_scenario_ready(context_client : ContextClient): # pylint: disable=redefined-outer-name
- # ----- List entities - Ensure scenario is ready -------------------------------------------------------------------
- response = context_client.ListContexts(Empty())
- assert len(response.contexts) == len(CONTEXTS)
-
- response = context_client.ListTopologies(ContextId(**CONTEXT_ID))
- assert len(response.topologies) == len(TOPOLOGIES)
-
- response = context_client.ListDevices(Empty())
- assert len(response.devices) == 0
-
- response = context_client.ListLinks(Empty())
- assert len(response.links) == 0
-
- response = context_client.ListServices(ContextId(**CONTEXT_ID))
- assert len(response.services) == 0
-
-
-def test_devices_bootstraping(
- context_client : ContextClient, device_client : DeviceClient): # pylint: disable=redefined-outer-name
-
- # ----- Start the EventsCollector ----------------------------------------------------------------------------------
- #events_collector = EventsCollector(context_client, log_events_received=True)
- #events_collector.start()
+def test_prepare_environment(context_client : ContextClient): # pylint: disable=redefined-outer-name
- #expected_events = []
+ for context in CONTEXTS : context_client.SetContext (Context (**context ))
+ for topology in TOPOLOGIES: context_client.SetTopology(Topology(**topology))
- # ----- Create Devices and Validate Collected Events ---------------------------------------------------------------
for device, connect_rules in DEVICES:
- device_uuid = device['device_id']['device_uuid']['uuid']
- LOGGER.info('Adding Device {:s}'.format(device_uuid))
-
device_with_connect_rules = copy.deepcopy(device)
device_with_connect_rules['device_config']['config_rules'].extend(connect_rules)
- response = device_client.AddDevice(Device(**device_with_connect_rules))
- assert response.device_uuid.uuid == device_uuid
-
- #expected_events.extend([
- # # Device creation, update for automation to start the device
- # ('DeviceEvent', EVENT_CREATE, json_device_id(device_uuid)),
- # #('DeviceEvent', EVENT_UPDATE, json_device_id(device_uuid)),
- #])
-
- #response = context_client.GetDevice(response)
- #for endpoint in response.device_endpoints:
- # for _ in endpoint.kpi_sample_types:
- # # Monitoring configures monitoring for endpoint
- # expected_events.append(('DeviceEvent', EVENT_UPDATE, json_device_id(device_uuid)))
-
- # ----- Validate Collected Events ----------------------------------------------------------------------------------
- #check_events(events_collector, expected_events)
+ device_client.AddDevice(Device(**device_with_connect_rules))
- # ----- Stop the EventsCollector -----------------------------------------------------------------------------------
- #events_collector.stop()
+ for link in LINKS : context_client.SetLink (Link (**link ))
-def test_devices_bootstrapped(context_client : ContextClient): # pylint: disable=redefined-outer-name
- # ----- List entities - Ensure bevices are created -----------------------------------------------------------------
- response = context_client.ListContexts(Empty())
- assert len(response.contexts) == len(CONTEXTS)
-
- response = context_client.ListTopologies(ContextId(**CONTEXT_ID))
- assert len(response.topologies) == len(TOPOLOGIES)
- response = context_client.ListDevices(Empty())
- assert len(response.devices) == len(DEVICES)
- response = context_client.ListLinks(Empty())
- assert len(response.links) == 0
- response = context_client.ListServices(ContextId(**CONTEXT_ID))
- assert len(response.services) == 0
-
-
-def test_links_creation(context_client : ContextClient): # pylint: disable=redefined-outer-name
-
- # ----- Start the EventsCollector ----------------------------------------------------------------------------------
- #events_collector = EventsCollector(context_client)
- #events_collector.start()
-
- #expected_events = []
-
- # ----- Create Links and Validate Collected Events -----------------------------------------------------------------
- for link in LINKS:
- link_uuid = link['link_id']['link_uuid']['uuid']
- LOGGER.info('Adding Link {:s}'.format(link_uuid))
- response = context_client.SetLink(Link(**link))
- assert response.link_uuid.uuid == link_uuid
- #expected_events.append(('LinkEvent', EVENT_CREATE, json_link_id(link_uuid)))
-
- # ----- Validate Collected Events ----------------------------------------------------------------------------------
- #check_events(events_collector, expected_events)
-
- # ----- Stop the EventsCollector -----------------------------------------------------------------------------------
- #events_collector.stop()
-
-
-def test_links_created(context_client : ContextClient): # pylint: disable=redefined-outer-name
- # ----- List entities - Ensure links are created -------------------------------------------------------------------
+def test_scenario_ready(context_client : ContextClient): # pylint: disable=redefined-outer-name
+ # ----- List entities - Ensure scenario is ready -------------------------------------------------------------------
response = context_client.ListContexts(Empty())
assert len(response.contexts) == len(CONTEXTS)
@@ -191,7 +79,6 @@ def test_links_created(context_client : ContextClient): # pylint: disable=redef
response = context_client.ListServices(ContextId(**CONTEXT_ID))
assert len(response.services) == 0
-
def test_scenario_kpis_created(monitoring_client: MonitoringClient):
"""
This test validates that KPIs related to the service/device/endpoint were created