openmodule-test 15.2.0__tar.gz → 16.0.0__tar.gz

{openmodule_test-15.2.0 → openmodule_test-16.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openmodule_test
-Version: 15.2.0
+Version: 16.0.0
 Summary: Libraries for testing openmodule services
 Home-page: https://gitlab.com/arivo-public/device-python/openmodule.git
 Author: ARIVO

{openmodule_test-15.2.0 → openmodule_test-16.0.0}/database.py

@@ -41,6 +41,7 @@ class SQLiteTestMixin(TestCase):
     alembic_path = "../src/database"
     database_name = "database"
     main_process_migration = True  # change if migration should be performed in a separate process
+    delete_backups = True  # if True, all database backups are deleted on teardown
 
     @classmethod
     def get_database_folder(cls):
@@ -81,6 +82,9 @@ class SQLiteTestMixin(TestCase):
         super().tearDown()
         if self.create_database:
             truncate_all_tables(self.database)
+        if self.delete_backups:
+            for file in glob(os.path.join(self.get_database_folder(), f"{self.database_name}_*.sqlite3.backup")):
+                os.unlink(file)
 
     @classmethod
     def tearDownClass(cls):

{openmodule_test-15.2.0 → openmodule_test-16.0.0}/gate.py

@@ -25,10 +25,8 @@ class TestGate:
     def __init__(self, gate: str, direction: Direction, dispatcher: MessageDispatcher):
         self.gate = gate
         self.direction = direction
-        dispatcher.register_handler("access_accept", TestGateAccessMessage, self._access_accept,
-                                    register_schema=False, match_type=False)
-        dispatcher.register_handler("access_reject", TestGateAccessMessage, self._access_reject,
-                                    register_schema=False, match_type=False)
+        dispatcher.register_handler("access_accept", TestGateAccessMessage, self._access_accept, match_type=False)
+        dispatcher.register_handler("access_reject", TestGateAccessMessage, self._access_reject, match_type=False)
         _all_gates.add(self)
 
     @classmethod
@@ -42,10 +40,12 @@ class TestGate:
         self._wait_called_since_reset = False
 
     def _access_accept(self, message: TestGateAccessMessage):
+        """ increment open_count if correct gate """
         if message.gateway.gate == self.gate:
             self.open_count += 1
 
     def _access_reject(self, message: TestGateAccessMessage):
+        """ increment reject_count if correct gate """
         if message.gateway.gate == self.gate:
             self.reject_count += 1
 

{openmodule_test-15.2.0 → openmodule_test-16.0.0}/interrupt.py

@@ -13,7 +13,6 @@ from unittest import TestCase
 import multiprocessing_logging
 
 from openmodule.core import shutdown_openmodule
-from openmodule.utils.schema import Schema
 from openmodule_test.health import HealthTestMixin
 
 
@@ -26,7 +25,6 @@ class ExceptionProcess(Process):
     def run(self):
         try:
             super().run()
-            Schema.to_file()
             self.is_finished.set()
         except Exception as e:
             logging.exception(e)
@@ -96,7 +94,6 @@ class InterruptTestMixin(TestCase):
 
     def tearDown(self):
         super().tearDown()
-        Schema.to_file()
         self._kill_process()
 
     def wait_for_setup(self):

{openmodule_test-15.2.0 → openmodule_test-16.0.0}/io_simulator.py

@@ -1,12 +1,12 @@
 from collections import defaultdict
 from typing import Callable
 
-from openmodule.models.base import Gateway
+from openmodule.models.base import Gateway, Direction
 from openmodule.models.io import IoMessage, IoState
 from openmodule.utils.misc_functions import utcnow
 
 
-def generate_example_states(count: int | None = 8) -> dict[str, IoState]:
+def generate_example_states(count: int=8) -> dict[str, IoState]:
     """
     Creates a dict with pin as key and IoState as value.
     param count: how many pins should be created.
@@ -17,7 +17,7 @@ def generate_example_states(count: int | None = 8) -> dict[str, IoState]:
     states: dict[str, IoState] = defaultdict(IoState)
     for i in range(count):
         gate = int(i/4)
-        direction = "in" if gate % 2 == 0 else "out"
+        direction = Direction.IN if gate % 2 == 0 else Direction.OUT
         gateway = Gateway(gate="gate_{}".format(gate), direction=direction)
         state = IoState(pin="", gateway=gateway, value=0, physical=0, inverted=False, type="input",
                         last_timestamp=utcnow())
@@ -75,11 +75,11 @@ class IoSimulator:
     def set_pin_high(self, pin: str):
         self._emit(pin, 1)
 
-    def emit_custom_io_message(self, pin: str, value: int = None, physical: int = None, inverted: bool = None,
-                               edge: int = None):
+    def emit_custom_io_message(self, pin: str, value: int | None = None, physical: int | None = None,
+                               inverted: bool | None = None, edge: int | None = None):
         state = self.pin_states[pin]
         if edge is None:
-            if state.value != value or state.is_inverted != inverted:
+            if state.value != value or state.inverted != inverted:
                 edge = 1
             else:
                 edge = 0

{openmodule_test-15.2.0 → openmodule_test-16.0.0}/openmodule_test.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openmodule_test
-Version: 15.2.0
+Version: 16.0.0
 Summary: Libraries for testing openmodule services
 Home-page: https://gitlab.com/arivo-public/device-python/openmodule.git
 Author: ARIVO

{openmodule_test-15.2.0 → openmodule_test-16.0.0}/presence.py

@@ -1,7 +1,7 @@
 import random
 import time
 from datetime import datetime
-from typing import Callable
+from typing import Callable, Self
 
 from openmodule.models.base import Direction, Gateway, datetime_to_timestamp
 from openmodule.models.presence import PresenceBaseMessage, PresenceEnterMessage, PresenceLeaveMessage, \
@@ -36,11 +36,11 @@ class VehicleBuilder:
             leave_time=self.leave_time
         )
 
-    def id(self, id: int) -> 'VehicleBuilder':
+    def id(self, id: int) -> Self:
         self.vehicle_id = id
         return self
 
-    def lpr(self, country: str | None, plate: str | None = None, state="") -> 'VehicleBuilder':
+    def lpr(self, country: str | None, plate: str | None = None, state="") -> Self:
         if country is None:
             self.medium.lpr = None
         else:
@@ -50,40 +50,40 @@ class VehicleBuilder:
             )
         return self
 
-    def nfc(self, id: str | None) -> 'VehicleBuilder':
+    def nfc(self, id: str | None) -> Self:
         if id is None:
             self.medium.nfc = id
         else:
             self.medium.nfc = Medium(id=id, type=MediumType.nfc)
         return self
 
-    def qr(self, id: str | None, binary: str | None = None) -> 'VehicleBuilder':
+    def qr(self, id: str | None, binary: str | None = None) -> Self:
         if id is None:
             self.medium.qr = id
         else:
             self.medium.qr = QRMedium(id=id, binary=binary)
         return self
 
-    def pin(self, id: str | None) -> 'VehicleBuilder':
+    def pin(self, id: str | None) -> Self:
         if id is None:
             self.medium.pin = id
         else:
             self.medium.pin = Medium(id=id, type=MediumType.pin)
         return self
 
-    def set_make_model(self, make_model) -> 'VehicleBuilder':
+    def set_make_model(self, make_model) -> Self:
         self.make_model = make_model
         return self
 
-    def set_enter_direction(self, enter_direction: EnterDirection) -> 'VehicleBuilder':
+    def set_enter_direction(self, enter_direction: EnterDirection) -> Self:
         self.enter_direction = enter_direction
         return self
 
-    def set_enter_time(self, enter_time: datetime) -> 'VehicleBuilder':
+    def set_enter_time(self, enter_time: datetime) -> Self:
         self.enter_time = enter_time
         return self
 
-    def set_leave_time(self, leave_time: datetime) -> 'VehicleBuilder':
+    def set_leave_time(self, leave_time: datetime) -> Self:
         self.leave_time = leave_time
         return self
 

{openmodule_test-15.2.0 → openmodule_test-16.0.0}/rpc.py

@@ -7,7 +7,7 @@ from typing import Any, Callable
 
 from pydantic.main import BaseModel
 
-from openmodule.models.base import OpenModuleModel
+from openmodule.models.base import OpenModuleModel, ZMQMessage
 from openmodule.models.rpc import RPCErrorResult, RPCServerError
 from openmodule.rpc import RPCClient
 from openmodule_test.zeromq import ZMQTestMixin
@@ -18,6 +18,14 @@ class _EmptyModel(BaseModel):
 
 
 class RPCServerTestMixin(ZMQTestMixin):
+    def setUp(self):
+        ZMQMessage._ALLOW_CUSTOM_TIMESTAMP = True
+        return super().setUp()
+
+    def tearDown(self):
+        ZMQMessage._ALLOW_CUSTOM_TIMESTAMP = False
+        return super().tearDown()
+
     def wait_for_rpc_response(self, channel: str, type: str, request: BaseModel, response_type: type[OpenModuleModel]):
         """
         waits until a rpc server is responding to the channel/type
@@ -37,6 +45,7 @@ class RPCServerTestMixin(ZMQTestMixin):
         message_received = False
 
         def handler(_, __):
+            """ handler to set message_received true """
             nonlocal message_received
             message_received = True
 
@@ -48,7 +57,7 @@ class RPCServerTestMixin(ZMQTestMixin):
         assert server.handlers, "you need to register the handlers beforehand"
         random_channel = "_test" + "".join(random.choices(string.ascii_letters, k=10))
 
-        server.register_handler(random_channel, "ping", _EmptyModel, _EmptyModel, handler, register_schema=False)
+        server.register_handler(random_channel, "ping", _EmptyModel, _EmptyModel, handler)
 
         for x in range(self.zmq_client.startup_check_iterations):
             self.rpc_no_response(random_channel, "ping", {})

{openmodule_test-15.2.0 → openmodule_test-16.0.0}/settings.py

@@ -85,10 +85,9 @@ class SettingsRPCMocker:
             for setting, value in settings.items():
                 if setting[0] in serialization._model_mapping:
                     serialization.parse_setting_from_obj(setting[0], value)
-        rpc_server.register_handler("settings", "get", SettingsGetRequest, SettingsGetResponse, self._get_handler,
-                                    register_schema=False)
+        rpc_server.register_handler("settings", "get", SettingsGetRequest, SettingsGetResponse, self._get_handler)
         rpc_server.register_handler("settings", "get_many", SettingsGetManyRequest, SettingsGetManyResponse,
-                                    self._get_many_handler, register_schema=False)
+                                    self._get_many_handler)
         self.settings = settings
         self.result_mode = SettingsRPCMocker.ResultMode.ok
         self.error_code = "no such setting"
@@ -109,10 +108,12 @@ class SettingsRPCMocker:
             raise RuntimeError()
 
     def _get_handler(self, request: SettingsGetRequest, _) -> SettingsGetResponse:
+        """ either raise set error or return requested value """
         self._do_errors()
         return self._get_setting(request.key, request.scope)
 
     def _get_many_handler(self, request: SettingsGetManyRequest, _) -> SettingsGetManyResponse:
+        """ either raise set error or return requested values """
         self._do_errors()
         return SettingsGetManyResponse(settings={key: self._get_setting(key, request.scope, i)
                                                  for i, key in enumerate(request.key)})

{openmodule_test-15.2.0 → openmodule_test-16.0.0}/signal_simulator.py

@@ -18,7 +18,7 @@ class SignalSimulator:
             signal_msg = SignalMessage(signal=signal_name, type=signal_type, gate=gate, parking_area_id=parking_area_id,
                                        value=value, additional_data=additional_data)
         elif signal_type == SignalType.parkinglot_full:
-            signal_name = signal_type.value
+            signal_name: str = signal_type.value  # type: ignore (just pycharm)
             signal_msg = SignalMessage(signal=signal_name, type=signal_type,
                                        value=value, additional_data=additional_data)
         elif signal_type == SignalType.area_full:

{openmodule_test-15.2.0 → openmodule_test-16.0.0}/zeromq.py

@@ -24,7 +24,6 @@ from openmodule.dispatcher import SubscribingMessageDispatcher
 from openmodule.models.base import OpenModuleModel
 from openmodule.models.rpc import RPCResponse
 from openmodule.rpc import RPCClient
-from openmodule.utils.schema import Schema
 from openmodule_test.utils import DeveloperError
 
 
@@ -433,7 +432,7 @@ class ZMQTestMixin(TestCase):
         and if it is connected, all previous subscriptions will also be connected
         """
         random_topic = "_test" + "".join(random.choices(string.ascii_letters, k=10))
-        dispatcher.register_handler(random_topic, OpenModuleModel, handler, register_schema=False, match_type=False)
+        dispatcher.register_handler(random_topic, OpenModuleModel, handler, match_type=False)
 
         for _ in range(self.zmq_client.startup_check_iterations):
             self.zmq_client.send(random_topic, {"type": "connection-check"})
@@ -469,7 +468,6 @@ class ZMQTestMixin(TestCase):
         )
         self._cleanup()
         super(ZMQTestMixin, self).tearDown()
-        Schema.to_file()
 
     def rpc(self, channel: str, type: str, request, response_type: type[OpenModuleModel], timeout=3, resource=None) \
             -> str | OpenModuleModel:
@@ -507,7 +505,7 @@ class ZMQTestMixin(TestCase):
         except TimeoutError:
             raise RPCClient.TimeoutError()
         entry = RPCClient.RPCEntry(0)  # timeout 0 because timeout is handled above, so we never have to wait here
-        entry.response = RPCResponse(**response).response
+        entry.response = RPCResponse.model_validate(response).response
         return entry.result(response_type)
 
     def assertSubscription(self, *topics: str):