diff --git a/scripts/run_tests_locally-context.sh b/scripts/run_tests_locally-context.sh
index 0124469ecc0089c1aeb26f695f4976b7bc50a66d..8c0b300b7c65129db2a50509e645a8c601a097ea 100755
--- a/scripts/run_tests_locally-context.sh
+++ b/scripts/run_tests_locally-context.sh
@@ -60,9 +60,7 @@ export NATS_URI="nats://tfs:tfs123@172.254.254.11:4222"
export PYTHONPATH=/home/tfs/tfs-ctrl/src
# helpful pytest flags: --log-level=INFO -o log_cli=true --verbose --maxfail=1 --durations=0
coverage run --rcfile=$RCFILE --append -m pytest --log-level=INFO --verbose --maxfail=1 \
- context/tests/test_context.py \
- context/tests/test_topology.py
- #context/tests/test_*.py
+ context/tests/test_*.py
echo
echo "Coverage report:"
diff --git a/src/context/service/ContextServiceServicerImpl.py b/src/context/service/ContextServiceServicerImpl.py
index 1528d64d9d9e394080cfbff17eba03a9b73430f9..95cda2c29d23c16f60889386efd4340b6ac72b76 100644
--- a/src/context/service/ContextServiceServicerImpl.py
+++ b/src/context/service/ContextServiceServicerImpl.py
@@ -130,28 +130,29 @@ class ContextServiceServicerImpl(ContextServiceServicer, ContextPolicyServiceSer
@safe_and_metered_rpc_method(METRICS_POOL, LOGGER)
def ListDeviceIds(self, request : Empty, context : grpc.ServicerContext) -> DeviceIdList:
- return device_list_ids(self.db_engine)
+ return DeviceIdList(device_ids=device_list_ids(self.db_engine))
@safe_and_metered_rpc_method(METRICS_POOL, LOGGER)
def ListDevices(self, request : Empty, context : grpc.ServicerContext) -> DeviceList:
- return device_list_objs(self.db_engine)
+ return DeviceList(devices=device_list_objs(self.db_engine))
@safe_and_metered_rpc_method(METRICS_POOL, LOGGER)
def GetDevice(self, request : ContextId, context : grpc.ServicerContext) -> Device:
- return device_get(self.db_engine, request)
+ return Device(**device_get(self.db_engine, request))
@safe_and_metered_rpc_method(METRICS_POOL, LOGGER)
def SetDevice(self, request : Device, context : grpc.ServicerContext) -> DeviceId:
- device_id,updated = device_set(self.db_engine, request) # pylint: disable=unused-variable
- #event_type = EventTypeEnum.EVENTTYPE_UPDATE if updated else EventTypeEnum.EVENTTYPE_CREATE
- #notify_event(self.messagebroker, TOPIC_DEVICE, event_type, {'device_id': device_id})
- return device_id
+ device_id,updated = device_set(self.db_engine, request)
+ event_type = EventTypeEnum.EVENTTYPE_UPDATE if updated else EventTypeEnum.EVENTTYPE_CREATE
+ notify_event(self.messagebroker, TOPIC_DEVICE, event_type, {'device_id': device_id})
+ return DeviceId(**device_id)
@safe_and_metered_rpc_method(METRICS_POOL, LOGGER)
def RemoveDevice(self, request : DeviceId, context : grpc.ServicerContext) -> Empty:
- deleted = device_delete(self.db_engine, request) # pylint: disable=unused-variable
- #if deleted:
- # notify_event(self.messagebroker, TOPIC_DEVICE, EventTypeEnum.EVENTTYPE_REMOVE, {'device_id': request})
+ device_id,deleted = device_delete(self.db_engine, request)
+ if deleted:
+ event_type = EventTypeEnum.EVENTTYPE_REMOVE
+ notify_event(self.messagebroker, TOPIC_DEVICE, event_type, {'device_id': device_id})
return Empty()
@safe_and_metered_rpc_method(METRICS_POOL, LOGGER)
diff --git a/src/context/service/database/ConfigRule.py b/src/context/service/database/ConfigRule.py
index 05dda20aa1cb20439e3cbdcbd123c56e8529d4c8..f64e273bfdbd1b309f4b1398309a31b1296b18ec 100644
--- a/src/context/service/database/ConfigRule.py
+++ b/src/context/service/database/ConfigRule.py
@@ -12,6 +12,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+import datetime, logging
from sqlalchemy import delete
from sqlalchemy.dialects.postgresql import insert
from sqlalchemy.orm import Session
@@ -22,8 +23,10 @@ from .models.enums.ConfigAction import grpc_to_enum__config_action
from .models.ConfigRuleModel import ConfigRuleKindEnum, ConfigRuleModel
from .uuids._Builder import get_uuid_random
+LOGGER = logging.getLogger(__name__)
+
def compose_config_rules_data(
- config_rules : List[ConfigRule],
+ config_rules : List[ConfigRule], now : datetime.datetime,
device_uuid : Optional[str] = None, service_uuid : Optional[str] = None, slice_uuid : Optional[str] = None
) -> List[Dict]:
dict_config_rules : List[Dict] = list()
@@ -36,6 +39,8 @@ def compose_config_rules_data(
'kind' : ConfigRuleKindEnum._member_map_.get(str_kind.upper()), # pylint: disable=no-member
'action' : grpc_to_enum__config_action(config_rule.action),
'data' : grpc_message_to_json_string(getattr(config_rule, str_kind, {})),
+ 'created_at' : now,
+ 'updated_at' : now,
}
if device_uuid is not None: dict_config_rule['device_uuid' ] = device_uuid
if service_uuid is not None: dict_config_rule['service_uuid'] = service_uuid
@@ -45,16 +50,30 @@ def compose_config_rules_data(
def upsert_config_rules(
session : Session, config_rules : List[Dict],
- device_uuid : Optional[str] = None, service_uuid : Optional[str] = None, slice_uuid : Optional[str] = None
-) -> None:
+ device_uuid : Optional[str] = None, service_uuid : Optional[str] = None, slice_uuid : Optional[str] = None,
+) -> bool:
+ # TODO: do not delete all rules; just add-remove as needed
stmt = delete(ConfigRuleModel)
if device_uuid is not None: stmt = stmt.where(ConfigRuleModel.device_uuid == device_uuid )
if service_uuid is not None: stmt = stmt.where(ConfigRuleModel.service_uuid == service_uuid)
if slice_uuid is not None: stmt = stmt.where(ConfigRuleModel.slice_uuid == slice_uuid )
session.execute(stmt)
+
+ updated = False
if len(config_rules) > 0:
- session.execute(insert(ConfigRuleModel).values(config_rules))
+ stmt = insert(ConfigRuleModel).values(config_rules)
+ #stmt = stmt.on_conflict_do_update(
+ # index_elements=[ConfigRuleModel.configrule_uuid],
+ # set_=dict(
+ # updated_at = stmt.excluded.updated_at,
+ # )
+ #)
+ stmt = stmt.returning(ConfigRuleModel.created_at, ConfigRuleModel.updated_at)
+ config_rule_updates = session.execute(stmt).fetchall()
+ LOGGER.warning('config_rule_updates = {:s}'.format(str(config_rule_updates)))
+ # TODO: updated = ...
+ return updated
#Union_SpecificConfigRule = Union[
# ConfigRuleCustomModel, ConfigRuleAclModel
diff --git a/src/context/service/database/Device.py b/src/context/service/database/Device.py
index ccd991d7f4ccbd8b8ca40fbee95a7d21f8fc69e2..68369ac9df6f1c3bb8707452641a9d18148c6504 100644
--- a/src/context/service/database/Device.py
+++ b/src/context/service/database/Device.py
@@ -12,15 +12,15 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+import datetime, logging
from sqlalchemy.dialects.postgresql import insert
from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session, sessionmaker
from sqlalchemy_cockroachdb import run_transaction
from typing import Dict, List, Optional, Set, Tuple
-from common.proto.context_pb2 import Device, DeviceId, DeviceIdList, DeviceList
from common.method_wrappers.ServiceExceptions import InvalidArgumentException, NotFoundException
+from common.proto.context_pb2 import Device, DeviceId
from common.tools.object_factory.Device import json_device_id
-from context.service.database.ConfigRule import compose_config_rules_data, upsert_config_rules
from .models.DeviceModel import DeviceModel
from .models.EndPointModel import EndPointModel
from .models.TopologyModel import TopologyDeviceModel
@@ -29,22 +29,23 @@ from .models.enums.DeviceOperationalStatus import grpc_to_enum__device_operation
from .models.enums.KpiSampleType import grpc_to_enum__kpi_sample_type
from .uuids.Device import device_get_uuid
from .uuids.EndPoint import endpoint_get_uuid
+from .ConfigRule import compose_config_rules_data, upsert_config_rules
-def device_list_ids(db_engine : Engine) -> DeviceIdList:
+LOGGER = logging.getLogger(__name__)
+
+def device_list_ids(db_engine : Engine) -> List[Dict]:
def callback(session : Session) -> List[Dict]:
obj_list : List[DeviceModel] = session.query(DeviceModel).all()
- #.options(selectinload(DeviceModel.topology)).filter_by(context_uuid=context_uuid).one_or_none()
return [obj.dump_id() for obj in obj_list]
- return DeviceIdList(device_ids=run_transaction(sessionmaker(bind=db_engine), callback))
+ return run_transaction(sessionmaker(bind=db_engine), callback)
-def device_list_objs(db_engine : Engine) -> DeviceList:
+def device_list_objs(db_engine : Engine) -> List[Dict]:
def callback(session : Session) -> List[Dict]:
obj_list : List[DeviceModel] = session.query(DeviceModel).all()
- #.options(selectinload(DeviceModel.topology)).filter_by(context_uuid=context_uuid).one_or_none()
return [obj.dump() for obj in obj_list]
- return DeviceList(devices=run_transaction(sessionmaker(bind=db_engine), callback))
+ return run_transaction(sessionmaker(bind=db_engine), callback)
-def device_get(db_engine : Engine, request : DeviceId) -> Device:
+def device_get(db_engine : Engine, request : DeviceId) -> Dict:
device_uuid = device_get_uuid(request, allow_random=False)
def callback(session : Session) -> Optional[Dict]:
obj : Optional[DeviceModel] = session.query(DeviceModel).filter_by(device_uuid=device_uuid).one_or_none()
@@ -55,9 +56,9 @@ def device_get(db_engine : Engine, request : DeviceId) -> Device:
raise NotFoundException('Device', raw_device_uuid, extra_details=[
'device_uuid generated was: {:s}'.format(device_uuid)
])
- return Device(**obj)
+ return obj
-def device_set(db_engine : Engine, request : Device) -> Tuple[DeviceId, bool]:
+def device_set(db_engine : Engine, request : Device) -> Tuple[Dict, bool]:
raw_device_uuid = request.device_id.device_uuid.uuid
raw_device_name = request.name
device_name = raw_device_uuid if len(raw_device_name) == 0 else raw_device_name
@@ -67,6 +68,8 @@ def device_set(db_engine : Engine, request : Device) -> Tuple[DeviceId, bool]:
oper_status = grpc_to_enum__device_operational_status(request.device_operational_status)
device_drivers = [grpc_to_enum__device_driver(d) for d in request.device_drivers]
+ now = datetime.datetime.utcnow()
+
topology_uuids : Set[str] = set()
related_topologies : List[Dict] = list()
endpoints_data : List[Dict] = list()
@@ -94,6 +97,8 @@ def device_set(db_engine : Engine, request : Device) -> Tuple[DeviceId, bool]:
'name' : endpoint_name,
'endpoint_type' : endpoint.endpoint_type,
'kpi_sample_types': kpi_sample_types,
+ 'created_at' : now,
+ 'updated_at' : now,
})
if endpoint_topology_uuid not in topology_uuids:
@@ -103,7 +108,7 @@ def device_set(db_engine : Engine, request : Device) -> Tuple[DeviceId, bool]:
})
topology_uuids.add(endpoint_topology_uuid)
- config_rules = compose_config_rules_data(request.device_config.config_rules, device_uuid=device_uuid)
+ config_rules = compose_config_rules_data(request.device_config.config_rules, now, device_uuid=device_uuid)
device_data = [{
'device_uuid' : device_uuid,
@@ -111,9 +116,11 @@ def device_set(db_engine : Engine, request : Device) -> Tuple[DeviceId, bool]:
'device_type' : device_type,
'device_operational_status': oper_status,
'device_drivers' : device_drivers,
+ 'created_at' : now,
+ 'updated_at' : now,
}]
- def callback(session : Session) -> None:
+ def callback(session : Session) -> bool:
stmt = insert(DeviceModel).values(device_data)
stmt = stmt.on_conflict_do_update(
index_elements=[DeviceModel.device_uuid],
@@ -122,9 +129,12 @@ def device_set(db_engine : Engine, request : Device) -> Tuple[DeviceId, bool]:
device_type = stmt.excluded.device_type,
device_operational_status = stmt.excluded.device_operational_status,
device_drivers = stmt.excluded.device_drivers,
+ updated_at = stmt.excluded.updated_at,
)
)
- session.execute(stmt)
+ stmt = stmt.returning(DeviceModel.created_at, DeviceModel.updated_at)
+ created_at,updated_at = session.execute(stmt).fetchone()
+ updated = updated_at > created_at
stmt = insert(EndPointModel).values(endpoints_data)
stmt = stmt.on_conflict_do_update(
@@ -133,23 +143,28 @@ def device_set(db_engine : Engine, request : Device) -> Tuple[DeviceId, bool]:
name = stmt.excluded.name,
endpoint_type = stmt.excluded.endpoint_type,
kpi_sample_types = stmt.excluded.kpi_sample_types,
+ updated_at = stmt.excluded.updated_at,
)
)
- session.execute(stmt)
+ stmt = stmt.returning(EndPointModel.created_at, EndPointModel.updated_at)
+ endpoint_updates = session.execute(stmt).fetchall()
+ LOGGER.warning('endpoint_updates = {:s}'.format(str(endpoint_updates)))
session.execute(insert(TopologyDeviceModel).values(related_topologies).on_conflict_do_nothing(
index_elements=[TopologyDeviceModel.topology_uuid, TopologyDeviceModel.device_uuid]
))
- upsert_config_rules(session, config_rules, device_uuid=device_uuid)
+ configrules_updated = upsert_config_rules(session, config_rules, device_uuid=device_uuid)
+
+ return updated
- run_transaction(sessionmaker(bind=db_engine), callback)
- updated = False # TODO: improve and check if created/updated
- return DeviceId(**json_device_id(device_uuid)),updated
+ updated = run_transaction(sessionmaker(bind=db_engine), callback)
+ return json_device_id(device_uuid),updated
-def device_delete(db_engine : Engine, request : DeviceId) -> bool:
+def device_delete(db_engine : Engine, request : DeviceId) -> Tuple[Dict, bool]:
device_uuid = device_get_uuid(request, allow_random=False)
def callback(session : Session) -> bool:
num_deleted = session.query(DeviceModel).filter_by(device_uuid=device_uuid).delete()
return num_deleted > 0
- return run_transaction(sessionmaker(bind=db_engine), callback)
+ deleted = run_transaction(sessionmaker(bind=db_engine), callback)
+ return json_device_id(device_uuid),deleted
diff --git a/src/context/service/database/Engine.py b/src/context/service/database/Engine.py
index a1aedc3ae5c0d1ba8ade7222a005ab304e45a842..c507efc720ea75381f4f9e83c84d007fb4be5890 100644
--- a/src/context/service/database/Engine.py
+++ b/src/context/service/database/Engine.py
@@ -29,13 +29,13 @@ class Engine:
engine = sqlalchemy.create_engine(
crdb_uri, connect_args={'application_name': APP_NAME}, echo=ECHO, future=True)
except: # pylint: disable=bare-except # pragma: no cover
- LOGGER.exception('Failed to connect to database: {:s}'.format(crdb_uri))
+ LOGGER.exception('Failed to connect to database: {:s}'.format(str(crdb_uri)))
return None
try:
Engine.create_database(engine)
except: # pylint: disable=bare-except # pragma: no cover
- LOGGER.exception('Failed to check/create to database: {:s}'.format(engine.url))
+ LOGGER.exception('Failed to check/create to database: {:s}'.format(str(crdb_uri)))
return None
return engine
diff --git a/src/context/service/database/Topology.py b/src/context/service/database/Topology.py
index 75fc229d8c41261c4e15ba89393c47d94f32d4ba..fcd93e6bb2500c370b5e0e9a206e7d7117507b88 100644
--- a/src/context/service/database/Topology.py
+++ b/src/context/service/database/Topology.py
@@ -82,7 +82,7 @@ def topology_set(db_engine : Engine, request : Topology) -> Tuple[Dict, bool]:
'updated_at' : now,
}]
- def callback(session : Session) -> None:
+ def callback(session : Session) -> bool:
stmt = insert(TopologyModel).values(topology_data)
stmt = stmt.on_conflict_do_update(
index_elements=[TopologyModel.topology_uuid],
diff --git a/src/context/service/database/models/ConfigRuleModel.py b/src/context/service/database/models/ConfigRuleModel.py
index c2baa8df6aa2f83758ea42c5d040fd83c723d028..a697de55652c82406f7496188641c33f99f9682a 100644
--- a/src/context/service/database/models/ConfigRuleModel.py
+++ b/src/context/service/database/models/ConfigRuleModel.py
@@ -13,7 +13,7 @@
# limitations under the License.
import enum, json
-from sqlalchemy import CheckConstraint, Column, Enum, ForeignKey, Integer, String
+from sqlalchemy import CheckConstraint, Column, DateTime, Enum, ForeignKey, Integer, String
from sqlalchemy.dialects.postgresql import UUID
from typing import Dict
from .enums.ConfigAction import ORM_ConfigActionEnum
@@ -35,6 +35,8 @@ class ConfigRuleModel(_Base):
kind = Column(Enum(ConfigRuleKindEnum), nullable=False)
action = Column(Enum(ORM_ConfigActionEnum), nullable=False)
data = Column(String, nullable=False)
+ created_at = Column(DateTime)
+ updated_at = Column(DateTime)
__table_args__ = (
CheckConstraint(position >= 0, name='check_position_value'),
diff --git a/src/context/service/database/models/DeviceModel.py b/src/context/service/database/models/DeviceModel.py
index 2deb688e16d76ef43cf057bfaf981115a1840bdc..ef56c715863607dc67c4f0be31202f03948353e0 100644
--- a/src/context/service/database/models/DeviceModel.py
+++ b/src/context/service/database/models/DeviceModel.py
@@ -13,7 +13,7 @@
# limitations under the License.
import operator
-from sqlalchemy import Column, Enum, String
+from sqlalchemy import Column, DateTime, Enum, String
from sqlalchemy.dialects.postgresql import ARRAY, UUID
from sqlalchemy.orm import relationship
from typing import Dict
@@ -24,11 +24,13 @@ from ._Base import _Base
class DeviceModel(_Base):
__tablename__ = 'device'
- device_uuid = Column(UUID(as_uuid=False), primary_key=True)
- device_name = Column(String, nullable=False)
- device_type = Column(String, nullable=False)
+ device_uuid = Column(UUID(as_uuid=False), primary_key=True)
+ device_name = Column(String, nullable=False)
+ device_type = Column(String, nullable=False)
device_operational_status = Column(Enum(ORM_DeviceOperationalStatusEnum), nullable=False)
- device_drivers = Column(ARRAY(Enum(ORM_DeviceDriverEnum), dimensions=1))
+ device_drivers = Column(ARRAY(Enum(ORM_DeviceDriverEnum), dimensions=1))
+ created_at = Column(DateTime)
+ updated_at = Column(DateTime)
#topology_devices = relationship('TopologyDeviceModel', back_populates='device')
config_rules = relationship('ConfigRuleModel', passive_deletes=True) # lazy='joined', back_populates='device'
diff --git a/src/context/service/database/models/EndPointModel.py b/src/context/service/database/models/EndPointModel.py
index 4151cfe0df01c5e40dedc0d449343c29fe064e75..abc16c1affdf542b64c2d0d6698645e1ba82b665 100644
--- a/src/context/service/database/models/EndPointModel.py
+++ b/src/context/service/database/models/EndPointModel.py
@@ -12,7 +12,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-from sqlalchemy import Column, Enum, ForeignKey, String
+from sqlalchemy import Column, DateTime, Enum, ForeignKey, String
from sqlalchemy.dialects.postgresql import ARRAY, UUID
from sqlalchemy.orm import relationship
from typing import Dict
@@ -28,6 +28,8 @@ class EndPointModel(_Base):
name = Column(String, nullable=False)
endpoint_type = Column(String, nullable=False)
kpi_sample_types = Column(ARRAY(Enum(ORM_KpiSampleTypeEnum), dimensions=1))
+ created_at = Column(DateTime)
+ updated_at = Column(DateTime)
device = relationship('DeviceModel', back_populates='endpoints')
topology = relationship('TopologyModel')
diff --git a/src/context/tests/test_device.py b/src/context/tests/test_device.py
index e53ad747c3934c34e81d8ba80b069c125a761cb8..b009a5e456cad10b2a0c5ff0a1ffa6edb921ae94 100644
--- a/src/context/tests/test_device.py
+++ b/src/context/tests/test_device.py
@@ -12,24 +12,25 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import copy, grpc, pytest
+import copy, grpc, pytest, time
from common.proto.context_pb2 import (
- Context, ContextId, Device, DeviceDriverEnum, DeviceId, DeviceOperationalStatusEnum, Empty, Topology, TopologyId)
+ Context, ContextEvent, ContextId, Device, DeviceDriverEnum, DeviceEvent, DeviceId, DeviceOperationalStatusEnum, Empty, EventTypeEnum, Topology, TopologyEvent, TopologyId)
from context.client.ContextClient import ContextClient
from context.service.database.uuids.Device import device_get_uuid
-#from context.client.EventsCollector import EventsCollector
+from context.client.EventsCollector import EventsCollector
from .Objects import CONTEXT, CONTEXT_ID, DEVICE_R1, DEVICE_R1_ID, DEVICE_R1_NAME, TOPOLOGY, TOPOLOGY_ID
@pytest.mark.depends(on=['context/tests/test_topology.py::test_topology'])
def test_device(context_client : ContextClient) -> None:
# ----- Initialize the EventsCollector -----------------------------------------------------------------------------
- #events_collector = EventsCollector(
- # context_client, log_events_received=True,
- # activate_context_collector = False, activate_topology_collector = False, activate_device_collector = True,
- # activate_link_collector = False, activate_service_collector = False, activate_slice_collector = False,
- # activate_connection_collector = False)
- #events_collector.start()
+ events_collector = EventsCollector(
+ context_client, log_events_received=True,
+ activate_context_collector = False, activate_topology_collector = False, activate_device_collector = True,
+ activate_link_collector = False, activate_service_collector = False, activate_slice_collector = False,
+ activate_connection_collector = False)
+ events_collector.start()
+ time.sleep(3)
# ----- Prepare dependencies for the test and capture related events -----------------------------------------------
response = context_client.SetContext(Context(**CONTEXT))
@@ -38,14 +39,14 @@ def test_device(context_client : ContextClient) -> None:
response = context_client.SetTopology(Topology(**TOPOLOGY))
topology_uuid = response.topology_uuid.uuid
- #events = events_collector.get_events(block=True, count=2)
- #assert isinstance(events[0], ContextEvent)
- #assert events[0].event.event_type == EventTypeEnum.EVENTTYPE_CREATE
- #assert events[0].context_id.context_uuid.uuid == context_uuid
- #assert isinstance(events[1], TopologyEvent)
- #assert events[1].event.event_type == EventTypeEnum.EVENTTYPE_CREATE
- #assert events[1].topology_id.context_id.context_uuid.uuid == context_uuid
- #assert events[1].topology_id.topology_uuid.uuid == topology_uuid
+ events = events_collector.get_events(block=True, count=2, timeout=1.0)
+ assert isinstance(events[0], ContextEvent)
+ assert events[0].event.event_type == EventTypeEnum.EVENTTYPE_CREATE
+ assert events[0].context_id.context_uuid.uuid == context_uuid
+ assert isinstance(events[1], TopologyEvent)
+ assert events[1].event.event_type == EventTypeEnum.EVENTTYPE_CREATE
+ assert events[1].topology_id.context_id.context_uuid.uuid == context_uuid
+ assert events[1].topology_id.topology_uuid.uuid == topology_uuid
# ----- Get when the object does not exist -------------------------------------------------------------------------
device_id = DeviceId(**DEVICE_R1_ID)
@@ -78,10 +79,10 @@ def test_device(context_client : ContextClient) -> None:
assert response.device_uuid.uuid == device_uuid
# ----- Check create event -----------------------------------------------------------------------------------------
- #event = events_collector.get_event(block=True)
- #assert isinstance(event, DeviceEvent)
- #assert event.event.event_type == EventTypeEnum.EVENTTYPE_CREATE
- #assert event.device_id.device_uuid.uuid == device_uuid
+ event = events_collector.get_event(block=True, timeout=1.0)
+ assert isinstance(event, DeviceEvent)
+ assert event.event.event_type == EventTypeEnum.EVENTTYPE_CREATE
+ assert event.device_id.device_uuid.uuid == device_uuid
# ----- Get when the object exists ---------------------------------------------------------------------------------
response = context_client.GetDevice(DeviceId(**DEVICE_R1_ID))
@@ -121,10 +122,10 @@ def test_device(context_client : ContextClient) -> None:
assert response.device_uuid.uuid == device_uuid
# ----- Check update event -----------------------------------------------------------------------------------------
- #event = events_collector.get_event(block=True)
- #assert isinstance(event, DeviceEvent)
- #assert event.event.event_type == EventTypeEnum.EVENTTYPE_UPDATE
- #assert event.device_id.device_uuid.uuid == device_uuid
+ event = events_collector.get_event(block=True, timeout=1.0)
+ assert isinstance(event, DeviceEvent)
+ assert event.event.event_type == EventTypeEnum.EVENTTYPE_UPDATE
+ assert event.device_id.device_uuid.uuid == device_uuid
# ----- Get when the object is modified ----------------------------------------------------------------------------
response = context_client.GetDevice(DeviceId(**DEVICE_R1_ID))
@@ -155,20 +156,6 @@ def test_device(context_client : ContextClient) -> None:
assert DeviceDriverEnum.DEVICEDRIVER_OPENCONFIG in response.devices[0].device_drivers
assert len(response.devices[0].device_endpoints) == 4
- # ----- Create object relation -------------------------------------------------------------------------------------
- #TOPOLOGY_WITH_DEVICE = copy.deepcopy(TOPOLOGY)
- #TOPOLOGY_WITH_DEVICE['device_ids'].append(DEVICE_R1_ID)
- #response = context_client.SetTopology(Topology(**TOPOLOGY_WITH_DEVICE))
- #assert response.context_id.context_uuid.uuid == context_uuid
- #assert response.topology_uuid.uuid == topology_uuid
-
- # ----- Check update event -----------------------------------------------------------------------------------------
- #event = events_collector.get_event(block=True)
- #assert isinstance(event, TopologyEvent)
- #assert event.event.event_type == EventTypeEnum.EVENTTYPE_UPDATE
- #assert response.context_id.context_uuid.uuid == context_uuid
- #assert response.topology_uuid.uuid == topology_uuid
-
# ----- Check relation was created ---------------------------------------------------------------------------------
response = context_client.GetTopology(TopologyId(**TOPOLOGY_ID))
assert response.topology_id.context_id.context_uuid.uuid == context_uuid
@@ -181,10 +168,10 @@ def test_device(context_client : ContextClient) -> None:
context_client.RemoveDevice(DeviceId(**DEVICE_R1_ID))
# ----- Check remove event -----------------------------------------------------------------------------------------
- #event = events_collector.get_event(block=True)
- #assert isinstance(event, DeviceEvent)
- #assert event.event.event_type == EventTypeEnum.EVENTTYPE_REMOVE
- #assert event.device_id.device_uuid.uuid == device_uuid
+ event = events_collector.get_event(block=True, timeout=1.0)
+ assert isinstance(event, DeviceEvent)
+ assert event.event.event_type == EventTypeEnum.EVENTTYPE_REMOVE
+ assert event.device_id.device_uuid.uuid == device_uuid
# ----- List after deleting the object -----------------------------------------------------------------------------
response = context_client.ListDeviceIds(Empty())
@@ -203,14 +190,14 @@ def test_device(context_client : ContextClient) -> None:
context_client.RemoveTopology(TopologyId(**TOPOLOGY_ID))
context_client.RemoveContext(ContextId(**CONTEXT_ID))
- #events = events_collector.get_events(block=True, count=2)
- #assert isinstance(events[0], TopologyEvent)
- #assert events[0].event.event_type == EventTypeEnum.EVENTTYPE_REMOVE
- #assert events[0].topology_id.context_id.context_uuid.uuid == context_uuid
- #assert events[0].topology_id.topology_uuid.uuid == topology_uuid
- #assert isinstance(events[1], ContextEvent)
- #assert events[1].event.event_type == EventTypeEnum.EVENTTYPE_REMOVE
- #assert events[1].context_id.context_uuid.uuid == context_uuid
+ events = events_collector.get_events(block=True, count=2, timeout=1.0)
+ assert isinstance(events[0], TopologyEvent)
+ assert events[0].event.event_type == EventTypeEnum.EVENTTYPE_REMOVE
+ assert events[0].topology_id.context_id.context_uuid.uuid == context_uuid
+ assert events[0].topology_id.topology_uuid.uuid == topology_uuid
+ assert isinstance(events[1], ContextEvent)
+ assert events[1].event.event_type == EventTypeEnum.EVENTTYPE_REMOVE
+ assert events[1].context_id.context_uuid.uuid == context_uuid
# ----- Stop the EventsCollector -----------------------------------------------------------------------------------
- #events_collector.stop()
+ events_collector.stop()