-
- | Protocol |
- Plausible Use Cases |
- Operations |
-
-
- | HTTP |
- Web Apps |
-
- readproperty,
- writeproperty,
- observeproperty,
- unobserveproperty,
- invokeaction,
- subscribeevent,
- unsubscribeevent,
- readmultipleproperties,
- writemultipleproperties,
- readallproperties,
- writeallproperties
-
- properties and actions can be operated in a oneway and no-block manner (issue and query later format) as well
- |
-
-
- | ZMQ TCP |
- Networked Control Systems, subnet protected containerized apps like in Kubernetes |
-
-
- | ZMQ IPC |
- Desktop Applications, Python Dashboards without exposing device API directly on network |
-
-
- | ZMQ INPROC |
-
- High Speed Desktop Applications (again, not exposed on network), currently you will need some CPP magic or disable GIL to leverage it fully
- |
-
-
- | MQTT |
-
- Reliable pub-sub & incorporating into existing systems that use MQTT for
lightweight messaging
- |
-
- observeproperty,
- unobserveproperty,
- subscribeevent,
- unsubscribeevent
- |
-
-
- | MQTT with websockets |
-
- Reliable pub-sub for web applications, planned for November 2025 release.
- |
-
- observeproperty,
- unobserveproperty,
- subscribeevent,
- unsubscribeevent
- |
-
-
diff --git a/doc b/doc
index d4e965b5..e8ec16a0 160000
--- a/doc
+++ b/doc
@@ -1 +1 @@
-Subproject commit d4e965b5ad5b8c0b88f807d031b72e76acf9cde9
+Subproject commit e8ec16a0f5ff9a74c38a8a13fab26baf615e73cb
diff --git a/hololinked/logger.py b/hololinked/logger.py
index 5d1b6613..1d816688 100644
--- a/hololinked/logger.py
+++ b/hololinked/logger.py
@@ -1,11 +1,15 @@
-import logging
-import structlog
import copy
-from typing import Any
-from structlog.dev import KeyValueColumnFormatter
+import logging
import sys
import types
+from typing import Any
+
+import structlog
+
+from structlog.dev import KeyValueColumnFormatter
+
+
default_label_formatter = None
@@ -67,8 +71,8 @@ def setup_logging(log_level: int = logging.INFO, colored_logs: bool = False, log
import httpx # noqa: F401
# httpx_log = structlog.get_logger().bind(component="library|httpx")
- logging.getLogger("httpcore").setLevel(logging.WARNING)
- logging.getLogger("httpx").setLevel(logging.WARNING)
+ logging.getLogger("httpcore").setLevel(logging.WARNING if log_level <= logging.WARNING else log_level)
+ logging.getLogger("httpx").setLevel(logging.WARNING if log_level <= logging.WARNING else log_level)
except ImportError:
pass
diff --git a/hololinked/param/copy_parameters.py b/hololinked/param/copy_parameters.py
deleted file mode 100644
index 23ebe6bb..00000000
--- a/hololinked/param/copy_parameters.py
+++ /dev/null
@@ -1,119 +0,0 @@
-def copy_parameters(
- src: str = "D:/onedrive/desktop/dashboard/scada/scadapy/scadapy/param/parameters.py",
- dst: str = "D:/onedrive/desktop/dashboard/scada/scadapy/scadapy/server/remote_parameters.py",
-) -> None:
- skip_classes = [
- "Infinity",
- "resolve_path",
- "normalize_path",
- "BaseConstrainedList",
- "TypeConstrainedList",
- "TypeConstrainedDict",
- "TypedKeyMappingsConstrainedDict",
- "Event",
- ]
- end_line = "def hashable"
- additional_imports = [
- "from ..param.parameters import (TypeConstrainedList, TypeConstrainedDict, abbreviate_paths,\n",
- " TypedKeyMappingsConstrainedDict, resolve_path, concrete_descendents, named_objs)\n"
- "from .remote_parameter import RemoteParameter\n",
- "from .constants import HTTP, PROXY, USE_OBJECT_NAME, GET, PUT",
- ]
-
- def fetch_line() -> typing.Generator[str]:
- with open(src, "r") as file:
- oldlines = file.readlines()
- for line in oldlines:
- yield line
-
- remote_init_kwargs = [
- "\t\t\tURL_path : str = USE_OBJECT_NAME, http_method : typing.Tuple[str, str] = (GET, PUT),\n",
- "\t\t\tstate : typing.Optional[typing.Union[typing.List, typing.Tuple, str, Enum]] = None,\n",
- "\t\t\tdb_persist : bool = False, db_init : bool = False, db_commit : bool = False,\n"
- "\t\t\taccess_type : str = (HTTP, PROXY),\n",
- ]
-
- remote_super_init = [
- "\t\t\tURL_path=URL_path, http_method=http_method, state=state, db_persist=db_persist,\n",
- "\t\t\tdb_init=db_init, db_commit=db_commit, access_type=access_type)\n",
- ]
-
- common_linegen = fetch_line()
- newlines = []
-
- def skip_to_init_doc():
- for line in common_linegen:
- if "doc : typing.Optional[str] = None" in line:
- return line
- else:
- newlines.append(line)
-
- def skip_to_super_init_end():
- for line in common_linegen:
- if "precedence=precedence)" in line:
- return line
- else:
- newlines.append(line)
-
- def is_function(line: str) -> bool:
- if "def " in line and "self" not in line and "cls" not in line and "obj" not in line:
- return True
- return False
-
- def next_line_after_skip_class_or_function() -> str:
- for line_ in common_linegen:
- if ("class " in line_ and ":" in line_) or is_function(line_):
- return line_
-
- def process_current_line(line: str):
- newline = line
- if "import " in line and "parameterized " in line:
- newlines_ = [
- line.replace("from .parameterized", "from ..param.parameterized").replace("ParamOverrides,", ""),
- next(common_linegen).replace("ParameterizedFunction, descendents,", ""),
- *additional_imports,
- ]
- newlines.extend(newlines_)
- return
- elif "from collections import OrderedDict" in line:
- newlines.append("from enum import Enum\n")
- elif "from .utils" in line or "from .exceptions" in line:
- newline = line.replace("from .", "from ..param.")
- elif "class " in line and ":" in line and line.startswith("class"):
- if "(Parameter):" in line:
- newline = line.replace("(Parameter):", "(RemoteParameter):")
- newlines.append(newline)
- else:
- classname_with_inheritance = line.split(" ", 1)[1][:-2] # [:-2] for removing colon
- classname_without_inheritance = classname_with_inheritance.split("(", 1)[0]
- if classname_without_inheritance in skip_classes:
- newline = next_line_after_skip_class_or_function()
- process_current_line(newline)
- return
- else:
- newlines.append(line)
- newline = skip_to_init_doc()
- newlines.append(newline)
- newlines.extend(remote_init_kwargs)
- newline = skip_to_super_init_end()
- if newline:
- newline = newline.replace("precedence=precedence)", "precedence=precedence,")
- newlines.append(newline)
- newlines.extend(remote_super_init)
- return
- elif "Parameter.__init__" in line:
- newline = line.replace("Parameter.__init__", "RemoteParameter.__init__")
- elif is_function(line):
- newline = next_line_after_skip_class_or_function()
- process_current_line(newline)
- return
- newlines.append(newline)
-
- for line in common_linegen:
- process_current_line(line)
- if end_line in line:
- newlines.pop()
- break
-
- with open(dst, "w") as file:
- file.writelines(newlines)
diff --git a/hololinked/server/http/__init__.py b/hololinked/server/http/__init__.py
index 74b13a41..18bc5164 100644
--- a/hololinked/server/http/__init__.py
+++ b/hololinked/server/http/__init__.py
@@ -1,45 +1,49 @@
-import warnings
import logging
import socket
import ssl
import typing
+import warnings
+
+from copy import deepcopy
+
import structlog
+
from pydantic import BaseModel
-from copy import deepcopy
from tornado import ioloop
-from tornado.web import Application
from tornado.httpserver import HTTPServer as TornadoHTTP1Server
-# from tornado_http2.server import Server as TornadoHTTP2Server
+from tornado.web import Application
-from ...param.parameters import IPAddress, ClassSelector, TypedList
+from ...config import global_config
from ...constants import HTTP_METHODS
+from ...core.actions import Action
+from ...core.events import Event
+from ...core.property import Property
+from ...core.thing import Thing, ThingMeta
+from ...core.zmq.brokers import MessageMappedZMQClientPool
+
+# from tornado_http2.server import Server as TornadoHTTP2Server
+from ...param.parameters import ClassSelector, IPAddress, TypedList
+from ...td import ActionAffordance, EventAffordance, PropertyAffordance
from ...utils import (
get_current_async_loop,
issubklass,
pep8_to_dashed_name,
run_callable_somehow,
)
-from ...config import global_config
-from ...core.property import Property
-from ...core.actions import Action
-from ...core.events import Event
-from ...core.thing import Thing, ThingMeta
-from ...core.zmq.brokers import MessageMappedZMQClientPool
-from ...td import ActionAffordance, EventAffordance, PropertyAffordance
-from ..server import BaseProtocolServer, BrokerThing
from ..security import Security
+from ..server import BaseProtocolServer, BrokerThing
from ..utils import consume_broker_queue
from .handlers import (
ActionHandler,
+ BaseHandler,
+ EventHandler,
LivenessProbeHandler,
- ReadinessProbeHandler,
PropertyHandler,
- EventHandler,
- BaseHandler,
+ ReadinessProbeHandler,
+ RPCHandler,
RWMultiplePropertiesHandler,
StopHandler,
ThingDescriptionHandler,
- RPCHandler,
)
@@ -274,8 +278,14 @@ async def async_stop(self) -> None:
self.zmq_client_pool.stop_polling()
if not self.tornado_instance:
return
- self.tornado_instance.stop()
- await self.tornado_instance.close_all_connections()
+ try:
+ self.tornado_instance.stop()
+ await self.tornado_instance.close_all_connections()
+ except Exception as ex:
+ self.logger.error(
+ "error while stopping tornado server, use stop() method "
+ + f"from hololinked.server and do not reuse the port - {ex}"
+ )
def add_property(
self,
diff --git a/hololinked/server/http/handlers.py b/hololinked/server/http/handlers.py
index f8ace3c7..afef9d78 100644
--- a/hololinked/server/http/handlers.py
+++ b/hololinked/server/http/handlers.py
@@ -1,37 +1,40 @@
import copy
import typing
import uuid
-from tornado.web import RequestHandler, StaticFileHandler
-from tornado.iostream import StreamClosedError
+
import msgspec
+
from msgspec import DecodeError as MsgspecJSONDecodeError
+from tornado.iostream import StreamClosedError
+from tornado.web import RequestHandler, StaticFileHandler
-from ...utils import format_exception_as_json, get_current_async_loop
from ...config import global_config
+from ...constants import JSONSerializable, Operations
from ...core.zmq.brokers import AsyncEventConsumer, EventConsumer
from ...core.zmq.message import (
EMPTY_BYTE,
- TIMEOUT,
ERROR,
INVALID_MESSAGE,
+ TIMEOUT,
ResponseMessage,
+ SerializableNone,
+ ServerExecutionContext,
+ ThingExecutionContext,
default_server_execution_context,
default_thing_execution_context,
- ThingExecutionContext,
- ServerExecutionContext,
)
-from ...core.zmq.message import SerializableNone
-from ...constants import JSONSerializable, Operations
from ...schema_validators import BaseSchemaValidator
-from ...serializers.payloads import PreserializedData, SerializableData
from ...serializers import Serializers
+from ...serializers.payloads import PreserializedData, SerializableData
from ...td import (
- InteractionAffordance,
- PropertyAffordance,
ActionAffordance,
EventAffordance,
+ InteractionAffordance,
+ PropertyAffordance,
)
from ...td.forms import Form
+from ...utils import format_exception_as_json, get_current_async_loop
+
try:
from ..security import BcryptBasicSecurity
@@ -662,6 +665,7 @@ def initialize(self, owner_inst=None) -> None:
self.server = owner_inst
self.allowed_clients = self.server.allowed_clients
self.security_schemes = self.server.security_schemes
+ self.logger = self.server.logger.bind(path=self.request.path)
async def post(self):
if not self.has_access_control:
@@ -691,6 +695,7 @@ def initialize(self, owner_inst=None) -> None:
assert isinstance(owner_inst, HTTPServer)
self.server = owner_inst
+ self.logger = self.server.logger.bind(path=self.request.path)
async def get(self):
self.set_status(200, "ok")
@@ -704,6 +709,7 @@ def initialize(self, owner_inst=None) -> None:
assert isinstance(owner_inst, HTTPServer)
self.server = owner_inst
+ self.logger = self.server.logger.bind(path=self.request.path)
async def get(self):
try:
diff --git a/hololinked/utils.py b/hololinked/utils.py
index f19b3fc1..0f24b892 100644
--- a/hololinked/utils.py
+++ b/hololinked/utils.py
@@ -1,19 +1,20 @@
-import sys
-import logging
-import re
import asyncio
import inspect
-import typing
-import types
-import traceback
-import ifaddr
+import logging
+import re
+import sys
import threading
-from functools import wraps
+import traceback
+import types
+import typing
from collections import OrderedDict
from dataclasses import asdict
-from pydantic import BaseModel, ConfigDict, create_model, Field, RootModel
+from functools import wraps
from inspect import Parameter, signature
+import ifaddr
+from pydantic import BaseModel, ConfigDict, Field, RootModel, create_model
+
def get_IP_from_interface(interface_name: str = "Ethernet", adapter_name=None) -> str:
"""
diff --git a/pyproject.toml b/pyproject.toml
index a14503e6..8cc0bcdb 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -88,7 +88,8 @@ test = [
"fastjsonschema==2.20.0",
"pytest>=8.0.0",
"pytest-cov>=4.0.0",
- "pytest-order>=1.0.0"
+ "pytest-order>=1.0.0",
+ "pytest-asyncio>=1.3.0",
]
linux = [
"uvloop==0.20.0"
@@ -97,14 +98,17 @@ linux = [
[tool.pytest.ini_options]
minversion = "8.0"
addopts = "-ra --strict-markers --strict-config --ignore=lib64"
-testpaths = ["tests/pytests-new"]
-python_files = ["test_*_pytest.py"]
+testpaths = ["tests"]
+norecursedirs = ["tests/yet-to-be-integrated*"]
+python_files = ["test_*.py"]
python_classes = ["Test*"]
python_functions = ["test_*"]
+asyncio_mode = "auto"
markers = [
"order: mark test to run in a specific order",
"slow: marks tests as slow (deselect with '-m \"not slow\"')",
- "integration: marks tests as integration tests"
+ "integration: marks tests as integration tests",
+ "asyncio: mark test as asyncio to run with pytest-asyncio"
]
filterwarnings = [
"error",
@@ -117,4 +121,4 @@ filterwarnings = [
exclude = [
"hololinked/core/properties.py",
"hololinked/param"
-]
+]
\ No newline at end of file
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 00000000..60340fd6
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,65 @@
+"""pytest configuration and shared fixtures for hololinked tests"""
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from uuid import uuid4
+
+import pytest
+import zmq.asyncio
+
+from hololinked.config import global_config
+from hololinked.logger import setup_logging
+from hololinked.serializers import Serializers
+from hololinked.server import stop
+from hololinked.utils import set_global_event_loop_policy
+
+
+@dataclass
+class AppIDs:
+ """
+ Application related IDs generally used by end-user,
+ like server, client, and thing IDs.
+ """
+
+ server_id: str
+ """RPC server ID"""
+ client_id: str
+ """A client ID"""
+ thing_id: str
+ """A thing ID"""
+
+
+@pytest.fixture(scope="session")
+def event_loop():
+ try:
+ loop = asyncio.get_running_loop()
+ except RuntimeError:
+ loop = asyncio.new_event_loop()
+ yield loop
+ loop.close()
+
+
+@pytest.fixture(autouse=True, scope="module")
+def setup_test_environment():
+ """Automatically setup test environment for each file"""
+ # This fixture runs automatically for every test
+ set_global_event_loop_policy()
+ global_config.ZMQ_CONTEXT = zmq.asyncio.Context()
+ setup_logging(log_level=logging.ERROR + 10)
+ yield
+ stop()
+ # Reset serializers after each test
+ Serializers().reset()
+ global_config.ZMQ_CONTEXT.destroy(linger=0)
+ global_config.ZMQ_CONTEXT.term()
+
+
+@pytest.fixture()
+def app_ids() -> AppIDs:
+ """Generate unique test IDs for server, client, and thing for each test"""
+ return AppIDs(
+ server_id=f"test-server-{uuid4().hex[:8]}",
+ client_id=f"test-client-{uuid4().hex[:8]}",
+ thing_id=f"test-thing-{uuid4().hex[:8]}",
+ )
diff --git a/tests/helper-scripts/run_testthing_basic.py b/tests/helper-scripts/run_testthing_basic.py
deleted file mode 100644
index ef09f147..00000000
--- a/tests/helper-scripts/run_testthing_basic.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# run_testthing_basic.py
-import logging, time, uuid
-from tests.things.test_thing import TestThing
-from hololinked.server.security import BcryptBasicSecurity
-
-thing_id = f"tt-{uuid.uuid4().hex[:6]}"
-port = 60110
-sec = BcryptBasicSecurity(username="cliuser", password="clipass")
-
-thing = TestThing(id=thing_id, log_level=logging.INFO)
-thing.run_with_http_server(forked=True, port=port, config={"allow_cors": True}, security_schemes=[sec])
-
-print(f"TD: http://127.0.0.1:{port}/{thing_id}/resources/wot-td")
-print(f"Prop: http://127.0.0.1:{port}/{thing_id}/base-property")
-while True:
- time.sleep(5)
diff --git a/tests/not working - yet to be integrated/test_09_rpc_broker.py b/tests/not working - yet to be integrated/test_09_rpc_broker.py
deleted file mode 100644
index 4f2e350e..00000000
--- a/tests/not working - yet to be integrated/test_09_rpc_broker.py
+++ /dev/null
@@ -1,1100 +0,0 @@
-import asyncio
-import copy
-import threading
-import typing
-import unittest
-import jsonschema
-import logging
-import random
-import time
-import structlog
-from types import SimpleNamespace
-
-from hololinked.client.abstractions import SSE
-from hololinked.core.actions import BoundAction
-from hololinked.core.property import Property
-from hololinked.core.thing import Thing
-from hololinked.core.zmq.brokers import (
- AsyncEventConsumer,
- AsyncZMQClient,
- EventConsumer,
- EventPublisher,
- SyncZMQClient,
-)
-from hololinked.core.zmq.message import EXIT, RequestMessage
-from hololinked.core.zmq.rpc_server import RPCServer
-from hololinked.server.zmq import ZMQServer
-from hololinked.td.forms import Form
-from hololinked.td.utils import get_zmq_unique_identifier_from_event_affordance
-from hololinked.utils import get_all_sub_things_recusively, get_current_async_loop
-from hololinked.config import global_config
-from hololinked.td import ActionAffordance, PropertyAffordance, EventAffordance
-from hololinked.client.zmq.consumed_interactions import ZMQAction, ZMQProperty, ZMQEvent
-from hololinked.logger import setup_logging
-
-try:
- from .test_05_brokers import TestBrokerMixin
- from .test_06_actions import replace_methods_with_actions
- from .utils import TestRunner, TestCase
- from .things import (
- run_thing_with_zmq_server_forked,
- test_thing_TD as test_thing_original_TD,
- TestThing,
- )
-except ImportError:
- from test_05_brokers import TestBrokerMixin
- from test_06_actions import replace_methods_with_actions
- from utils import TestRunner, TestCase
- from things import (
- run_thing_with_zmq_server_forked,
- test_thing_TD as test_thing_original_TD,
- TestThing,
- )
-
-data_structures = [
- {"key": "value"},
- [1, 2, 3],
- "string",
- 42,
- 3.14,
- True,
- None,
- {"nested": {"key": "value"}},
- [{"list": "of"}, {"dicts": "here"}],
- {"complex": {"nested": {"list": [1, 2, 3]}, "mixed": [1, "two", 3.0, None]}},
- {"array": [1, 2, 3]},
-] # to use for testing
-
-
-# global_config.DEBUG = True
-setup_logging(log_level=logging.ERROR)
-
-
-class InteractionAffordanceMixin(TestBrokerMixin):
- @classmethod
- def setUpClass(cls):
- super().setUpClass()
- cls.setUpActions()
- cls.setUpProperties()
- cls.setUpEvents()
-
- @classmethod
- def setUpActions(cls):
- owner_inst = SimpleNamespace(_noblock_messages={})
- test_thing_TD = copy.deepcopy(test_thing_original_TD)
- test_thing_TD["id"] = cls.thing_id
- cls.action_echo = ZMQAction(
- resource=ActionAffordance.from_TD("action_echo", test_thing_TD),
- sync_client=cls.sync_client,
- async_client=cls.async_client,
- owner_inst=owner_inst,
- logger=structlog.get_logger(),
- invokation_timeout=5,
- execution_timeout=5,
- )
-
- cls.action_get_serialized_data = ZMQAction(
- resource=ActionAffordance.from_TD("get_serialized_data", test_thing_TD),
- sync_client=cls.sync_client,
- async_client=cls.async_client,
- owner_inst=owner_inst,
- logger=structlog.get_logger(),
- invokation_timeout=5,
- execution_timeout=5,
- )
-
- cls.action_sleep = ZMQAction(
- resource=ActionAffordance.from_TD("sleep", test_thing_TD),
- sync_client=cls.sync_client,
- async_client=cls.async_client,
- owner_inst=owner_inst,
- logger=structlog.get_logger(),
- invokation_timeout=5,
- execution_timeout=5,
- )
-
- cls.action_get_mixed_content_data = ZMQAction(
- resource=ActionAffordance.from_TD("get_mixed_content_data", test_thing_TD),
- sync_client=cls.sync_client,
- async_client=cls.async_client,
- owner_inst=owner_inst,
- logger=structlog.get_logger(),
- invokation_timeout=5,
- execution_timeout=5,
- )
- cls.action_push_events = ZMQAction(
- resource=ActionAffordance.from_TD("push_events", test_thing_TD),
- sync_client=cls.sync_client,
- async_client=cls.async_client,
- owner_inst=owner_inst,
- logger=structlog.get_logger(),
- invokation_timeout=5,
- execution_timeout=5,
- )
-
- @classmethod
- def setUpProperties(cls):
- owner_inst = SimpleNamespace(_noblock_messages={})
- test_thing_TD = copy.deepcopy(test_thing_original_TD)
- test_thing_TD["id"] = cls.thing_id
- cls.base_property = ZMQProperty(
- resource=PropertyAffordance.from_TD("base_property", test_thing_TD),
- sync_client=cls.sync_client,
- async_client=cls.async_client,
- owner_inst=owner_inst,
- logger=structlog.get_logger(),
- invokation_timeout=5,
- execution_timeout=5,
- )
- cls.total_number_of_events = ZMQProperty(
- resource=PropertyAffordance.from_TD("total_number_of_events", test_thing_TD),
- sync_client=cls.sync_client,
- async_client=cls.async_client,
- owner_inst=owner_inst,
- logger=structlog.get_logger(),
- invokation_timeout=5,
- execution_timeout=5,
- )
-
- @classmethod
- def setUpEvents(cls):
- owner_inst = SimpleNamespace(_noblock_messages={})
- test_thing_TD = copy.deepcopy(test_thing_original_TD)
- test_thing_TD["id"] = cls.thing_id
- cls.test_event = ZMQEvent(
- resource=EventAffordance.from_TD("test_event", test_thing_TD),
- owner_inst=owner_inst,
- logger=structlog.get_logger(),
- )
-
-
-class TestRPCServerMixin(InteractionAffordanceMixin):
- @classmethod
- def setUpThing(cls):
- replace_methods_with_actions(TestThing)
- super().setUpThing()
-
- @classmethod
- def setUpServer(cls):
- cls.server = RPCServer(id=cls.server_id, things=[cls.thing])
-
- @classmethod
- def setUpClient(cls):
- cls.async_client = AsyncZMQClient(
- id=cls.client_id,
- server_id=cls.server_id,
- access_point="INPROC",
- handshake=False,
- )
- cls.sync_client = SyncZMQClient(
- id=cls.client_id + "-sync",
- server_id=cls.server_id,
- access_point="INPROC",
- handshake=False,
- )
-
- @classmethod
- def startServer(cls):
- cls._server_thread = threading.Thread(
- target=cls.server.run,
- daemon=False, # to test exit daemon must be False
- )
- cls._server_thread.start()
-
- @classmethod
- def setUpClass(cls):
- super().setUpClass()
- print(f"test ZMQ RPC Server {cls.__name__}")
-
- @classmethod
- def tearDownClass(cls):
- cls.server.stop()
- return super().tearDownClass()
-
-
-class TestInprocRPCServer(TestRPCServerMixin):
- def test_1_creation_defaults(self):
- """test server configuration defaults"""
- self.assertTrue(self.server.req_rep_server.socket_address.startswith("inproc://"))
- self.assertTrue(self.server.event_publisher.socket_address.startswith("inproc://"))
-
- self.assertTrue(self.thing.rpc_server, self.server)
- self.assertTrue(self.thing.event_publisher, self.server.event_publisher)
-
- def test_2_handshake(self):
- """test handshake mechanisms"""
- self.sync_client.handshake()
-
- async def async_handshake():
- self.async_client.handshake()
- await self.async_client.handshake_complete()
-
- get_current_async_loop().run_until_complete(async_handshake())
-
- def test_3_action_abstractions(self):
- """ "test if action can be invoked by a client"""
-
- async def test_basic_operations():
- """Test if action can be invoked by a client in basic request/response way, oneway and no block"""
- nonlocal self
- await self.action_echo.async_call("value")
- self.action_echo.oneway(5)
- noblock_msg_id = self.action_echo.noblock(10)
- self.assertEqual(self.action_echo.last_return_value, "value")
- # test the responses for no block call, so read the socket - but, this is usually abstracte in a higher level API
- response = self.action_echo._sync_zmq_client.recv_response(noblock_msg_id)
- self.action_echo._last_zmq_response = response
- self.assertEqual(self.action_echo.last_return_value, 10)
- self.assertEqual(self.action_echo(2), 2)
-
- get_current_async_loop().run_until_complete(test_basic_operations())
- self.sync_client.handshake()
-
- async def test_operations_thorough():
- # Generate 20 random JSON serializable data structures
- nonlocal self
- global data_structures
-
- msg_ids = [None for i in range(len(data_structures))]
- last_call_type = None
- # Randomize calls to self.action_echo
- for index, data in enumerate(data_structures):
- call_type = random.choice(["async_call", "plain_call", "oneway", "noblock"])
- if call_type == "async_call":
- result = await self.action_echo.async_call(data)
- self.assertEqual(result, data)
- elif call_type == "plain_call":
- result = self.action_echo(data)
- self.assertEqual(result, data)
- elif call_type == "oneway":
- self.action_echo.oneway(data)
- self.assertNotEqual(data, self.action_echo.last_return_value)
- elif call_type == "noblock":
- msg_ids[index] = self.action_echo.noblock(data)
- self.assertNotEqual(data, self.action_echo.last_return_value)
-
- # print("last_call_type", last_call_type, "call_type", call_type, "data", data)
- if last_call_type == "noblock":
- response = self.action_echo._sync_zmq_client.recv_response(msg_ids[index - 1])
- self.action_echo._last_zmq_response = response
- self.assertEqual(self.action_echo.last_return_value, data_structures[index - 1])
-
- last_call_type = call_type
-
- get_current_async_loop().run_until_complete(test_operations_thorough())
- self.sync_client.handshake()
-
- def test_4_property_abstractions(self):
- """Test if property can be invoked by a client"""
-
- def test_basic_operations():
- nonlocal self
- self.base_property.set(100)
- self.assertEqual(self.base_property.get(), 100)
- self.base_property.oneway_set(200)
- self.assertEqual(self.base_property.get(), 200)
-
- async def test_async_property_abstractions():
- nonlocal self
- await self.base_property.async_set(300)
- self.assertEqual(self.base_property.get(), 300)
- await self.base_property.async_set(0)
- self.assertEqual(await self.base_property.async_get(), 0)
-
- get_current_async_loop().run_until_complete(test_async_property_abstractions())
-
- test_basic_operations()
- self.sync_client.handshake()
-
- async def test_operations_thorough():
- # Generate 20 random JSON serializable data structures
- nonlocal self
- global data_structures
-
- msg_ids = [None for i in range(len(data_structures))]
- last_call_type = None
- # Randomize calls to self.action_echo
- for index, data in enumerate(data_structures):
- call_type = random.choice(["async_set", "set", "oneway_set", "noblock_get"])
- if call_type == "async_set":
- self.assertIsNone(await self.base_property.async_set(data))
- self.assertEqual(await self.base_property.async_get(), data)
- elif call_type == "set":
- self.assertIsNone(self.base_property.set(data))
- self.assertEqual(self.base_property.get(), data)
- elif call_type == "oneway_set":
- self.assertIsNone(self.base_property.oneway_set(data))
- self.assertNotEqual(data, self.base_property.last_read_value)
- self.assertEqual(data, self.base_property.get())
- # for one way calls as well, get() will return the latest value
- elif call_type == "noblock_get":
- msg_ids[index] = self.base_property.noblock_get()
- self.assertNotEqual(data, self.base_property.last_read_value)
-
- # print("last_call_type", last_call_type, "call_type", call_type, "data", data)
- if last_call_type == "noblock":
- response = self.base_property._sync_zmq_client.recv_response(msg_ids[index - 1])
- self.base_property._last_zmq_response = response
- self.assertEqual(self.base_property.last_read_value, data_structures[index - 1])
-
- last_call_type = call_type
-
- get_current_async_loop().run_until_complete(test_operations_thorough())
- self.sync_client.handshake()
-
- def test_5_thing_execution_context(self):
- """test if thing execution context is used correctly"""
- old_thing_execution_context = self.action_echo._thing_execution_context
- # Only fetch_execution_logs currently supported
- self.action_echo._thing_execution_context = dict(fetch_execution_logs=True)
- get_current_async_loop().run_until_complete(self.action_echo.async_call("value"))
- self.assertIsInstance(self.action_echo.last_return_value, dict)
- self.assertTrue("execution_logs" in self.action_echo.last_return_value.keys())
- self.assertTrue("return_value" in self.action_echo.last_return_value.keys())
- self.assertTrue(len(self.action_echo.last_return_value) == 2)
- self.assertFalse(self.action_echo.last_return_value == "value") # because its a dict now
- self.assertIsInstance(self.action_echo.last_return_value["execution_logs"], list)
- self.assertTrue(self.action_echo.last_return_value["return_value"] == "value")
- self.action_echo._thing_execution_context = old_thing_execution_context
-
- def test_6_server_execution_context(self):
- """test if server execution context is used correctly"""
-
- async def test_execution_timeout():
- try:
- await self.action_sleep.async_call()
- except Exception as ex:
- self.assertIsInstance(ex, TimeoutError)
- self.assertIn("Execution timeout occured", str(ex))
- else:
- self.assertTrue(False) # fail the test if reached here
-
- get_current_async_loop().run_until_complete(test_execution_timeout())
-
- async def test_invokation_timeout():
- try:
- old_timeout = self.action_sleep._invokation_timeout
- self.action_sleep._invokation_timeout = 0.1 # reduce the value to test timeout
- await self.action_sleep.async_call()
- except Exception as ex:
- self.assertIsInstance(ex, TimeoutError)
- self.assertIn("Invokation timeout occured", str(ex))
- else:
- self.assertTrue(False) # fail the test if reached here
- finally:
- self.action_sleep._invokation_timeout = old_timeout
-
- get_current_async_loop().run_until_complete(test_invokation_timeout())
-
- def test_7_binary_payloads(self):
- """test if binary payloads are handled correctly"""
- self.assertEqual(self.action_get_mixed_content_data(), ("foobar", b"foobar"))
- self.assertEqual(self.action_get_serialized_data(), b"foobar")
-
- async def async_call():
- await self.action_get_mixed_content_data.async_call()
- return self.action_get_mixed_content_data.last_return_value
-
- result = get_current_async_loop().run_until_complete(async_call())
- self.assertEqual(result, ("foobar", b"foobar"))
-
- async def async_call():
- await self.action_get_serialized_data.async_call()
- return self.action_get_serialized_data.last_return_value
-
- result = get_current_async_loop().run_until_complete(async_call())
- self.assertEqual(result, b"foobar")
-
- def test_8_stop(self):
- """test if server can be stopped"""
- self.server.stop()
-
-
-class TestRPCServer(TestInprocRPCServer):
- @classmethod
- def setUpServer(cls):
- cls.server = ZMQServer(
- id=cls.server_id,
- things=[cls.thing],
- access_points=["INPROC", "IPC", "tcp://*:59000"],
- )
-
- @classmethod
- def setUpClient(cls):
- super().setUpClient()
- cls.sync_ipc_client = SyncZMQClient(
- id=cls.client_id + "-sync",
- server_id=cls.server_id,
- handshake=False,
- access_point="IPC",
- )
- cls.sync_tcp_client = SyncZMQClient(
- id=cls.client_id + "-sync",
- server_id=cls.server_id,
- handshake=False,
- access_point="tcp://localhost:59000",
- )
- cls.async_ipc_client = AsyncZMQClient(
- id=cls.client_id + "-async",
- server_id=cls.server_id,
- handshake=False,
- access_point="IPC",
- )
- cls.async_tcp_client = AsyncZMQClient(
- id=cls.client_id + "-async",
- server_id=cls.server_id,
- handshake=False,
- access_point="tcp://localhost:59000",
- )
-
- def test_1_creation_defaults(self):
- super().test_1_creation_defaults()
- # check socket creation defaults
- self.assertTrue(self.server.ipc_server.socket_address.startswith("ipc://"))
- self.assertTrue(self.server.tcp_server.socket_address.startswith("tcp://"))
- self.assertTrue(self.server.tcp_server.socket_address.endswith(":59000"))
-
- def test_2_handshake(self):
- super().test_2_handshake()
- self.sync_ipc_client.handshake()
- self.sync_tcp_client.handshake()
-
- async def async_handshake():
- self.async_ipc_client.handshake()
- await self.async_ipc_client.handshake_complete()
- self.async_tcp_client.handshake()
- await self.async_tcp_client.handshake_complete()
-
- get_current_async_loop().run_until_complete(async_handshake())
-
- def test_3_action_abstractions(self):
- old_sync_client = self.action_echo._sync_zmq_client
- old_async_client = self.action_echo._async_zmq_client
- for clients in [
- (self.sync_tcp_client, self.async_tcp_client),
- (self.sync_ipc_client, self.async_ipc_client),
- ]:
- self.action_echo._sync_zmq_client, self.action_echo._async_zmq_client = clients
- super().test_3_action_abstractions()
- self.action_echo._sync_zmq_client = old_sync_client
- self.action_echo._async_zmq_client = old_async_client
-
- def test_4_property_abstractions(self):
- old_sync_client = self.base_property._sync_zmq_client
- old_async_client = self.base_property._async_zmq_client
- for clients in [
- (self.sync_tcp_client, self.async_tcp_client),
- (self.sync_ipc_client, self.async_ipc_client),
- ]:
- (
- self.base_property._sync_zmq_client,
- self.base_property._async_zmq_client,
- ) = clients
- super().test_4_property_abstractions()
- self.base_property._sync_zmq_client = old_sync_client
- self.base_property._async_zmq_client = old_async_client
-
- def test_5_thing_execution_context(self):
- old_sync_client = self.action_echo._sync_zmq_client
- old_async_client = self.action_echo._async_zmq_client
- for clients in [
- (self.sync_tcp_client, self.async_tcp_client),
- (self.sync_ipc_client, self.async_ipc_client),
- ]:
- self.action_echo._sync_zmq_client, self.action_echo._async_zmq_client = clients
- super().test_5_thing_execution_context()
- self.action_echo._sync_zmq_client = old_sync_client
- self.action_echo._async_zmq_client = old_async_client
-
- def test_6_server_execution_context(self):
- old_sync_client = self.action_sleep._sync_zmq_client
- old_async_client = self.action_sleep._async_zmq_client
- for clients in [
- (self.sync_tcp_client, self.async_tcp_client),
- (self.sync_ipc_client, self.async_ipc_client),
- ]:
- self.action_sleep._sync_zmq_client, self.action_sleep._async_zmq_client = clients
- super().test_6_server_execution_context()
- self.action_sleep._sync_zmq_client = old_sync_client
- self.action_sleep._async_zmq_client = old_async_client
-
- def test_7_binary_payloads(self):
- for clients in [
- (self.sync_tcp_client, self.async_tcp_client),
- (self.sync_ipc_client, self.async_ipc_client),
- ]:
- for action in [
- self.action_get_serialized_data,
- self.action_get_mixed_content_data,
- ]:
- action._sync_zmq_client, action._async_zmq_client = clients
- super().test_7_binary_payloads()
-
-
-class TestExposedActions(InteractionAffordanceMixin):
- @classmethod
- def setUpServer(cls):
- pass
-
- @classmethod
- def setUpThing(cls):
- pass
-
- @classmethod
- def startServer(cls):
- run_thing_with_zmq_server_forked(
- thing_cls=TestThing,
- id=cls.server_id,
- log_level=logging.ERROR + 10,
- done_queue=cls.done_queue,
- prerun_callback=replace_methods_with_actions,
- as_process=False,
- )
-
- @classmethod
- def setUpClient(cls):
- super().setUpClient()
- cls.sync_client = SyncZMQClient(
- id=cls.client_id,
- server_id=cls.server_id,
- handshake=False,
- )
- cls.client = cls.sync_client
-
- def test_1_exposed_actions(self):
- """
- Now that actions can be invoked by a client, test different types of actions
- and their behaviors
- """
- replace_methods_with_actions(TestThing)
- thing = TestThing(id=self.server_id)
- # has to match server only because run_thing_with_zmq_server_forked equates server_id and thing_id
- self.sync_client.handshake()
-
- # thing_client = ObjectProxy('test-action', log_level=logging.ERROR) # type: TestThing
- assert isinstance(thing.action_echo, BoundAction) # type definition
- action_echo = ZMQAction(
- resource=thing.action_echo.to_affordance(),
- sync_client=self.client,
- async_client=None,
- logger=structlog.get_logger(),
- owner_inst=None,
- )
- self.assertEqual(action_echo(1), 1)
-
- assert isinstance(thing.action_echo_with_classmethod, BoundAction) # type definition
- action_echo_with_classmethod = ZMQAction(
- resource=thing.action_echo_with_classmethod.to_affordance(),
- sync_client=self.client,
- async_client=None,
- logger=structlog.get_logger(),
- owner_inst=None,
- )
- self.assertEqual(action_echo_with_classmethod(2), 2)
-
- assert isinstance(thing.action_echo_async, BoundAction) # type definition
- action_echo_async = ZMQAction(
- resource=thing.action_echo_async.to_affordance(),
- sync_client=self.client,
- async_client=None,
- logger=structlog.get_logger(),
- owner_inst=None,
- )
- self.assertEqual(action_echo_async("string"), "string")
-
- assert isinstance(thing.action_echo_async_with_classmethod, BoundAction) # type definition
- action_echo_async_with_classmethod = ZMQAction(
- resource=thing.action_echo_async_with_classmethod.to_affordance(),
- sync_client=self.client,
- async_client=None,
- logger=structlog.get_logger(),
- owner_inst=None,
- )
- self.assertEqual(action_echo_async_with_classmethod([1, 2]), [1, 2])
-
- assert isinstance(thing.parameterized_action, BoundAction) # type definition
- parameterized_action = ZMQAction(
- resource=thing.parameterized_action.to_affordance(),
- sync_client=self.client,
- async_client=None,
- logger=structlog.get_logger(),
- owner_inst=None,
- )
- self.assertEqual(
- parameterized_action(arg1=1, arg2="hello", arg3=5),
- [self.server_id, 1, "hello", 5],
- )
-
- assert isinstance(thing.parameterized_action_async, BoundAction) # type definition
- parameterized_action_async = ZMQAction(
- resource=thing.parameterized_action_async.to_affordance(),
- sync_client=self.client,
- async_client=None,
- logger=structlog.get_logger(),
- owner_inst=None,
- )
- self.assertEqual(
- parameterized_action_async(arg1=2.5, arg2="hello", arg3="foo"),
- [self.server_id, 2.5, "hello", "foo"],
- )
-
- assert isinstance(thing.parameterized_action_without_call, BoundAction) # type definition
- parameterized_action_without_call = ZMQAction(
- resource=thing.parameterized_action_without_call.to_affordance(),
- sync_client=self.client,
- async_client=None,
- logger=structlog.get_logger(),
- owner_inst=None,
- )
- with self.assertRaises(NotImplementedError) as ex:
- parameterized_action_without_call(arg1=2, arg2="hello", arg3=5)
- self.assertTrue(str(ex.exception).startswith("Subclasses must implement __call__"))
-
- def test_2_schema_validation(self):
- """Test if schema validation is working correctly"""
- self._test_2_json_schema_validation()
- self._test_2_pydantic_validation()
-
- def _test_2_json_schema_validation(self):
- thing = TestThing(id=self.server_id)
- self.sync_client.handshake()
-
- # JSON schema validation
- assert isinstance(thing.json_schema_validated_action, BoundAction) # type definition
- action_affordance = thing.json_schema_validated_action.to_affordance()
- json_schema_validated_action = ZMQAction(
- resource=action_affordance, sync_client=self.client, async_client=None, owner_inst=None
- )
- # data with invalid schema
- with self.assertRaises(Exception) as ex1:
- json_schema_validated_action(val1="1", val2="hello", val3={"field": "value"}, val4=[])
- self.assertTrue(str(ex1.exception).startswith("'1' is not of type 'integer'"))
- with self.assertRaises(Exception) as ex2:
- json_schema_validated_action("1", val2="hello", val3={"field": "value"}, val4=[])
- self.assertTrue(str(ex2.exception).startswith("'1' is not of type 'integer'"))
- with self.assertRaises(Exception) as ex3:
- json_schema_validated_action(1, 2, val3={"field": "value"}, val4=[])
- self.assertTrue(str(ex3.exception).startswith("2 is not of type 'string'"))
- with self.assertRaises(Exception) as ex4:
- json_schema_validated_action(1, "hello", val3="field", val4=[])
- self.assertTrue(str(ex4.exception).startswith("'field' is not of type 'object'"))
- with self.assertRaises(Exception) as ex5:
- json_schema_validated_action(1, "hello", val3={"field": "value"}, val4="[]")
- self.assertTrue(str(ex5.exception).startswith("'[]' is not of type 'array'"))
- # data with valid schema
- return_value = json_schema_validated_action(val1=1, val2="hello", val3={"field": "value"}, val4=[])
- self.assertEqual(return_value, {"val1": 1, "val3": {"field": "value"}})
- jsonschema.Draft7Validator(action_affordance.output).validate(return_value)
-
- def _test_2_pydantic_validation(self):
- thing = TestThing(id=self.server_id)
- self.sync_client.handshake()
-
- # Pydantic schema validation
- assert isinstance(thing.pydantic_validated_action, BoundAction) # type definition
- action_affordance = thing.pydantic_validated_action.to_affordance()
- pydantic_validated_action = ZMQAction(
- resource=action_affordance, sync_client=self.client, async_client=None, owner_inst=None
- )
- # data with invalid schema
- with self.assertRaises(Exception) as ex1:
- pydantic_validated_action(val1="1", val2="hello", val3={"field": "value"}, val4=[])
- self.assertTrue(
- "validation error for pydantic_validated_action_input" in str(ex1.exception)
- and "val1" in str(ex1.exception)
- and "val2" not in str(ex1.exception)
- and "val3" not in str(ex1.exception)
- and "val4" not in str(ex1.exception)
- ) # {obj.name}_input is the pydantic model name
- with self.assertRaises(Exception) as ex2:
- pydantic_validated_action("1", val2="hello", val3={"field": "value"}, val4=[])
- self.assertTrue(
- "validation error for pydantic_validated_action_input" in str(ex2.exception)
- and "val1" in str(ex2.exception)
- and "val2" not in str(ex2.exception)
- and "val3" not in str(ex2.exception)
- and "val4" not in str(ex2.exception)
- )
- with self.assertRaises(Exception) as ex3:
- pydantic_validated_action(1, 2, val3={"field": "value"}, val4=[])
- self.assertTrue(
- "validation error for pydantic_validated_action_input" in str(ex3.exception)
- and "val1" not in str(ex3.exception)
- and "val2" in str(ex3.exception)
- and "val3" not in str(ex3.exception)
- and "val4" not in str(ex3.exception)
- )
- with self.assertRaises(Exception) as ex4:
- pydantic_validated_action(1, "hello", val3="field", val4=[])
- self.assertTrue(
- "validation error for pydantic_validated_action_input" in str(ex4.exception)
- and "val1" not in str(ex4.exception)
- and "val2" not in str(ex4.exception)
- and "val3" in str(ex4.exception)
- and "val4" not in str(ex4.exception)
- )
- with self.assertRaises(Exception) as ex5:
- pydantic_validated_action(1, "hello", val3={"field": "value"}, val4="[]")
- self.assertTrue(
- "validation error for pydantic_validated_action_input" in str(ex5.exception)
- and "val1" not in str(ex5.exception)
- and "val2" not in str(ex5.exception)
- and "val3" not in str(ex5.exception)
- and "val4" in str(ex5.exception)
- )
- # data with valid schema
- return_value = pydantic_validated_action(val1=1, val2="hello", val3={"field": "value"}, val4=[])
- self.assertEqual(return_value, {"val2": "hello", "val4": []})
-
- def test_3_exit(self):
- """Exit the server"""
- exit_message = RequestMessage.craft_with_message_type(
- sender_id="test-action-client",
- receiver_id=self.server_id,
- message_type=EXIT,
- )
- self.sync_client.socket.send_multipart(exit_message.byte_array)
- self.assertEqual(self.done_queue.get(), self.server_id)
-
-
-class TestExposedProperties(InteractionAffordanceMixin):
- @classmethod
- def setUpThing(cls):
- pass
-
- @classmethod
- def setUpServer(cls):
- pass
-
- @classmethod
- def startServer(cls):
- run_thing_with_zmq_server_forked(
- thing_cls=TestThing,
- id=cls.server_id,
- log_level=logging.ERROR + 10,
- done_queue=cls.done_queue,
- as_process=False,
- )
-
- @classmethod
- def setUpClient(cls):
- super().setUpClient()
- cls.sync_client = SyncZMQClient(
- id=cls.client_id,
- server_id=cls.server_id,
- handshake=False,
- )
- cls.client = cls.sync_client
-
- def test_01_property_abstractions(self):
- thing = TestThing(id=self.server_id)
- self.sync_client.handshake()
-
- descriptor = thing.properties["number_prop"]
- assert isinstance(descriptor, Property) # type definition
- number_prop = ZMQProperty(
- resource=descriptor.to_affordance(thing),
- sync_client=self.client,
- async_client=None,
- logger=structlog.get_logger(),
- owner_inst=None,
- )
- self.assertEqual(number_prop.get(), descriptor.default)
- number_prop.set(100)
- self.assertEqual(number_prop.get(), 100)
- number_prop.oneway_set(200)
- self.assertEqual(number_prop.get(), 200)
-
- async def test_6_async_property_abstractions(self: "TestThing"):
- nonlocal number_prop
- async_client = AsyncZMQClient(
- id="test-property-async-client",
- server_id=self.server_id,
- handshake=False,
- )
- number_prop._async_zmq_client = async_client
- async_client.handshake()
- await async_client.handshake_complete()
- await number_prop.async_set(300)
- self.assertEqual(number_prop.get(), 300)
- await number_prop.async_set(0)
- self.assertEqual(await number_prop.async_get(), 0)
-
- get_current_async_loop().run_until_complete(test_6_async_property_abstractions(self))
-
- def test_02_json_schema_property(self):
- """Test json schema based property"""
- test_thing_TD = copy.deepcopy(test_thing_original_TD)
- test_thing_TD["id"] = self.server_id # thing id should be server id. TODO refactor this
- json_schema_prop = ZMQProperty(
- resource=PropertyAffordance.from_TD("json_schema_prop", test_thing_TD),
- sync_client=self.client,
- async_client=None,
- logger=structlog.get_logger(),
- owner_inst=None,
- )
- json_schema_prop.resource._thing_id = self.server_id
- json_schema_prop.set("hello")
- self.assertEqual(json_schema_prop.get(), "hello")
- json_schema_prop.set("world")
- self.assertEqual(json_schema_prop.get(), "world")
- with self.assertRaises(Exception) as ex:
- json_schema_prop.set("world1")
- self.assertTrue("Failed validating 'pattern' in schema:" in str(ex.exception))
-
- def test_03_pydantic_model_property(self):
- """Test pydantic model based property"""
- test_thing_TD = copy.deepcopy(test_thing_original_TD)
- test_thing_TD["id"] = self.server_id # thing id should be server id. TODO refactor this
- pydantic_prop = ZMQProperty(
- resource=PropertyAffordance.from_TD("pydantic_prop", test_thing_TD),
- sync_client=self.client,
- async_client=None,
- logger=structlog.get_logger(),
- owner_inst=None,
- )
- pydantic_prop.resource._thing_id = self.server_id
-
- valid_value = {"foo": "foo", "bar": 1, "foo_bar": 1.0}
- pydantic_prop.set(valid_value)
- self.assertEqual(pydantic_prop.get(), valid_value)
-
- invalid_value = {"foo": 1, "bar": "1", "foo_bar": 1.0}
- with self.assertRaises(Exception) as ex:
- pydantic_prop.set(invalid_value)
- self.assertTrue("validation error for PydanticProp" in str(ex.exception))
-
- pydantic_simple_prop = ZMQProperty(
- resource=PropertyAffordance.from_TD("pydantic_simple_prop", test_thing_TD),
- sync_client=self.client,
- async_client=None,
- logger=structlog.get_logger(),
- owner_inst=None,
- )
- pydantic_simple_prop.resource._thing_id = self.server_id
- pydantic_simple_prop.set(5)
- self.assertEqual(pydantic_simple_prop.get(), 5)
- with self.assertRaises(Exception) as ex:
- pydantic_simple_prop.set("5str")
- self.assertTrue("validation error for 'int'" in str(ex.exception))
-
- def test_04_exit(self):
- exit_message = RequestMessage.craft_with_message_type(
- sender_id="test-property-client",
- receiver_id=self.server_id,
- message_type=EXIT,
- )
- self.sync_client.socket.send_multipart(exit_message.byte_array)
- self.assertEqual(self.done_queue.get(), self.server_id)
-
-
-class TestExposedEvents(TestRPCServerMixin):
- @classmethod
- def setUpServer(cls):
- cls.server = ZMQServer(
- id=cls.server_id,
- things=[cls.thing],
- access_points=["INPROC", "IPC", "tcp://*:59005"],
- )
-
- @classmethod
- def setUpEvents(cls):
- test_thing_TD = copy.deepcopy(test_thing_original_TD)
- test_thing_TD["id"] = cls.thing_id
- cls.event_names = [
- "test_event",
- "test_binary_payload_event",
- "test_event_with_json_schema",
- ]
- for event_name in cls.event_names:
- event_affordance = EventAffordance.from_TD(event_name, test_thing_TD)
- form = Form()
- form.href = cls.server.event_publisher.socket_address
- form.contentType = "application/json"
- form.op = "subscribeevent"
- form.subprotocol = "sse"
- event_affordance.forms = [form]
- event = ZMQEvent(resource=event_affordance, logger=structlog.get_logger(), owner_inst=None)
- setattr(cls, event_name, event)
-
- def test_1_creation_defaults(self):
- """test server configuration defaults"""
- all_things = get_all_sub_things_recusively(self.thing)
- self.assertTrue(len(all_things) > 1) # run the test only if there are sub things
- for thing in all_things:
- assert isinstance(thing, Thing)
- for name, event in thing.events.values.items():
- self.assertTrue(event.publisher, self.server.event_publisher)
- self.assertIsInstance(event._unique_identifier, str)
- self.assertEqual(event._owner_inst, thing)
-
- def test_2_sync_client_event_stream(self):
- """test if event can be streamed by a synchronous threaded client"""
-
- def test_events(event_name: str, expected_data: typing.Any) -> None:
- event_client = getattr(self, event_name) # type: ZMQEvent
-
- self.assertEqual(
- get_zmq_unique_identifier_from_event_affordance(event_client.resource),
- getattr(self.thing, event_client.resource.name)._unique_identifier, # type: EventDispatcher
- )
- attempts = 100
- results = []
-
- def cb(value: SSE):
- nonlocal results
- results.append(value)
-
- event_client.subscribe(cb)
- time.sleep(5) # calm down for event publisher to connect fully as there is no handshake for events
- self.action_push_events(event_name=event_name, total_number_of_events=attempts)
-
- for i in range(attempts):
- if len(results) == attempts:
- break
- time.sleep(0.1)
- self.assertAlmostEqual(len(results), attempts, delta=3)
- self.assertEqual([res.data for res in results], [expected_data] * len(results))
- event_client.unsubscribe()
-
- for name, data in zip(
- self.event_names,
- [
- "test data",
- b"test data",
- {
- "val1": 1,
- "val2": "test",
- "val3": {"key": "value"},
- "val4": [1, 2, 3],
- },
- ],
- ):
- test_events(name, data)
-
- def test_3_async_client_event_stream(self):
- """test if event can be streamed by an asynchronous client in an async loop"""
-
- async def test_events(event_name: str, expected_data: typing.Any) -> None:
- event_client = getattr(self, event_name) # type: ZMQEvent
- self.assertEqual(
- get_zmq_unique_identifier_from_event_affordance(event_client.resource),
- getattr(self.thing, event_client.resource.name)._unique_identifier, # type: EventDispatcher
- )
- attempts = 100
- results = []
-
- def cb(value: SSE):
- nonlocal results
- # print("event callback", value)
- results.append(value)
-
- event_client.subscribe(cb, asynch=True)
- time.sleep(5) # calm down for event publisher to connect fully as there is no handshake for events
- self.action_push_events(event_name=event_name, total_number_of_events=attempts)
-
- for i in range(attempts):
- if len(results) == attempts:
- break
- await asyncio.sleep(0.1)
- self.assertAlmostEqual(len(results), attempts, delta=3)
- # since we are pushing events in multiple protocols, sometimes the event from the previous test is
- # still lingering on the socket. So the captured event must be at least the number of attempts.
- self.assertEqual([res.data for res in results], [expected_data] * len(results))
- event_client.unsubscribe()
-
- for name, data in zip(
- self.event_names,
- [
- "test data",
- b"test data",
- {
- "val1": 1,
- "val2": "test",
- "val3": {"key": "value"},
- "val4": [1, 2, 3],
- },
- ],
- ):
- get_current_async_loop().run_until_complete(test_events(name, data))
-
- def test_4_other_transports(self):
- test_thing_TD = copy.deepcopy(test_thing_original_TD)
- test_thing_TD["id"] = self.thing_id
- for publisher in [
- self.server.ipc_event_publisher,
- self.server.tcp_event_publisher,
- ]:
- self.assertIsInstance(publisher, EventPublisher)
- self.assertTrue(
- publisher.socket_address.startswith("tcp://") or publisher.socket_address.startswith("ipc://")
- )
- for event_name in self.event_names:
- event_affordance = EventAffordance.from_TD(event_name, test_thing_TD)
- event = getattr(self, event_name) # type: ZMQEvent
- form = Form()
- form.href = publisher.socket_address.replace("*", "localhost")
- form.contentType = "application/json"
- form.op = "subscribeevent"
- form.subprotocol = "sse"
- event_affordance.forms = [form]
- event.resource.forms = event_affordance.forms
- self.test_2_sync_client_event_stream()
- self.test_3_async_client_event_stream()
-
- def test_5_exit(self):
- self.server.stop()
-
-
-class TestThingRunRPCServer(TestBrokerMixin):
- """Finally check if the thing can be run with a ZMQ server directly"""
-
- @classmethod
- def setUpThing(self):
- self.thing = TestThing(id=self.thing_id, remote_accessible_logger=True)
-
- @classmethod
- def startServer(self):
- self.thing.run_with_zmq_server(forked=True)
- self.server = self.thing.rpc_server
- self.sync_client = SyncZMQClient(
- id=self.client_id,
- server_id=self.thing_id,
- handshake=False,
- access_point="INPROC",
- )
- self.async_client = AsyncZMQClient(
- id=self.client_id + "async",
- server_id=self.thing_id,
- handshake=False,
- access_point="INPROC",
- )
- time.sleep(2)
-
- def test_1_setup_zmq_server(self):
- self.assertIsInstance(self.thing.rpc_server, ZMQServer)
- self.assertIsInstance(self.thing.event_publisher, EventPublisher)
-
- def test_2_handshake(self):
- self.sync_client.handshake()
- self.async_client.handshake()
- get_current_async_loop().run_until_complete(self.async_client.handshake_complete())
-
- def test_3_stop(self):
- self.thing.rpc_server.stop()
-
-
-def load_tests(loader, tests, pattern):
- suite = unittest.TestSuite()
- # suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestInprocRPCServer))
- # suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestRPCServer))
- # suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestExposedActions))
- suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestExposedProperties))
- # suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestExposedEvents))
- # suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestThingRunRPCServer))
- return suite
-
-
-if __name__ == "__main__":
- runner = TestRunner()
- runner.run(load_tests(unittest.TestLoader(), None, None))
diff --git a/tests/not working - yet to be integrated/test_13_protocols_http.py b/tests/not working - yet to be integrated/test_13_protocols_http.py
deleted file mode 100644
index 605e44d0..00000000
--- a/tests/not working - yet to be integrated/test_13_protocols_http.py
+++ /dev/null
@@ -1,846 +0,0 @@
-import asyncio
-import base64
-import random
-import uuid
-import unittest
-import time
-import logging
-import requests
-from typing import Any
-from dataclasses import dataclass
-from types import SimpleNamespace
-
-from hololinked.client.abstractions import SSE
-from hololinked.utils import pep8_to_dashed_name
-from hololinked.config import global_config
-from hololinked.constants import ZMQ_TRANSPORTS
-from hololinked.core.zmq.message import (
- ServerExecutionContext,
- ThingExecutionContext,
- default_server_execution_context,
-)
-from hololinked.serializers import JSONSerializer
-from hololinked.serializers.payloads import PreserializedData, SerializableData
-from hololinked.serializers.serializers import (
- MsgpackSerializer,
- PickleSerializer,
- BaseSerializer,
-)
-from hololinked.core.meta import ThingMeta
-from hololinked.core.zmq.rpc_server import (
- RPCServer,
-) # sets loop policy, TODO: move somewhere else
-from hololinked.client.proxy import ObjectProxy
-from hololinked.client.factory import ClientFactory
-from hololinked.server.http import HTTPServer
-from hololinked.server.http.handlers import (
- PropertyHandler,
- RPCHandler,
- ThingDescriptionHandler,
-)
-from hololinked.server.security import Argon2BasicSecurity, BcryptBasicSecurity
-from hololinked.td.security_definitions import SecurityScheme
-
-try:
- from .things import OceanOpticsSpectrometer, TestThing
- from .utils import TestCase, TestRunner, fake
- from .test_11_rpc_e2e import TestRPCEndToEnd
-except ImportError:
- from things import OceanOpticsSpectrometer, TestThing
- from utils import TestCase, TestRunner, fake
- from test_11_rpc_e2e import TestRPCEndToEnd
-
-
-class TestHTTPServer(TestCase):
- def test_01_init_run_and_stop(self):
- """Test basic init, run and stop of the HTTP server."""
- # init, run and stop synchronously
- server = HTTPServer(port=60001)
- server.run(forked=True)
- time.sleep(5)
- server.stop()
- time.sleep(2)
-
- # stop remotely
- server.run(forked=True)
- time.sleep(5)
- response = requests.post(f"http://127.0.0.1:{server.port}/stop")
- self.assertIn(response.status_code, [200, 201, 202, 204])
- time.sleep(2)
-
- def test_02_add_interaction_affordance(self):
- """Test adding an interaction affordance to the HTTP server."""
- server = HTTPServer(log_level=logging.ERROR + 10)
-
- # add an interaction affordance
- server.add_property("/max-intensity", OceanOpticsSpectrometer.max_intensity)
- server.add_action("/connect", OceanOpticsSpectrometer.connect)
- server.add_event("/intensity/event", OceanOpticsSpectrometer.intensity_measurement_event)
-
- self.assertIn("/max-intensity", server.router)
- self.assertIn("/connect", server.router)
- self.assertIn("/intensity/event", server.router)
-
- # replacing interation affordances on an existing URL path causes a warning
- self.assertWarns(
- UserWarning,
- server.add_property,
- "/max-intensity",
- OceanOpticsSpectrometer.last_intensity,
- )
- self.assertWarns(
- UserWarning,
- server.add_action,
- "/connect",
- OceanOpticsSpectrometer.disconnect,
- )
- self.assertWarns(
- UserWarning,
- server.add_event,
- "/intensity/event",
- OceanOpticsSpectrometer.intensity_measurement_event,
- )
-
- def notest_03_add_thing(self):
- """Test adding a Thing object to the HTTP server."""
- # in principle works, but we need to refactor this logic a little bit more for the tests to pass,
- # and also probably refactor the tests themselves
- # add a thing, both class and instance
- server = HTTPServer(log_level=logging.ERROR + 10)
- for thing in [
- OceanOpticsSpectrometer(id="test", log_level=logging.ERROR + 10),
- TestThing(id="test-thing", log_level=logging.ERROR + 10),
- ]:
- old_number_of_rules = len(server.app.wildcard_router.rules) + len(server.router._pending_rules)
- server.add_things(thing)
- # TODO - reinstate rule numbers as they ensure that all routes were added
- # self.assertTrue(
- # len(server.app.wildcard_router.rules) + len(server.router._pending_rules) - old_number_of_rules >=
- # len(thing.properties.remote_objects) + len(thing.actions) + len(thing.events)
- # )
- # server.router.print_rules()
-
- old_number_of_rules = len(server.app.wildcard_router.rules) + len(server.router._pending_rules)
- for thing_meta in [OceanOpticsSpectrometer, TestThing]:
- self.assertRaises(TypeError, server.add_things, thing_meta)
- self.assertTrue(
- len(server.app.wildcard_router.rules) + len(server.router._pending_rules) == old_number_of_rules
- )
-
- # create new server to compute number of rules
- server = HTTPServer(log_level=logging.ERROR + 10)
- thing = OceanOpticsSpectrometer(id="test", log_level=logging.ERROR + 10)
- old_number_of_rules = len(server.app.wildcard_router.rules) + len(server.router._pending_rules)
- # append route with /custom to denote its a custom route
- server.add_property("/max-intensity/custom", OceanOpticsSpectrometer.max_intensity)
- server.add_action("/connect/custom", OceanOpticsSpectrometer.connect)
- server.add_event("/intensity/event/custom", OceanOpticsSpectrometer.intensity_measurement_event)
- server.add_things(thing)
- self.assertIn(f"/{thing.id}/max-intensity/custom", server.router)
- self.assertIn(f"/{thing.id}/connect/custom", server.router)
- self.assertIn(f"/{thing.id}/intensity/event/custom", server.router)
- # check if the affordance was not added twice using the default paths while add_thing was called
- self.assertNotIn(
- f"/{pep8_to_dashed_name(OceanOpticsSpectrometer.max_intensity.name)}",
- server.router,
- )
- self.assertNotIn(
- f"/{pep8_to_dashed_name(OceanOpticsSpectrometer.connect.name)}",
- server.router,
- )
- self.assertNotIn(
- f"/{pep8_to_dashed_name(OceanOpticsSpectrometer.intensity_measurement_event.name)}",
- server.router,
- )
- # TODO - reinstate rule numbers as they ensure that all routes were added
- # self.assertTrue(
- # len(server.app.wildcard_router.rules) + len(server.router._pending_rules) - old_number_of_rules >=
- # len(thing.properties.remote_objects) + len(thing.actions) + len(thing.events)
- # )
- # also check that it does not create duplicate rules
-
- def notest_04_add_thing_over_zmq_server(self):
- """extension of previous two tests to complete adding a thing running over a zmq server"""
- server = HTTPServer(log_level=logging.ERROR + 10)
- old_number_of_rules = len(server.app.wildcard_router.rules) + len(server.router._pending_rules)
-
- thing_id = f"test-add-zmq-{uuid.uuid4().hex[0:8]}"
- thing = OceanOpticsSpectrometer(id=thing_id, log_level=logging.ERROR + 10)
- thing.run_with_zmq_server(ZMQ_TRANSPORTS.INPROC, forked=True)
-
- server.add_property("/max-intensity/custom", OceanOpticsSpectrometer.max_intensity)
- server.add_action("/connect/custom", OceanOpticsSpectrometer.connect)
- server.add_event(
- "/intensity/event/custom",
- OceanOpticsSpectrometer.intensity_measurement_event,
- )
- server.add_things(thing)
-
- # server.router.print_rules()
- # print(thing.properties.remote_objects.keys(), thing.actions.descriptors.keys(), thing.events.descriptors.keys())
- # self.assertTrue(
- # len(server.app.wildcard_router.rules) + len(server.router._pending_rules) - old_number_of_rules >=
- # len(thing.properties.remote_objects) + len(thing.actions) + len(thing.events)
- # )
-
- fake_request = SimpleNamespace(path=f"/{thing_id}/max-intensity/custom")
- self.assertTrue(
- any([rule.matcher.match(fake_request) is not None for rule in server.app.wildcard_router.rules])
- )
- fake_request = SimpleNamespace(path="/non-existing-path-that-i-know-will-not-match")
- self.assertFalse(
- any([rule.matcher.match(fake_request) is not None for rule in server.app.wildcard_router.rules])
- )
- fake_request = SimpleNamespace(path=f"/{thing_id}/connect/custom")
- self.assertTrue(
- any([rule.matcher.match(fake_request) is not None for rule in server.app.wildcard_router.rules])
- )
- fake_request = SimpleNamespace(path=f"/{thing_id}/intensity/event/custom")
- self.assertTrue(
- any([rule.matcher.match(fake_request) is not None for rule in server.app.wildcard_router.rules])
- )
-
- while not thing.rpc_server:
- time.sleep(0.1) # wait for rpc server to be ready
- thing.rpc_server.stop()
-
- def test_05_handlers(self):
- """Test request info and payload decoding in RPC handlers along with content type handling"""
- latest_request_info = None # type: "LatestRequestInfo"
-
- @dataclass
- class LatestRequestInfo:
- server_execution_context: ServerExecutionContext | dict[str, Any]
- thing_execution_context: ThingExecutionContext | dict[str, Any]
- payload: SerializableData
- preserialized_payload: PreserializedData
-
- class TestableRPCHandler(RPCHandler):
- def update_latest_request_info(self) -> None:
- nonlocal latest_request_info
- server_execution_context, thing_execution_context, _, _ = self.get_execution_parameters()
- payload, preserialized_payload = self.get_request_payload()
- latest_request_info = LatestRequestInfo(
- server_execution_context=server_execution_context,
- thing_execution_context=thing_execution_context,
- payload=payload,
- preserialized_payload=preserialized_payload,
- )
-
- async def get(self):
- self.update_latest_request_info()
- self.set_status(200)
- self.finish()
-
- async def put(self):
- self.update_latest_request_info()
- self.set_status(200)
- self.finish()
-
- async def post(self):
- # for exit to go through
- await self.handle_through_thing("invokeaction")
-
- global_config.ALLOW_PICKLE = True # allow pickle serializer for testing
- thing_id = f"test-request-info-{uuid.uuid4().hex[0:8]}"
- port = 60002
-
- thing = OceanOpticsSpectrometer(id=thing_id, log_level=logging.ERROR + 10)
- thing.run_with_http_server(
- port=port,
- forked=True,
- property_handler=TestableRPCHandler,
- action_handler=TestableRPCHandler,
- )
- self.wait_until_server_ready(port=port)
- session = requests.session()
- for serializer in [JSONSerializer(), MsgpackSerializer(), PickleSerializer()]:
- serializer: BaseSerializer
- for method, path, body in [
- # server and thing execution context tests
- ("get", f"/{thing_id}/integration-time", None),
- ("get", f"/{thing_id}/integration-time?fetchExecutionLogs=true", None),
- (
- "get",
- f"/{thing_id}/integration-time?fetchExecutionLogs=true&oneway=true",
- None,
- ),
- (
- "get",
- f"/{thing_id}/integration-time?oneway=true&invokationTimeout=100",
- None,
- ),
- (
- "get",
- f"/{thing_id}/integration-time?invokationTimeout=100&executionTimeout=120&fetchExecutionLogs=true",
- None,
- ),
- # test payloads for JSON content type
- ("put", f"/{thing_id}/integration-time", 1200),
- (
- "put",
- f"/{thing_id}/integration-time?fetchExecutionLogs=true",
- {"a": 1, "b": 2},
- ),
- (
- "put",
- f"/{thing_id}/integration-time?fetchExecutionLogs=true&oneway=true",
- [1, 2, 3],
- ),
- (
- "put",
- f"/{thing_id}/integration-time?oneway=true&invokationTimeout=100",
- "abcd",
- ),
- (
- "put",
- f"/{thing_id}/integration-time?invokationTimeout=100&executionTimeout=120&fetchExecutionLogs=true",
- True,
- ),
- # test payloads for other content types
- ]:
- response = session.request(
- method=method,
- url=f"http://127.0.0.1:{port}{path}",
- data=serializer.dumps(body) if body is not None else None,
- headers={"Content-Type": serializer.content_type},
- )
- self.assertTrue(response.status_code in [200, 201, 202, 204])
- assert isinstance(latest_request_info, LatestRequestInfo)
- # test ThingExecutionContext
- self.assertTrue(
- isinstance(
- latest_request_info.thing_execution_context,
- ThingExecutionContext,
- )
- )
- self.assertTrue(
- ("fetchExecutionLogs" in path and latest_request_info.thing_execution_context.fetchExecutionLogs)
- or not latest_request_info.thing_execution_context.fetchExecutionLogs
- )
- # test ServerExecutionContext
- self.assertTrue(
- isinstance(
- latest_request_info.server_execution_context,
- ServerExecutionContext,
- )
- )
- self.assertTrue(
- ("oneway" in path and latest_request_info.server_execution_context.oneway)
- or not latest_request_info.server_execution_context.oneway
- )
- self.assertTrue(
- (
- "invokationTimeout" in path
- and latest_request_info.server_execution_context.invokationTimeout == 100
- )
- or
- # assume that in all tests where invokation timeout is specified, it will be 100
- latest_request_info.server_execution_context.invokationTimeout
- == default_server_execution_context.invokationTimeout
- )
- self.assertTrue(
- (
- "executionTimeout" in path
- and latest_request_info.server_execution_context.executionTimeout == 120
- )
- or
- # assume that in all tests where execution timeout is specified, it will be 120
- latest_request_info.server_execution_context.executionTimeout
- == default_server_execution_context.executionTimeout
- )
- # test body
- self.assertTrue(latest_request_info.payload.deserialize() == body)
-
- self.stop_server(port=port, thing_ids=[thing_id])
-
- def _test_handlers_end_to_end(self, port: int, thing_id: str, **request_kwargs):
- """
- basic end-to-end test with the HTTP server using handlers.
- Auth & other features not included, only invokation of interaction affordances.
- """
- session = requests.Session()
- logging.getLogger("requests").setLevel(logging.CRITICAL)
- logging.getLogger("urllib3").setLevel(logging.CRITICAL)
- # test end to end
- for method, path, body in self.generate_endpoints_for_thing(OceanOpticsSpectrometer, thing_id):
- # request will go through the Thing object
- response = session.request(
- method=method,
- url=f"http://127.0.0.1:{port}{path}",
- data=JSONSerializer().dumps(body) if body is not None and method != "get" else None,
- **request_kwargs,
- )
- self.assertTrue(response.status_code in [200, 201, 202, 204])
- # check if the response body is as expected
- if body and method != "put":
- self.assertTrue(response.json() == body)
- # check headers
- self.assertIn("Access-Control-Allow-Origin", response.headers)
- self.assertIn("Access-Control-Allow-Credentials", response.headers)
- self.assertIn("Content-Type", response.headers)
-
- # test unsupported HTTP methods
- for method, path, body in self.generate_endpoints_for_thing(OceanOpticsSpectrometer, thing_id):
- response = session.request(
- method="post"
- if method in ["get", "put"]
- else random.choice(["put", "delete"])
- if method == "post"
- else method,
- # get and put become post and post becomes put
- # i.e swap the default HTTP method with an unsupported one to generate 405
- url=f"http://127.0.0.1:{port}{path}",
- data=JSONSerializer().dumps(body) if body is not None and method != "get" else None,
- **request_kwargs,
- )
- self.assertTrue(response.status_code == 405)
-
- # check options for supported HTTP methods
- for method, path, body in self.generate_endpoints_for_thing(OceanOpticsSpectrometer, thing_id):
- response = session.options(f"http://127.0.0.1:{port}{path}", **request_kwargs)
- self.assertTrue(response.status_code in [200, 201, 202, 204])
- self.assertIn("Access-Control-Allow-Origin", response.headers)
- self.assertIn("Access-Control-Allow-Credentials", response.headers)
- self.assertIn("Access-Control-Allow-Headers", response.headers)
- self.assertIn("Access-Control-Allow-Methods", response.headers)
- allow_methods = response.headers.get("Access-Control-Allow-Methods", [])
- self.assertTrue(
- method.upper() in allow_methods,
- f"Method {method} not allowed in {allow_methods}",
- )
-
- def _test_invalid_auth_end_to_end(self, port: int, thing_id: str, wrong_auth_headers: list[str] = None):
- # check wrong credentials
- session = requests.Session()
- for wrong_auth in wrong_auth_headers:
- for method, path, body in self.generate_endpoints_for_thing(OceanOpticsSpectrometer, thing_id):
- response = session.request(
- method=method,
- url=f"http://127.0.0.1:{port}{path}",
- data=JSONSerializer().dumps(body) if body is not None and method != "get" else None,
- headers=wrong_auth,
- )
- self.assertTrue(response.status_code == 401)
-
- def _test_authenticated_end_to_end(
- self,
- port: int,
- security_scheme: SecurityScheme,
- auth_headers: dict[str, str] = None,
- wrong_auth_headers: dict[str, str] = None,
- ):
- """Test end-to-end with authentication"""
- thing_id = f"test-sec-{uuid.uuid4().hex[0:8]}"
- thing = OceanOpticsSpectrometer(id=thing_id, serial_number="simulation", log_level=logging.ERROR + 10)
- thing.run_with_http_server(
- forked=True,
- port=port,
- config={"cors": True},
- security_schemes=[security_scheme],
- )
- self.wait_until_server_ready(port=port)
- self._test_handlers_end_to_end(port=port, thing_id=thing_id, headers=auth_headers)
- self._test_invalid_auth_end_to_end(port=port, thing_id=thing_id, wrong_auth_headers=wrong_auth_headers)
- # reinstate correct credentials to stop
- self.stop_server(port=port, thing_ids=[thing_id], headers=auth_headers)
-
- def test_06_basic_end_to_end(self):
- thing_id = f"test-sec-{uuid.uuid4().hex[0:8]}"
- port = 60004
- thing = OceanOpticsSpectrometer(id=thing_id, serial_number="simulation", log_level=logging.ERROR + 10)
- thing.run_with_http_server(forked=True, port=port, config={"cors": True})
- self.wait_until_server_ready(port=port)
-
- self._test_handlers_end_to_end(port=port, thing_id=thing_id, headers={"Content-Type": "application/json"})
- self.stop_server(port, thing_ids=[thing_id])
-
- def test_07_bcrypt_basic_security_end_to_end(self):
- security_scheme = BcryptBasicSecurity(username="someuser", password="somepassword")
- port = 60005
- self._test_authenticated_end_to_end(
- port=port,
- security_scheme=security_scheme,
- auth_headers={
- "Content-type": "application/json",
- "Authorization": f"Basic {base64.b64encode(b'someuser:somepassword').decode('utf-8')}",
- },
- wrong_auth_headers=[
- {
- "Content-type": "application/json",
- "Authorization": f"Basic {base64.b64encode(b'wronguser:wrongpassword').decode('utf-8')}",
- },
- {
- "Content-type": "application/json",
- "Authorization": f"Basic {base64.b64encode(b'someuser:wrongpassword').decode('utf-8')}",
- },
- {
- "Content-type": "application/json",
- "Authorization": f"Basic {base64.b64encode(b'wronguser:somepassword').decode('utf-8')}",
- },
- ],
- )
-
- def test_08_argon2_basic_security_end_to_end(self):
- security_scheme = Argon2BasicSecurity(username="someuserargon2", password="somepasswordargon2")
- port = 60006
- self._test_authenticated_end_to_end(
- port=port,
- security_scheme=security_scheme,
- auth_headers={
- "Content-type": "application/json",
- "Authorization": f"Basic {base64.b64encode(b'someuserargon2:somepasswordargon2').decode('utf-8')}",
- },
- wrong_auth_headers=[
- {
- "Content-type": "application/json",
- "Authorization": f"Basic {base64.b64encode(b'wronguserargon2:wrongpasswordargon2').decode('utf-8')}",
- },
- {
- "Content-type": "application/json",
- "Authorization": f"Basic {base64.b64encode(b'someuserargon2:wrongpasswordargon2').decode('utf-8')}",
- },
- {
- "Content-type": "application/json",
- "Authorization": f"Basic {base64.b64encode(b'wronguserargon2:somepasswordargon2').decode('utf-8')}",
- },
- ],
- )
-
- def _test_sse_end_to_end(
- self,
- port: int,
- security_scheme: SecurityScheme = None,
- headers: dict[str, str] = None,
- ):
- """
- Test end-to-end with Server-Sent Events (SSE).
- """
- thing_id = f"test-sse-{uuid.uuid4().hex[0:8]}"
- thing = OceanOpticsSpectrometer(id=thing_id, serial_number="simulation", log_level=logging.ERROR + 10)
- thing.run_with_http_server(
- forked=True,
- port=port,
- config={"cors": True},
- security_schemes=[security_scheme] if security_scheme else None,
- )
- self.wait_until_server_ready(port=port)
-
- session = requests.Session()
- response = session.post(f"http://127.0.0.1:{port}/{thing_id}/start-acquisition", headers=headers)
- self.assertEqual(response.status_code, 200)
- sse_gen = self.sse_stream(
- f"http://127.0.0.1:{port}/{thing_id}/intensity-measurement-event",
- headers=headers,
- )
- for i in range(5):
- evt = next(sse_gen)
- self.assertTrue("exception" not in evt)
- response = session.post(f"http://127.0.0.1:{port}/{thing_id}/stop-acquisition", headers=headers)
- self.stop_server(port=port, thing_ids=[thing_id], headers=headers)
-
- def test_09_sse(self):
- """Test Server-Sent Events (SSE)"""
- for security_scheme, port in [
- (None, 60007),
- (BcryptBasicSecurity(username="someuser", password="somepassword"), 60008),
- ]:
- # test SSE with and without security
- if security_scheme:
- headers = {
- "Content-type": "application/json",
- "Authorization": f"Basic {base64.b64encode(b'someuser:somepassword').decode('utf-8')}",
- }
- else:
- headers = dict()
- self._test_sse_end_to_end(port=port, security_scheme=security_scheme, headers=headers)
-
- def test_10_forms_generation(self):
- thing_id = f"test-forms-{uuid.uuid4().hex[0:8]}"
- port = 60009
- thing = OceanOpticsSpectrometer(id=thing_id, serial_number="simulation", log_level=logging.ERROR + 10)
- thing.run_with_http_server(forked=True, port=port, config={"cors": True})
- self.wait_until_server_ready(port=port)
-
- session = requests.Session()
- response = session.get(f"http://127.0.0.1:{port}/{thing_id}/resources/wot-td")
- self.assertEqual(response.status_code, 200)
- td = response.json()
- self.assertIn("properties", td)
- self.assertIn("actions", td)
- self.assertIn("events", td)
- self.assertTrue(len(td["properties"]) >= 0)
- self.assertTrue(len(td["actions"]) >= 0)
- self.assertTrue(len(td["events"]) >= 0)
- for prop in list(td["properties"].values()) + list(td["actions"].values()) + list(td["events"].values()):
- self.assertIn("forms", prop)
- self.assertTrue(len(prop["forms"]) > 0)
- for form in prop["forms"]:
- self.assertIn("href", form)
- self.assertIn("htv:methodName", form)
- self.assertIn("contentType", form)
- self.assertIn("op", form)
- self.stop_server(port=port, thing_ids=[thing_id])
-
- def test_11_object_proxy_basic(self):
- thing_id = f"test-obj-proxy-{uuid.uuid4().hex[0:8]}"
- port = 60010
- thing = OceanOpticsSpectrometer(id=thing_id, serial_number="simulation", log_level=logging.ERROR + 10)
- thing.run_with_http_server(forked=True, port=port, config={"cors": True})
- self.wait_until_server_ready(port=port)
-
- object_proxy = ClientFactory.http(url=f"http://127.0.0.1:{port}/{thing_id}/resources/wot-td")
- self.assertIsInstance(object_proxy, ObjectProxy)
- self.assertEqual(object_proxy.test_echo("Hello World!"), "Hello World!")
- self.assertEqual(
- asyncio.run(object_proxy.async_invoke_action("test_echo", "Hello World!")),
- "Hello World!",
- )
- self.assertEqual(object_proxy.read_property("max_intensity"), 16384)
- self.assertEqual(object_proxy.write_property("integration_time", 1200), None)
- self.assertEqual(object_proxy.read_property("integration_time"), 1200)
- self.stop_server(port=port, thing_ids=[thing_id])
-
- def notest_12_object_proxy_with_basic_auth(self):
- security_scheme = BcryptBasicSecurity(username="cliuser", password="clipass")
- port = 60013
- thing_id = f"test-basic-proxy-{uuid.uuid4().hex[0:8]}"
- thing = OceanOpticsSpectrometer(id=thing_id, serial_number="simulation", log_level=logging.ERROR + 10)
- thing.run_with_http_server(
- forked=True,
- port=port,
- config={"cors": True},
- security_schemes=[security_scheme],
- )
- self.wait_until_server_ready(port=port)
-
- object_proxy = ClientFactory.http(
- url=f"http://127.0.0.1:{port}/{thing_id}/resources/wot-td",
- username="cliuser",
- password="clipass",
- )
- self.assertEqual(object_proxy.read_property("max_intensity"), 16384)
- headers = {}
- token = base64.b64encode("cliuser:clipass".encode("utf-8")).decode("ascii")
- headers["Authorization"] = f"Basic {token}"
- self.stop_server(port=port, thing_ids=[thing_id], headers=headers)
-
- @classmethod
- def stop_server(cls, port, thing_ids: list[str] = [], **request_kwargs):
- session = requests.Session()
- endpoints = [("post", f"/{thing_id}/exit", None) for thing_id in thing_ids]
- endpoints += [("post", "/stop", None)]
- for method, path, body in endpoints:
- response = session.request(method=method, url=f"http://127.0.0.1:{port}{path}", **request_kwargs)
- if response.status_code not in [200, 201, 202, 204]:
- logging.warning(f"Failed to stop server or thing at {path} with status {response.status_code}")
-
- @classmethod
- def wait_until_server_ready(cls, port, tries: int = 10):
- session = requests.Session()
- for i in range(tries):
- try:
- response = session.get(f"http://127.0.0.1:{port}/liveness")
- if response.status_code in [200, 201, 202, 204]:
- response = session.get(f"http://127.0.0.1:{port}/readiness")
- if response.status_code in [200, 201, 202, 204]:
- time.sleep(2)
- return
- except Exception:
- pass
- time.sleep(1)
- raise TimeoutError(f"Server on port {port} not ready after {tries} tries")
-
- @classmethod
- def sse_stream(cls, url, chunk_size=2048, **kwargs):
- """Generator yielding dicts with the fields of each SSE event"""
- with requests.get(url, stream=True, **kwargs) as resp:
- resp.raise_for_status()
- buffer = ""
- for chunk in resp.iter_content(chunk_size=chunk_size, decode_unicode=True):
- buffer += chunk
- # split events on the SSE separator: two newlines
- while "\n\n" in buffer:
- raw_event, buffer = buffer.split("\n\n", 1)
- event = {}
- for line in raw_event.splitlines():
- # skip comments
- if not line or line.startswith(":"):
- continue
- if ":" in line:
- field, value = line.split(":", 1)
- event.setdefault(field, "")
- # strip leading space after colon
- event[field] += value.lstrip()
- yield event
-
- @classmethod
- def generate_endpoints_for_thing(cls, class_: ThingMeta, thing_id: str) -> list[tuple[str, str, Any]]:
- if class_ == OceanOpticsSpectrometer:
- return [
- # read Property
- ("get", f"/{thing_id}/max-intensity", 16384),
- ("get", f"/{thing_id}/serial-number", "simulation"),
- # write Property
- ("put", f"/{thing_id}/integration-time", 1200),
- ("get", f"/{thing_id}/integration-time", 1200),
- # invoke action
- ("post", f"/{thing_id}/disconnect", None),
- ("post", f"/{thing_id}/connect", None),
- ]
- raise NotImplementedError(f"Endpoints for {class_.__name__} not implemented yet")
-
-
-class TestHTTPObjectProxy(TestCase):
- # later create a TestObjtectProxy class that will test ObjectProxy but just overload the setUp and tearDown methods
- # with the different protocol
-
- @classmethod
- def setUpClass(cls):
- super().setUpClass()
- cls.thing_id = f"test-obj-proxy-{uuid.uuid4().hex[0:8]}"
- cls.port = 60011
- cls.thing = OceanOpticsSpectrometer(id=cls.thing_id, serial_number="simulation", log_level=logging.ERROR + 10)
- cls.thing.run_with_http_server(forked=True, port=cls.port, config={"cors": True})
- TestHTTPServer.wait_until_server_ready(port=cls.port)
-
- cls.object_proxy = ClientFactory.http(url=f"http://127.0.0.1:{cls.port}/{cls.thing_id}/resources/wot-td")
-
- @classmethod
- def tearDownClass(cls):
- # stop the thing and server
- TestHTTPServer.stop_server(cls.port, thing_ids=[cls.thing.id])
- cls.object_proxy = None
- super().tearDownClass()
-
- def test_01_invoke_action(self):
- """Test basic functionality of ObjectProxy with HTTP server."""
- self.assertIsInstance(self.object_proxy, ObjectProxy)
- # Test invoke_action method with reply
- self.assertEqual(self.object_proxy.invoke_action("test_echo", "Hello World!"), "Hello World!")
- # Test invoke_action with dot notation
- self.assertEqual(self.object_proxy.test_echo(fake.chrome()), fake.last)
- self.assertEqual(self.object_proxy.test_echo(fake.sha256()), fake.last)
- self.assertEqual(self.object_proxy.test_echo(fake.address()), fake.last)
- # Test invoke_action with no reply
- self.assertEqual(
- self.object_proxy.invoke_action("test_echo", fake.random_number(), oneway=True),
- None,
- )
- # # Test invoke_action in non blocking mode
- noblock_payload = fake.pylist(20, value_types=[int, float, str, bool])
- noblock_msg_id = self.object_proxy.invoke_action("test_echo", noblock_payload, noblock=True)
- self.assertIsInstance(noblock_msg_id, str)
- self.assertEqual(
- self.object_proxy.invoke_action("test_echo", fake.pylist(20, value_types=[int, float, str, bool])),
- fake.last,
- )
- self.assertEqual(
- self.object_proxy.invoke_action("test_echo", fake.pylist(10, value_types=[int, float, str, bool])),
- fake.last,
- )
- self.assertEqual(self.object_proxy.read_reply(noblock_msg_id), noblock_payload)
-
- def test_02_rwd_properties(self):
- # test read and write properties
- self.assertEqual(self.object_proxy.read_property("max_intensity"), 16384)
- self.assertEqual(self.object_proxy.write_property("integration_time", 1200), None)
- self.assertEqual(self.object_proxy.read_property("integration_time"), 1200)
- # test read and write properties with dot notation
- self.assertEqual(self.object_proxy.max_intensity, 16384)
- self.assertEqual(self.object_proxy.integration_time, 1200)
- self.object_proxy.integration_time = 1000
- self.assertEqual(self.object_proxy.integration_time, 1000)
- # test oneway write property
- self.assertEqual(self.object_proxy.write_property("integration_time", 800, oneway=True), None)
- self.assertEqual(self.object_proxy.read_property("integration_time"), 800)
- # test noblock read property
- noblock_msg_id = self.object_proxy.read_property("integration_time", noblock=True)
- self.assertIsInstance(noblock_msg_id, str)
- self.assertEqual(self.object_proxy.read_property("max_intensity"), 16384)
- self.assertEqual(self.object_proxy.write_property("integration_time", 1200), None)
- self.assertEqual(self.object_proxy.read_reply(noblock_msg_id), 800)
-
- def notest_03_rw_multiple_properties(self):
- """Test reading and writing multiple properties at once."""
- # test read multiple properties
- properties = self.object_proxy.read_multiple_properties(["max_intensity", "integration_time"])
- self.assertEqual(properties["max_intensity"], 16384)
- self.assertEqual(properties["integration_time"], 800)
-
- # test write multiple properties
- new_values = {"integration_time": 1200, "max_intensity": 20000}
- self.object_proxy.write_multiple_properties(new_values)
- properties = self.object_proxy.read_multiple_properties(["max_intensity", "integration_time"])
- self.assertEqual(properties["max_intensity"], 20000)
- self.assertEqual(properties["integration_time"], 1200)
-
- def test_04_subscribe_event(self):
- """Test subscribing to an event and receiving updates."""
- event_name = "intensity_measurement_event"
-
- def on_event(data: SSE):
- nonlocal self
- self.assertTrue(isinstance(data.data, dict) and "value" in data.data and "timestamp" in data.data)
-
- self.object_proxy.subscribe_event(event_name, on_event)
- self.object_proxy.start_acquisition()
- time.sleep(2) # wait for some events to be generated
- self.object_proxy.stop_acquisition()
- # check if events are kept alive
- time.sleep(20)
- self.object_proxy.start_acquisition()
- time.sleep(2) # wait for some events to be generated
- self.object_proxy.stop_acquisition()
- self.object_proxy.unsubscribe_event(event_name)
-
-
-class TestHTTPEndToEnd(TestRPCEndToEnd):
- @classmethod
- def setUpClass(cls):
- cls.http_port = 60012
- super().setUpClass()
- print("Test HTTP Object Proxy End to End")
-
- @classmethod
- def setUpThing(cls):
- """Set up the thing for the http object proxy client"""
- cls.thing = TestThing(id=cls.thing_id, log_level=logging.ERROR + 10)
- cls.thing.run_with_http_server(forked=True, port=cls.http_port, config={"cors": True})
- TestHTTPServer.wait_until_server_ready(port=cls.http_port)
-
- cls.thing_model = cls.thing.get_thing_model(ignore_errors=True).json()
-
- @classmethod
- def tearDownClass(cls):
- """Test the stop of the http object proxy client"""
- TestHTTPServer.stop_server(port=cls.http_port, thing_ids=[cls.thing_id])
- super().tearDownClass()
-
- @classmethod
- def get_client(cls):
- try:
- if cls._client is not None:
- return cls._client
- raise AttributeError()
- except AttributeError:
- cls._client = ClientFactory.http(
- url=f"http://127.0.0.1:{cls.http_port}/{cls.thing_id}/resources/wot-td", ignore_TD_errors=True
- )
- return cls._client
-
- def test_04_RW_multiple_properties(self):
- pass
-
-
-def load_tests(loader, tests, pattern):
- suite = unittest.TestSuite()
- suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestHTTPServer))
- suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestHTTPObjectProxy))
- suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestHTTPEndToEnd))
- return suite
-
-
-if __name__ == "__main__":
- runner = TestRunner()
- runner.run(load_tests(unittest.TestLoader(), None, None))
diff --git a/tests/pytests-new/conftest.py b/tests/pytests-new/conftest.py
deleted file mode 100644
index 9da1aed3..00000000
--- a/tests/pytests-new/conftest.py
+++ /dev/null
@@ -1,66 +0,0 @@
-"""
-Pytest configuration and shared fixtures for hololinked tests.
-"""
-import asyncio
-import pytest
-import zmq.asyncio
-from uuid import uuid4
-from faker import Faker
-
-from hololinked.config import global_config
-
-
-@pytest.fixture(scope="session")
-def event_loop():
- """Create an instance of the default event loop for the test session."""
- loop = asyncio.get_event_loop_policy().new_event_loop()
- yield loop
- loop.close()
-
-
-@pytest.fixture(scope="class")
-def zmq_context():
- """Setup ZMQ context for test classes."""
- global_config.ZMQ_CONTEXT = zmq.asyncio.Context()
- yield global_config.ZMQ_CONTEXT
- # Cleanup is handled by the context manager
-
-
-@pytest.fixture(scope="class")
-def test_ids():
- """Generate unique test IDs for each test class."""
- return {
- "server_id": f"test-server-{uuid4().hex[:8]}",
- "client_id": f"test-client-{uuid4().hex[:8]}",
- "thing_id": f"test-thing-{uuid4().hex[:8]}"
- }
-
-
-@pytest.fixture(scope="session")
-def fake():
- """Provide a Faker instance for generating test data."""
- return Faker()
-
-
-@pytest.fixture(autouse=True)
-def setup_test_environment(zmq_context):
- """Automatically setup test environment for each test."""
- # This fixture runs automatically for every test
- pass
-
-
-def pytest_configure(config):
- """Configure pytest with custom settings."""
- config.addinivalue_line(
- "markers", "order: mark test to run in a specific order"
- )
-
-
-def pytest_collection_modifyitems(config, items):
- """Modify test collection to add ordering markers."""
- # Add order markers based on test file names
- for item in items:
- if "test_01_" in item.nodeid:
- item.add_marker(pytest.mark.order(1))
- elif "test_00_" in item.nodeid:
- item.add_marker(pytest.mark.order(0))
diff --git a/tests/pytests-new/test_01_message_pytest.py b/tests/pytests-new/test_01_message_pytest.py
deleted file mode 100644
index 122a38d1..00000000
--- a/tests/pytests-new/test_01_message_pytest.py
+++ /dev/null
@@ -1,353 +0,0 @@
-"""
-Pytest tests for message validation and messaging contract.
-Converted from unittest to pytest format.
-"""
-
-import pytest
-from uuid import UUID, uuid4
-
-from hololinked.core.zmq.message import (
- EXIT,
- OPERATION,
- HANDSHAKE,
- PreserializedData,
- SerializableData,
- RequestHeader,
- EventHeader,
- RequestMessage,
-) # client to server
-from hololinked.core.zmq.message import (
- TIMEOUT,
- INVALID_MESSAGE,
- ERROR,
- REPLY,
- ERROR,
- ResponseMessage,
- ResponseHeader,
- EventMessage,
-) # server to client
-from hololinked.serializers.serializers import Serializers
-
-
-class MessageValidatorMixin:
- """A mixin class to validate request and response messages"""
-
- @pytest.fixture(autouse=True)
- def setup_message_validator(self, test_ids):
- """Setup message validator with test IDs."""
- self.server_id = test_ids["server_id"]
- self.client_id = test_ids["client_id"]
- self.thing_id = test_ids["thing_id"]
-
- def validate_request_message(self, request_message: RequestMessage) -> None:
- """call this method to validate request message"""
-
- # req. 1. check message ID is a UUID
- assert isinstance(request_message.id, UUID) or isinstance(UUID(request_message.id, version=4), UUID)
- # req. 2. generated byte array must confine to predefined length (which is readonly & fixed)
- assert len(request_message.byte_array) == request_message.length
- # req. 3. receiver which must be the server ID
- assert request_message.receiver_id == self.server_id
- # req. 4. sender_id is the client ID
- assert request_message.sender_id == self.client_id
- # req. 5. all indices of byte array are bytes
- for obj in request_message.byte_array:
- assert isinstance(obj, bytes)
- # req. 6. check that header is correct type (RequestHeader dataclass/struct)
- assert isinstance(request_message.header, RequestHeader)
- # req. 7 check that body is correct type (list of SerializableData and PreserializedData)
- assert isinstance(request_message.body, list)
- assert len(request_message.body) == 2
- assert isinstance(request_message.body[0], SerializableData)
- assert isinstance(request_message.body[1], PreserializedData)
-
- def validate_response_message(self, response_message: ResponseMessage) -> None:
- """call this method to validate response message"""
-
- # check message ID is a UUID
- assert isinstance(response_message.id, UUID) or isinstance(UUID(response_message.id, version=4), UUID)
- # check message length
- assert len(response_message.byte_array) == response_message.length
- # check receiver which must be the client
- assert response_message.receiver_id == self.client_id
- # sender_id is not set before sending message on the socket
- assert response_message.sender_id == self.server_id
- # check that all indices are bytes
- for obj in response_message.byte_array:
- assert isinstance(obj, bytes)
- # check that header is correct type
- assert isinstance(response_message.header, ResponseHeader)
- # check that body is correct type
- assert isinstance(response_message.body, list)
- assert len(response_message.body) == 2
- assert isinstance(response_message.body[0], SerializableData)
- assert isinstance(response_message.body[1], PreserializedData)
-
- def validate_event_message(self, event_message: EventMessage) -> None:
- """call this method to validate event message"""
-
- # check message ID is a UUID
- assert isinstance(event_message.id, UUID) or isinstance(UUID(event_message.id, version=4), UUID)
- # check message length
- assert len(event_message.byte_array) == event_message.length
- # no receiver id for event message, only event id
- assert isinstance(event_message.event_id, str)
- # sender_id is not set before sending message on the socket
- assert event_message.sender_id == self.server_id
- # check that all indices are bytes
- for obj in event_message.byte_array:
- assert isinstance(obj, bytes)
- # check that header is correct type
- assert isinstance(event_message.header, EventHeader)
- # check that body is correct type
- assert isinstance(event_message.body, list)
- assert len(event_message.body) == 2
- assert isinstance(event_message.body[0], SerializableData)
- assert isinstance(event_message.body[1], PreserializedData)
-
-
-@pytest.mark.order(1)
-class TestMessagingContract(MessageValidatorMixin):
- """Tests request and response messages"""
-
- def test_1_request_message(self):
- """test the request message"""
-
- # request messages types are OPERATION, HANDSHAKE & EXIT
- request_message = RequestMessage.craft_from_arguments(
- receiver_id=self.server_id,
- sender_id=self.client_id,
- thing_id=self.thing_id,
- objekt="some_prop",
- operation="readproperty",
- )
- self.validate_request_message(request_message)
- # check message type for the above craft_from_arguments method
- assert request_message.type == OPERATION
-
- request_message = RequestMessage.craft_with_message_type(
- receiver_id=self.server_id, sender_id=self.client_id, message_type=HANDSHAKE
- )
- self.validate_request_message(request_message)
- # check message type for the above craft_with_message_type method
- assert request_message.type == HANDSHAKE
-
- request_message = RequestMessage.craft_with_message_type(
- receiver_id=self.server_id, sender_id=self.client_id, message_type=EXIT
- )
- self.validate_request_message(request_message)
- # check message type for the above craft_with_message_type method
- assert request_message.type == EXIT
-
- def test_2_response_message(self):
- """test the response message"""
-
- # response messages types are HANDSHAKE, TIMEOUT, INVALID_MESSAGE, ERROR and REPLY
- response_message = ResponseMessage.craft_from_arguments(
- receiver_id=self.client_id,
- sender_id=self.server_id,
- message_type=HANDSHAKE,
- message_id=uuid4(),
- )
- self.validate_response_message(response_message)
- # check message type for the above craft_with_message_type method
- assert response_message.type == HANDSHAKE
-
- response_message = ResponseMessage.craft_from_arguments(
- receiver_id=self.client_id,
- sender_id=self.server_id,
- message_type=TIMEOUT,
- message_id=uuid4(),
- )
- self.validate_response_message(response_message)
- # check message type for the above craft_with_message_type method
- assert response_message.type == TIMEOUT
-
- response_message = ResponseMessage.craft_from_arguments(
- receiver_id=self.client_id,
- sender_id=self.server_id,
- message_type=INVALID_MESSAGE,
- message_id=uuid4(),
- )
- self.validate_response_message(response_message)
- # check message type for the above craft_with_message_type method
- assert response_message.type == INVALID_MESSAGE
-
- response_message = ResponseMessage.craft_from_arguments(
- receiver_id=self.client_id,
- sender_id=self.server_id,
- message_type=ERROR,
- message_id=uuid4(),
- payload=SerializableData(Exception("test")),
- )
- self.validate_response_message(response_message)
- assert response_message.type == ERROR
- assert isinstance(Serializers.json.loads(response_message._bytes[2]), dict)
-
- request_message = RequestMessage.craft_from_arguments(
- sender_id=self.client_id,
- receiver_id=self.server_id,
- thing_id=self.thing_id,
- objekt="some_prop",
- operation="readProperty",
- )
- request_message._sender_id = self.client_id # will be done by craft_from_self
- response_message = ResponseMessage.craft_reply_from_request(
- request_message=request_message,
- )
- self.validate_response_message(response_message)
- assert response_message.type == REPLY
- assert Serializers.json.loads(response_message._bytes[3]) is None # INDEX_BODY = 3
- assert request_message.id == response_message.id
-
- def test_3_event_message(self):
- """test the event message"""
- event_message = EventMessage.craft_from_arguments(
- event_id="test-event",
- sender_id=self.server_id,
- payload=SerializableData("test"),
- preserialized_payload=PreserializedData(b"test"),
- )
- self.validate_event_message(event_message)
-
-
-# def validate_request_message(request_message, server_id, client_id):
-# """Validate request message contract."""
-# assert isinstance(request_message.id, UUID) or isinstance(UUID(request_message.id, version=4), UUID)
-# assert len(request_message.byte_array) == request_message.length
-# assert request_message.receiver_id == server_id
-# assert request_message.sender_id == client_id
-# for obj in request_message.byte_array:
-# assert isinstance(obj, bytes)
-# assert isinstance(request_message.header, RequestHeader)
-# assert isinstance(request_message.body, list)
-# assert len(request_message.body) == 2
-# assert isinstance(request_message.body[0], SerializableData)
-# assert isinstance(request_message.body[1], PreserializedData)
-
-# def validate_response_message(response_message, server_id, client_id):
-# """Validate response message contract."""
-# assert isinstance(response_message.id, UUID) or isinstance(UUID(response_message.id, version=4), UUID)
-# assert len(response_message.byte_array) == response_message.length
-# assert response_message.receiver_id == client_id
-# assert response_message.sender_id == server_id
-# for obj in response_message.byte_array:
-# assert isinstance(obj, bytes)
-# assert isinstance(response_message.header, ResponseHeader)
-# assert isinstance(response_message.body, list)
-# assert len(response_message.body) == 2
-# assert isinstance(response_message.body[0], SerializableData)
-# assert isinstance(response_message.body[1], PreserializedData)
-
-# def validate_event_message(event_message, server_id):
-# """Validate event message contract."""
-# assert isinstance(event_message.id, UUID) or isinstance(UUID(event_message.id, version=4), UUID)
-# assert len(event_message.byte_array) == event_message.length
-# assert isinstance(event_message.event_id, str)
-# assert event_message.sender_id == server_id
-# for obj in event_message.byte_array:
-# assert isinstance(obj, bytes)
-# assert isinstance(event_message.header, EventHeader)
-# assert isinstance(event_message.body, list)
-# assert len(event_message.body) == 2
-# assert isinstance(event_message.body[0], SerializableData)
-# assert isinstance(event_message.body[1], PreserializedData)
-
-# @pytest.fixture(scope="module")
-# def test_ids():
-# return {
-# "server_id": "server-uuid",
-# "client_id": "client-uuid",
-# "thing_id": "thing-uuid",
-# }
-
-# @pytest.mark.order(1)
-# class TestMessagingContract:
-# """Tests request and response messages"""
-
-# def test_1_request_message(self, test_ids):
-# request_message = RequestMessage.craft_from_arguments(
-# receiver_id=test_ids["server_id"],
-# sender_id=test_ids["client_id"],
-# thing_id=test_ids["thing_id"],
-# objekt="some_prop",
-# operation="readproperty",
-# )
-# validate_request_message(request_message, test_ids["server_id"], test_ids["client_id"])
-# assert request_message.type == OPERATION
-
-# request_message = RequestMessage.craft_with_message_type(
-# receiver_id=test_ids["server_id"], sender_id=test_ids["client_id"], message_type=HANDSHAKE
-# )
-# validate_request_message(request_message, test_ids["server_id"], test_ids["client_id"])
-# assert request_message.type == HANDSHAKE
-
-# request_message = RequestMessage.craft_with_message_type(
-# receiver_id=test_ids["server_id"], sender_id=test_ids["client_id"], message_type=EXIT
-# )
-# validate_request_message(request_message, test_ids["server_id"], test_ids["client_id"])
-# assert request_message.type == EXIT
-
-# def test_2_response_message(self, test_ids):
-# response_message = ResponseMessage.craft_from_arguments(
-# receiver_id=test_ids["client_id"],
-# sender_id=test_ids["server_id"],
-# message_type=HANDSHAKE,
-# message_id=uuid4(),
-# )
-# validate_response_message(response_message, test_ids["server_id"], test_ids["client_id"])
-# assert response_message.type == HANDSHAKE
-
-# response_message = ResponseMessage.craft_from_arguments(
-# receiver_id=test_ids["client_id"],
-# sender_id=test_ids["server_id"],
-# message_type=TIMEOUT,
-# message_id=uuid4(),
-# )
-# validate_response_message(response_message, test_ids["server_id"], test_ids["client_id"])
-# assert response_message.type == TIMEOUT
-
-# response_message = ResponseMessage.craft_from_arguments(
-# receiver_id=test_ids["client_id"],
-# sender_id=test_ids["server_id"],
-# message_type=INVALID_MESSAGE,
-# message_id=uuid4(),
-# )
-# validate_response_message(response_message, test_ids["server_id"], test_ids["client_id"])
-# assert response_message.type == INVALID_MESSAGE
-
-# response_message = ResponseMessage.craft_from_arguments(
-# receiver_id=test_ids["client_id"],
-# sender_id=test_ids["server_id"],
-# message_type=ERROR,
-# message_id=uuid4(),
-# payload=SerializableData(Exception("test")),
-# )
-# validate_response_message(response_message, test_ids["server_id"], test_ids["client_id"])
-# assert response_message.type == ERROR
-# assert isinstance(Serializers.json.loads(response_message._bytes[2]), dict)
-
-# request_message = RequestMessage.craft_from_arguments(
-# sender_id=test_ids["client_id"],
-# receiver_id=test_ids["server_id"],
-# thing_id=test_ids["thing_id"],
-# objekt="some_prop",
-# operation="readProperty",
-# )
-# request_message._sender_id = test_ids["client_id"]
-# response_message = ResponseMessage.craft_reply_from_request(
-# request_message=request_message,
-# )
-# validate_response_message(response_message, test_ids["server_id"], test_ids["client_id"])
-# assert response_message.type == REPLY
-# assert Serializers.json.loads(response_message._bytes[3]) is None
-# assert request_message.id == response_message.id
-
-# def test_3_event_message(self, test_ids):
-# event_message = EventMessage.craft_from_arguments(
-# event_id="test-event",
-# sender_id=test_ids["server_id"],
-# payload=SerializableData("test"),
-# preserialized_payload=PreserializedData(b"test"),
-# )
-# validate_event_message(event_message, test_ids["server_id"])
diff --git a/tests/test_00_utils.py b/tests/test_00_utils.py
index 4c99626c..2471a931 100644
--- a/tests/test_00_utils.py
+++ b/tests/test_00_utils.py
@@ -1,487 +1,361 @@
-import unittest
-import typing
+from typing import Any, Dict, List, Tuple
+
+import pytest
+
from pydantic import BaseModel, ValidationError
-from hololinked.utils import (
- get_input_model_from_signature,
- issubklass,
- pydantic_validate_args_kwargs,
- json_schema_merge_args_to_kwargs,
+from hololinked.utils import get_input_model_from_signature, issubklass, pydantic_validate_args_kwargs
+
+
+def func_without_args():
+ return 1
+
+
+def func_with_annotations(a: int, b: int) -> int:
+ return a + b
+
+
+def func_with_missing_annotations(a: int, b):
+ return a + b
+
+
+def func_with_no_annotations(a, b):
+ return a + b
+
+
+def func_with_kwargs(a: int, b: int, **kwargs):
+ return a + b
+
+
+def func_with_annotated_kwargs(a: int, b: int, **kwargs: dict[str, int]):
+ return a + b
+
+
+def func_with_args(*args):
+ return sum(args)
+
+
+def func_with_annotated_args(*args: list[int]):
+ return sum(args)
+
+
+def func_with_args_and_kwargs(*args, **kwargs):
+ return sum(args) + sum(kwargs.values())
+
+
+def func_with_annotated_args_and_kwargs(*args: list[int], **kwargs: dict[str, int]):
+ return sum(args) + sum(kwargs.values())
+
+
+def test_func_without_args_model_none():
+ model = get_input_model_from_signature(func_without_args)
+ assert model is None
+
+
+def test_01_model_func_with_annotations():
+ model = get_input_model_from_signature(func_with_annotations)
+ assert issubklass(model, BaseModel)
+ assert model.model_fields["a"].annotation is int
+ assert model.model_fields["b"].annotation is int
+ assert len(model.model_fields) == 2
+ assert model.model_config["extra"] == "forbid"
+
+
+@pytest.mark.parametrize(
+ "args,kwargs,raises,exmsg",
+ [
+ (None, {"a": 1, "b": 2}, None, None),
+ (None, {"a": 1, "b": "2"}, ValidationError, None),
+ (None, {"a": 1}, ValidationError, None),
+ (None, {"a": 1, "b": 2, "c": 3}, ValueError, "Unexpected keyword arguments"),
+ ((1, 2), None, None, None),
+ ((1, "2"), None, ValidationError, None),
+ ((1, 2, 3), None, ValueError, "Too many positional arguments"),
+ ((1,), None, ValidationError, None),
+ ((1,), {"b": 2}, None, None),
+ ((1,), {"a": 2}, ValueError, "Multiple values for argument"),
+ ((1, 2), {"c": 3}, ValueError, "Unexpected keyword arguments"),
+ (("1", 2), {"c": 3}, ValueError, "Unexpected keyword arguments"),
+ ],
+)
+def test_01_validation_func_with_annotations(args, kwargs, raises, exmsg):
+ model = get_input_model_from_signature(func_with_annotations)
+ if raises:
+ with pytest.raises(raises) as ex:
+ pydantic_validate_args_kwargs(model, args=args if args else (), kwargs=kwargs if kwargs else {})
+ if exmsg:
+ assert str(ex.value).startswith(exmsg)
+ else:
+ pydantic_validate_args_kwargs(model, args=args if args else (), kwargs=kwargs if kwargs else {})
+
+
+def test_02_model_func_with_missing_annotations():
+ model = get_input_model_from_signature(func_with_missing_annotations)
+ assert issubklass(model, BaseModel)
+ assert model.model_fields["a"].annotation is int
+ assert model.model_fields["b"].annotation is Any
+ assert len(model.model_fields) == 2
+ assert model.model_config["extra"] == "forbid"
+
+
+@pytest.mark.parametrize(
+ "args,kwargs,raises,exmsg",
+ [
+ (None, {"a": 1, "b": 2}, None, None),
+ (None, {"a": 1, "b": "2"}, None, None),
+ (None, {"a": 2, "b": list()}, None, None),
+ (None, {"a": "1", "b": "2"}, ValidationError, None),
+ (None, {"a": list(), "b": dict()}, ValidationError, None),
+ (None, {"a": 1}, ValidationError, None),
+ (None, {"a": 1, "b": 2, "c": 3}, ValueError, "Unexpected keyword arguments"),
+ ((1, 2), None, None, None),
+ ((1, "2"), None, None, None),
+ ((2, list()), None, None, None),
+ (("1", "2"), None, ValidationError, None),
+ ((list(), dict()), None, ValidationError, None),
+ ((1, 2, 3), None, ValueError, "Too many positional arguments"),
+ ((1,), None, ValidationError, None),
+ ((1,), {"b": 2}, None, None),
+ ((1,), {"b": "2"}, None, None),
+ ((2,), {"b": list()}, None, None),
+ ((1,), {"a": 2}, ValueError, "Multiple values for argument"),
+ ((1, 2), {"c": 3}, ValueError, "Unexpected keyword arguments"),
+ (("1", 2), {"c": 3}, ValueError, "Unexpected keyword arguments"),
+ ],
)
+def test_02_validation_func_with_missing_annotations(args, kwargs, raises, exmsg):
+ model = get_input_model_from_signature(func_with_missing_annotations)
+ if raises:
+ with pytest.raises(raises) as ex:
+ pydantic_validate_args_kwargs(model, args=args if args else (), kwargs=kwargs if kwargs else {})
+ if exmsg:
+ assert str(ex.value).startswith(exmsg)
+ else:
+ pydantic_validate_args_kwargs(model, args=args if args else (), kwargs=kwargs if kwargs else {})
+
+
+def test_03_model_func_with_no_annotations():
+ model = get_input_model_from_signature(func_with_no_annotations, model_for_empty_annotations=True)
+ assert issubklass(model, BaseModel)
+ assert model.model_fields["a"].annotation is Any
+ assert model.model_fields["b"].annotation is Any
+ assert len(model.model_fields) == 2
+ assert model.model_config["extra"] == "forbid"
+
+
+@pytest.mark.parametrize(
+ "args,kwargs,raises,exmsg",
+ [
+ (None, {"a": 1, "b": 2}, None, None),
+ (None, {"a": 1.2, "b": "2"}, None, None),
+ (None, {"a": dict(), "b": list()}, None, None),
+ (None, {"a": list()}, ValidationError, None),
+ (None, {"b": dict()}, ValidationError, None),
+ (None, {"a": 1, "b": 2, "c": 3}, ValueError, "Unexpected keyword arguments"),
+ ((1, 2), None, None, None),
+ ((1, "2"), None, None, None),
+ ((dict(), list()), None, None, None),
+ ((1,), {"b": 2}, None, None),
+ ((1, 2, 3), None, ValueError, "Too many positional arguments"),
+ ((dict(), list(), 3), None, ValueError, "Too many positional arguments"),
+ ((1,), None, ValidationError, None),
+ ((dict(),), None, ValidationError, None),
+ ((1,), {"b": 2}, None, None),
+ ((1.1,), {"b": "2"}, None, None),
+ ((dict(),), {"b": list()}, None, None),
+ ((1,), {"a": 2}, ValueError, "Multiple values for argument"),
+ ((1, 2), {"c": 3}, ValueError, "Unexpected keyword arguments"),
+ (("1", 2), {"c": 3}, ValueError, "Unexpected keyword arguments"),
+ ],
+)
+def test_03_validation_func_with_no_annotations(args, kwargs, raises, exmsg):
+ model = get_input_model_from_signature(func_with_no_annotations, model_for_empty_annotations=True)
+ if raises:
+ with pytest.raises(raises) as ex:
+ pydantic_validate_args_kwargs(model, args=args if args else (), kwargs=kwargs if kwargs else {})
+ if exmsg:
+ assert str(ex.value).startswith(exmsg)
+ else:
+ pydantic_validate_args_kwargs(model, args=args if args else (), kwargs=kwargs if kwargs else {})
+
+
+def test_03_no_model_func_with_no_annotations():
+ model = get_input_model_from_signature(func_with_no_annotations)
+ assert model is None
+
+
+def test_04_model_func_with_kwargs():
+ model = get_input_model_from_signature(func_with_kwargs)
+ assert issubklass(model, BaseModel)
+ assert model.model_fields["a"].annotation is int
+ assert model.model_fields["b"].annotation is int
+ assert len(model.model_fields) == 3
+ assert model.model_config["extra"] == "forbid"
+
+
+@pytest.mark.parametrize(
+ "args,kwargs,raises,exmsg",
+ [
+ (None, {"a": 1, "b": 2}, None, None),
+ (None, {"a": 1, "b": 2, "c": 3}, None, None),
+ ((1, 2), {"c": "3"}, None, None),
+ (None, {"a": 1, "b": "2"}, ValidationError, None),
+ (None, {"a": 1, "b": "2", "c": "3"}, ValidationError, None),
+ (None, {"a": 1}, ValidationError, None),
+ (None, {"a": 1, "b": 2, "c": 3, "d": 4}, None, None),
+ ((1, 2), None, None, None),
+ ((1, "2"), None, ValidationError, None),
+ (("1", 2), None, ValidationError, None),
+ ((1, 2, 3), None, ValidationError, None),
+ ((1,), None, ValidationError, None),
+ ((1,), {"b": 2}, None, None),
+ ((1,), {"b": 2, "c": 3}, None, None),
+ ((1,), {"a": 2}, ValueError, "Multiple values for argument"),
+ ((1, 2), {"a": 3}, ValueError, "Multiple values for argument"),
+ ((1, 2), {"b": 3}, ValueError, "Multiple values for argument"),
+ ],
+)
+def test_04_validation_func_with_kwargs(args, kwargs, raises, exmsg):
+ model = get_input_model_from_signature(func_with_kwargs)
+ if raises:
+ with pytest.raises(raises) as ex:
+ pydantic_validate_args_kwargs(model, args=args if args else (), kwargs=kwargs if kwargs else {})
+ if exmsg:
+ assert str(ex.value).startswith(exmsg)
+ else:
+ pydantic_validate_args_kwargs(model, args=args if args else (), kwargs=kwargs if kwargs else {})
+
+
+def test_05_model_func_with_annotated_kwargs():
+ model = get_input_model_from_signature(func_with_annotated_kwargs)
+ assert issubklass(model, BaseModel)
+ assert model.model_fields["a"].annotation is int
+ assert model.model_fields["b"].annotation is int
+ assert model.model_fields["kwargs"].annotation == dict[str, int]
+ assert len(model.model_fields) == 3
+ assert model.model_config["extra"] == "forbid"
+
+
+@pytest.mark.parametrize(
+ "args,kwargs,raises,exmsg",
+ [
+ (None, {"a": 1, "b": 2}, None, None),
+ (None, {"a": 1, "b": 2, "c": 3}, None, None),
+ ((1, 2), {"c": 3}, None, None),
+ (None, {"a": 1, "b": "2"}, ValidationError, None),
+ (None, {"a": 1, "b": 2, "c": "3"}, ValidationError, None),
+ (None, {"a": 1, "b": 2, "c": list()}, ValidationError, None),
+ (None, {"a": 1}, ValidationError, None),
+ ((1, 2), None, None, None),
+ ((1, "2"), None, ValidationError, None),
+ ((dict(), 2), None, ValidationError, None),
+ ((1, 2, 3), None, ValidationError, None),
+ ((1,), None, ValidationError, None),
+ ((1,), {"b": 2}, None, None),
+ ((1,), {"b": 2, "c": 3}, None, None),
+ ((1,), {"a": 2}, ValueError, "Multiple values for argument"),
+ ((1, 2), {"a": 3}, ValueError, "Multiple values for argument"),
+ ((1, 2), {"b": 3}, ValueError, "Multiple values for argument"),
+ ((1, 2), {"a": list(), "c": 3}, ValueError, "Multiple values for argument"),
+ ],
+)
+def test_05_validation_func_with_annotated_kwargs(args, kwargs, raises, exmsg):
+ model = get_input_model_from_signature(func_with_annotated_kwargs)
+ if raises:
+ with pytest.raises(raises) as ex:
+ pydantic_validate_args_kwargs(model, args=args if args else (), kwargs=kwargs if kwargs else {})
+ if exmsg:
+ assert str(ex.value).startswith(exmsg)
+ else:
+ pydantic_validate_args_kwargs(model, args=args if args else (), kwargs=kwargs if kwargs else {})
+
+
+def test_06_model_func_with_args():
+ model = get_input_model_from_signature(func_with_args, model_for_empty_annotations=True)
+ assert issubklass(model, BaseModel)
+ # assert model.model_fields["args"].annotation == tuple or model.model_fields["args"].annotation == Tuple
+ assert len(model.model_fields) == 1
+ assert model.model_config["extra"] == "forbid"
+
+
+@pytest.mark.parametrize(
+ "args,kwargs,raises,exmsg",
+ [
+ ((1, 2), None, None, None),
+ (None, None, None, None),
+ ((dict(),), None, None, None),
+ (None, {"a": 1}, ValueError, "Unexpected keyword arguments"),
+ ((1, 2), None, None, None),
+ ((1,), {"a": 2}, ValueError, "Unexpected keyword arguments"),
+ ((1, 2), {"c": 3}, ValueError, "Unexpected keyword arguments"),
+ ],
+)
+def test_06_validation_func_with_args(args, kwargs, raises, exmsg):
+ model = get_input_model_from_signature(func_with_args, model_for_empty_annotations=True)
+ if raises:
+ with pytest.raises(raises) as ex:
+ pydantic_validate_args_kwargs(model, args=args if args else (), kwargs=kwargs if kwargs else {})
+ if exmsg:
+ assert str(ex.value).startswith(exmsg)
+ else:
+ pydantic_validate_args_kwargs(model, args=args if args else (), kwargs=kwargs if kwargs else {})
+
+
+def test_06_no_model_func_with_args():
+ model = get_input_model_from_signature(func_with_args)
+ assert model is None
+
+
+def test_07_model_func_with_annotated_args():
+ model = get_input_model_from_signature(func_with_annotated_args)
+ assert issubklass(model, BaseModel)
+ # assert model.model_fields["args"].annotation == typing.List[int]
+ assert len(model.model_fields) == 1
+ assert model.model_config["extra"] == "forbid"
+
+
+@pytest.mark.parametrize(
+ "args,kwargs,raises,exmsg",
+ [
+ (None, {"a": 1}, ValueError, "Unexpected keyword arguments"),
+ (None, None, None, None),
+ ((1, 2), None, None, None),
+ ((1, "2"), None, ValidationError, None),
+ ((dict(),), None, ValidationError, None),
+ ],
+)
+def test_07_validation_func_with_annotated_args(args, kwargs, raises, exmsg):
+ model = get_input_model_from_signature(func_with_annotated_args)
+ if raises:
+ with pytest.raises(raises) as ex:
+ pydantic_validate_args_kwargs(model, args=args if args else (), kwargs=kwargs if kwargs else {})
+ if exmsg:
+ assert str(ex.value).startswith(exmsg)
+ else:
+ pydantic_validate_args_kwargs(model, args=args if args else (), kwargs=kwargs if kwargs else {})
+
+
+def test_08_no_model_func_with_args_and_kwargs():
+ model = get_input_model_from_signature(func_with_args_and_kwargs)
+ assert model is None
+
+
+def test_08_model_func_with_args_and_kwargs():
+ model = get_input_model_from_signature(func_with_args_and_kwargs, model_for_empty_annotations=True)
+ assert issubklass(model, BaseModel)
+ assert model.model_fields["args"].annotation == Tuple or model.model_fields["args"].annotation is tuple
+ assert model.model_fields["kwargs"].annotation == Dict[str, Any] or model.model_fields["kwargs"].annotation is dict
+ assert len(model.model_fields) == 2
+ assert model.model_config["extra"] == "forbid"
+
-try:
- from .utils import TestCase, TestRunner
-except ImportError:
- from utils import TestCase, TestRunner
-
-
-class TestUtils(TestCase):
- def test_1_pydantic_function_signature_validation(self):
- def func_without_args():
- return 1
-
- model = get_input_model_from_signature(func_without_args)
- self.assertTrue(model is None)
-
- """
- Test Sequence:
- 1. Create model from function signature
- 2. Check model annotations
- 3. Check model fields length
- 4. Check model config (pydantic's model_config)
- 5. Validation with correction and wrong invokation of function
- 6. Always check exception strings for ValueError
- 7. Use ValidationError if pydantic is supposed to raise the Error
- """
-
- """
- Signatures that we will validate:
- 1. func_with_annotations(a: int, b: int) -> int:
- 2. func_with_missing_annotations(a: int, b):
- 3. func_with_no_annotations(a, b):
- 4. func_with_kwargs(a: int, b: int, **kwargs):
- 5. func_with_annotated_kwargs(a: int, b: int, **kwargs: typing.Dict[str, int]):
- 6. func_with_args(*args):
- 7. func_with_annotated_args(*args: typing.List[int]):
- 8. func_with_args_and_kwargs(*args, **kwargs):
- 9. func_with_annotated_args_and_kwargs(*args: typing.List[int], **kwargs: typing.Dict[str, int]):
- 10. func_with_positional_only_args(a, b, /):
- 11. func_with_keyword_only_args(*, a, b):
- 12. func_with_positional_only_args_and_kwargs(a, *args, b, **kwargs):
- """
-
- ####################
- ##### create model from function signature
- # 1. func_with_annotations(a: int, b: int) -> int:
- def func_with_annotations(a: int, b: int) -> int:
- return a + b
-
- model = get_input_model_from_signature(func_with_annotations)
- self.assertTrue(issubklass(model, BaseModel))
- self.assertEqual(model.model_fields["a"].annotation, int)
- self.assertEqual(model.model_fields["b"].annotation, int)
- self.assertEqual(len(model.model_fields), 2)
- self.assertEqual(model.model_config["extra"], "forbid")
- ##### validate correct usage
- # For all the following cases, see block comment below the test case for details
- # 1. correct usage with keyword arguments
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": 2})
- # 2. incorrect argument types with keyword arguments
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": "2"})
- # 3. missing keyword arguments
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, kwargs={"a": 1})
- # 4. too many keyword arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": 2, "c": 3})
- self.assertTrue(str(ex.exception).startswith("Unexpected keyword arguments"))
- # 5. correct usage with positional arguments
- pydantic_validate_args_kwargs(model, args=(1, 2))
- # 6. incorrect argument types with positional arguments
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, args=(1, "2"))
- # 7. too many positional arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1, 2, 3))
- self.assertTrue(str(ex.exception).startswith("Too many positional arguments"))
- # 8. missing positional arguments
- with self.assertRaises(ValidationError) as ex:
- pydantic_validate_args_kwargs(model, args=(1,))
- # 9. correct usage with positional and keyword arguments
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"b": 2})
- # 10. incorrect ordering with positional and keyword arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"a": 2})
- self.assertTrue(str(ex.exception).startswith("Multiple values for argument"))
- # 11. incorrect usage with both positional and keyword arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1, 2), kwargs={"c": 3})
- self.assertTrue(str(ex.exception).startswith("Unexpected keyword arguments"))
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=("1", 2), kwargs={"c": 3})
- self.assertTrue(str(ex.exception).startswith("Unexpected keyword arguments"))
- ####################
-
- # 1. correct usage with keyword arguments
- # 2. incorrect argument types with keyword arguments
- # 3. missing keyword arguments
- # 4. too many keyword arguments
- # 5. correct usage with positional arguments
- # 6. incorrect argument types with positional arguments
- # 7. too many positional arguments
- # 8. missing positional arguments
- # 9. correct usage with positional and keyword arguments
- # 10. incorrect ordering with positional and keyword arguments
- # 11. additional cases of incorrect usage falling under the same categories
-
- ####################
- ##### create model from function signature
- # 2. func_with_missing_annotations(a: int, b):
- def func_with_missing_annotations(a: int, b):
- return a + b
-
- model = get_input_model_from_signature(func_with_missing_annotations)
- self.assertTrue(issubklass(model, BaseModel))
- self.assertEqual(model.model_fields["a"].annotation, int)
- self.assertEqual(model.model_fields["b"].annotation, typing.Any)
- self.assertEqual(len(model.model_fields), 2)
- self.assertEqual(model.model_config["extra"], "forbid")
- ##### validate correct usage
- # 1. correct usage with keyword arguments
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": 2})
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": "2"})
- pydantic_validate_args_kwargs(model, kwargs={"a": 2, "b": list()})
- # 2. incorrect argument types with keyword arguments
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, kwargs={"a": "1", "b": "2"})
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, kwargs={"a": list(), "b": dict()})
- # 3. missing keyword arguments
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, kwargs={"a": 1})
- # 4. too many keyword arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": 2, "c": 3})
- self.assertTrue(str(ex.exception).startswith("Unexpected keyword arguments"))
- # 5. correct positional arguments
- pydantic_validate_args_kwargs(model, args=(1, 2))
- pydantic_validate_args_kwargs(model, args=(1, "2"))
- pydantic_validate_args_kwargs(model, args=(2, list()))
- # 6. incorrect argument types with positional arguments
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, args=("1", "2"))
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, args=(list(), dict()))
- # 7. too many positional arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1, 2, 3))
- self.assertTrue(str(ex.exception).startswith("Too many positional arguments"))
- # 8. missing positional arguments
- with self.assertRaises(ValidationError) as ex:
- pydantic_validate_args_kwargs(model, args=(1,))
- # 9. correct usage with positional and keyword arguments
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"b": 2})
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"b": "2"})
- pydantic_validate_args_kwargs(model, args=(2,), kwargs={"b": list()})
- # 10. incorrect ordering with positional and keyword arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"a": 2})
- self.assertTrue(str(ex.exception).startswith("Multiple values for argument"))
- # 11. incorrect usage with both positional and keyword arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1, 2), kwargs={"c": 3})
- self.assertTrue(str(ex.exception).startswith("Unexpected keyword arguments"))
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=("1", 2), kwargs={"c": 3})
- self.assertTrue(str(ex.exception).startswith("Unexpected keyword arguments"))
- ####################
-
- ####################
- ##### create model from function signature
- # 3. func_with_no_annotations(a, b):
- def func_with_no_annotations(a, b):
- return a + b
-
- model = get_input_model_from_signature(func_with_no_annotations, model_for_empty_annotations=True)
- self.assertTrue(issubklass(model, BaseModel))
- self.assertEqual(model.model_fields["a"].annotation, typing.Any)
- self.assertEqual(model.model_fields["b"].annotation, typing.Any)
- self.assertEqual(len(model.model_fields), 2)
- self.assertEqual(model.model_config["extra"], "forbid")
- ##### validate correct usage
- # 1. correct usage
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": 2})
- pydantic_validate_args_kwargs(model, kwargs={"a": 1.2, "b": "2"})
- pydantic_validate_args_kwargs(model, kwargs={"a": dict(), "b": list()})
- # 2. incorrect argument types
- # typing.Any allows any type, so no ValidationError
- # 3. missing keyword arguments
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, kwargs={"a": list()})
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, kwargs={"b": dict()})
- # 4. too many keyword arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": 2, "c": 3})
- self.assertTrue(str(ex.exception).startswith("Unexpected keyword arguments"))
- # 5. correct positional arguments
- pydantic_validate_args_kwargs(model, args=(1, 2))
- pydantic_validate_args_kwargs(model, args=(1, "2"))
- pydantic_validate_args_kwargs(model, args=(dict(), list()))
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"b": 2})
- # 6. incorrect argument types with positional arguments
- # typing.Any allows any type, so no ValidationError
- # 7. too many positional arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1, 2, 3))
- self.assertTrue(str(ex.exception).startswith("Too many positional arguments"))
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(dict(), list(), 3))
- self.assertTrue(str(ex.exception).startswith("Too many positional arguments"))
- # 8. missing positional arguments
- with self.assertRaises(ValidationError) as ex:
- pydantic_validate_args_kwargs(model, args=(1,))
- with self.assertRaises(ValidationError) as ex:
- pydantic_validate_args_kwargs(model, args=(dict(),))
- # 9. correct usage with positional and keyword arguments
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"b": 2})
- pydantic_validate_args_kwargs(model, args=(1.1,), kwargs={"b": "2"})
- pydantic_validate_args_kwargs(model, args=(dict(),), kwargs={"b": list()})
- # 10. incorrect ordering with positional and keyword arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"a": 2})
- self.assertTrue(str(ex.exception).startswith("Multiple values for argument"))
- # 11. incorrect usage with both positional and keyword arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1, 2), kwargs={"c": 3})
- self.assertTrue(str(ex.exception).startswith("Unexpected keyword arguments"))
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=("1", 2), kwargs={"c": 3})
- self.assertTrue(str(ex.exception).startswith("Unexpected keyword arguments"))
-
- model = get_input_model_from_signature(func_with_no_annotations)
- self.assertTrue(model is None)
-
- ####################
- ##### create model from function signature
- # 4. func_with_kwargs(a: int, b: int, **kwargs):
- def func_with_kwargs(a: int, b: int, **kwargs):
- return a + b
-
- model = get_input_model_from_signature(func_with_kwargs)
- self.assertTrue(issubklass(model, BaseModel))
- self.assertEqual(model.model_fields["a"].annotation, int)
- self.assertEqual(model.model_fields["b"].annotation, int)
- self.assertEqual(len(model.model_fields), 3)
- self.assertEqual(model.model_config["extra"], "forbid")
- ##### validate correct usage
- # 1. correct usage
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": 2})
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": 2, "c": 3})
- pydantic_validate_args_kwargs(model, args=(1, 2), kwargs={"c": "3"})
- # 2. incorrect argument types
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": "2"})
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": "2", "c": "3"})
- # 3. missing keyword arguments
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, kwargs={"a": 1})
- # 4. too many keyword arguments
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": 2, "c": 3, "d": 4}) # OK, not an error
- # 5. correct positional arguments
- pydantic_validate_args_kwargs(model, args=(1, 2))
- # 6. incorrect argument types with positional arguments
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, args=(1, "2"))
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, args=("1", 2))
- # 7. too many positional arguments
- with self.assertRaises(ValidationError) as ex:
- pydantic_validate_args_kwargs(model, args=(1, 2, 3))
- # 8. missing positional arguments
- with self.assertRaises(ValidationError) as ex:
- pydantic_validate_args_kwargs(model, args=(1,))
- # 9. correct usage with positional and keyword arguments
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"b": 2})
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"b": 2, "c": 3})
- # 10. incorrect ordering with positional and keyword arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"a": 2})
- self.assertTrue(str(ex.exception).startswith("Multiple values for argument"))
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1, 2), kwargs={"a": 3})
- self.assertTrue(str(ex.exception).startswith("Multiple values for argument"))
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1, 2), kwargs={"b": 3})
- self.assertTrue(str(ex.exception).startswith("Multiple values for argument"))
- # 11. incorrect usage with both positional and keyword arguments
- # any extra keyword argument is allowed
-
- ####################
- ##### create model from function signature
- # 5. func_with_annotated_kwargs(a: int, b: int, **kwargs: typing.Dict[str, int]):
- def func_with_annotated_kwargs(a: int, b: int, **kwargs: typing.Dict[str, int]):
- return a + b
-
- model = get_input_model_from_signature(func_with_annotated_kwargs)
- self.assertTrue(issubklass(model, BaseModel))
- self.assertEqual(model.model_fields["a"].annotation, int)
- self.assertEqual(model.model_fields["b"].annotation, int)
- self.assertEqual(model.model_fields["kwargs"].annotation, typing.Dict[str, int])
- self.assertEqual(len(model.model_fields), 3)
- self.assertEqual(model.model_config["extra"], "forbid")
- # 1. correct usage
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": 2})
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": 2, "c": 3})
- pydantic_validate_args_kwargs(model, args=(1, 2), kwargs={"c": 3})
- # 2. incorrect argument types
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": "2"})
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": 2, "c": "3"})
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, kwargs={"a": 1, "b": 2, "c": list()})
- # 3. missing keyword arguments
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, kwargs={"a": 1})
- # 4. too many keyword arguments
- # OK, not an error
- # 5. correct positional arguments
- pydantic_validate_args_kwargs(model, args=(1, 2))
- # 6. incorrect argument types with positional arguments
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, args=(1, "2"))
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, args=(dict(), 2))
- # 7. too many positional arguments
- with self.assertRaises(ValidationError) as ex:
- pydantic_validate_args_kwargs(model, args=(1, 2, 3))
- # 8. missing positional arguments
- with self.assertRaises(ValidationError) as ex:
- pydantic_validate_args_kwargs(model, args=(1,))
- # 9. correct usage with positional and keyword arguments
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"b": 2})
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"b": 2, "c": 3})
- # 10. incorrect ordering with positional and keyword arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"a": 2})
- self.assertTrue(str(ex.exception).startswith("Multiple values for argument"))
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1, 2), kwargs={"a": 3})
- self.assertTrue(str(ex.exception).startswith("Multiple values for argument"))
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1, 2), kwargs={"b": 3})
- self.assertTrue(str(ex.exception).startswith("Multiple values for argument"))
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1, 2), kwargs={"a": list(), "c": 3})
- self.assertTrue(str(ex.exception).startswith("Multiple values for argument"))
- # 11. incorrect usage with both positional and keyword arguments
- # any extra keyword argument is allowed so long it is of type int
-
- # both the following are not allowed in python - its also illogical
- # def func_with_double_args(*args1, *args2):
- # """syntax error"""
- # return
- # def func_with_double_kwargs(**kwargs1, **kwargs2):
- # """syntax error"""
- # return
-
- ####################
- ##### create model from function signature
- # 6. func_with_args(*args):
- def func_with_args(*args):
- return sum(args)
-
- model = get_input_model_from_signature(func_with_args, model_for_empty_annotations=True)
- self.assertTrue(issubklass(model, BaseModel))
- self.assertEqual(model.model_fields["args"].annotation, typing.Tuple)
- self.assertEqual(len(model.model_fields), 1)
- self.assertEqual(model.model_config["extra"], "forbid")
- # 1. correct usage
- pydantic_validate_args_kwargs(model, args=(1, 2))
- pydantic_validate_args_kwargs(model)
- pydantic_validate_args_kwargs(model, args=(dict()))
- # 2. incorrect argument types
- # OK, since args is a tuple of any type
- # 3. missing keyword arguments
- # OK, since args is a tuple
- # 4. too many keyword arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, kwargs={"a": 1})
- self.assertTrue(str(ex.exception).startswith("Unexpected keyword arguments"))
- # 5. correct positional arguments
- pydantic_validate_args_kwargs(model, args=(1, 2))
- # 6. incorrect argument types with positional arguments
- # OK, since args is a tuple of any type
- # 7. too many positional arguments
- # OK, since args is a tuple of any length
- # 8. missing positional arguments
- # OK, since args is a tuple of any length
- # 9. correct usage with positional and keyword arguments
- # no keyword arguments
- # 10. incorrect ordering with positional and keyword arguments
- # OK, since args is a tuple and not keywords, no multiple values
- # 11. incorrect usage with both positional and keyword arguments
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1,), kwargs={"a": 2})
- self.assertTrue(str(ex.exception).startswith("Unexpected keyword arguments"))
- with self.assertRaises(ValueError) as ex:
- pydantic_validate_args_kwargs(model, args=(1, 2), kwargs={"c": 3})
- self.assertTrue(str(ex.exception).startswith("Unexpected keyword arguments"))
-
- model = get_input_model_from_signature(func_with_args)
- self.assertTrue(model is None)
- ####################
-
- ####################
- ##### create model from function signature
- # 7. func_with_annotated_args(*args: typing.List[int]):
- def func_with_annotated_args(*args: typing.List[int]):
- return sum(args)
-
- model = get_input_model_from_signature(func_with_annotated_args)
- self.assertTrue(issubklass(model, BaseModel))
- self.assertEqual(model.model_fields["args"].annotation, typing.List[int])
- self.assertEqual(len(model.model_fields), 1)
- self.assertEqual(model.model_config["extra"], "forbid")
- # 1. correct usage with keyword arguments
- # not possible, since args is a tuple
- # 2. incorrect argument types with keyword arguments
- # keyword arguments are not allowed
- # 3. missing keyword arguments
- # not possible
- # 4. too many keyword arguments
- with self.assertRaises(ValueError):
- pydantic_validate_args_kwargs(model, kwargs={"a": 1})
- self.assertTrue(str(ex.exception).startswith("Unexpected keyword arguments"))
- # 5. correct usage with positional arguments
- pydantic_validate_args_kwargs(model)
- pydantic_validate_args_kwargs(model, args=(1, 2))
- # 6. incorrect argument types with positional arguments
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, args=(1, "2"))
- with self.assertRaises(ValidationError):
- pydantic_validate_args_kwargs(model, args=(dict(),))
- # 7. too many positional arguments
- # OK, since args is a list of any length
- # 8. missing positional arguments
- # OK, since args is a list of any length
- # 9. correct usage with positional and keyword arguments
- # not possible
- # 10. incorrect ordering with positional and keyword arguments
- # OK, since args is a list and not keywords, no multiple values
- # 11. incorrect usage with both positional and keyword arguments
- # not possible
-
- #####################
- ##### create model from function signature
- # 8. func_with_args_and_kwargs(*args, **kwargs):
- def func_with_args_and_kwargs(*args, **kwargs):
- return sum(args) + sum(kwargs.values())
-
- # no model
- model = get_input_model_from_signature(func_with_args_and_kwargs)
- self.assertTrue(model is None)
- # check model for empty annotations
- model = get_input_model_from_signature(func_with_args_and_kwargs, model_for_empty_annotations=True)
- self.assertTrue(issubklass(model, BaseModel))
- self.assertEqual(model.model_fields["args"].annotation, typing.Tuple)
- self.assertEqual(model.model_fields["kwargs"].annotation, typing.Dict[str, typing.Any])
- self.assertEqual(len(model.model_fields), 2)
- self.assertEqual(model.model_config["extra"], "forbid")
-
- def func_with_annotated_args_and_kwargs(*args: typing.List[int], **kwargs: typing.Dict[str, int]):
- return sum(args) + sum(kwargs.values())
-
- model = get_input_model_from_signature(func_with_annotated_args_and_kwargs)
- self.assertTrue(issubklass(model, BaseModel))
- self.assertEqual(model.model_fields["args"].annotation, typing.List[int])
- self.assertEqual(model.model_fields["kwargs"].annotation, typing.Dict[str, int])
- self.assertEqual(len(model.model_fields), 2)
- self.assertEqual(model.model_config["extra"], "forbid")
-
-
-if __name__ == "__main__":
- unittest.main(testRunner=TestRunner())
+def test_08_model_func_with_annotated_args_and_kwargs_model():
+ model = get_input_model_from_signature(func_with_annotated_args_and_kwargs)
+ assert issubklass(model, BaseModel)
+ assert model.model_fields["args"].annotation == List[int] or model.model_fields["args"].annotation == list[int]
+ assert (
+ model.model_fields["kwargs"].annotation == Dict[str, int]
+ or model.model_fields["kwargs"].annotation == dict[str, int]
+ )
+ assert len(model.model_fields) == 2
+ assert model.model_config["extra"] == "forbid"
diff --git a/tests/test_01_message.py b/tests/test_01_message.py
index dc72c627..5bb1548f 100644
--- a/tests/test_01_message.py
+++ b/tests/test_01_message.py
@@ -1,219 +1,197 @@
-import unittest
from uuid import UUID, uuid4
from hololinked.core.zmq.message import (
+ ERROR,
EXIT,
- OPERATION,
HANDSHAKE,
+ INVALID_MESSAGE,
+ OPERATION,
+ REPLY,
+ TIMEOUT,
+ EventHeader,
+ EventMessage,
PreserializedData,
- SerializableData,
RequestHeader,
- EventHeader,
RequestMessage,
-) # client to server
-from hololinked.core.zmq.message import (
- TIMEOUT,
- INVALID_MESSAGE,
- ERROR,
- REPLY,
- ERROR,
- ResponseMessage,
ResponseHeader,
- EventMessage,
-) # server to client
+ ResponseMessage,
+ SerializableData,
+)
from hololinked.serializers.serializers import Serializers
+
try:
- from .utils import TestCase, TestRunner
+ from .conftest import AppIDs
except ImportError:
- from utils import TestCase, TestRunner
-
-
-class MessageValidatorMixin(TestCase):
- """A mixin class to validate request and response messages"""
-
- @classmethod
- def setUpClass(cls):
- super().setUpClass()
- cls.server_id = f"test-server-{uuid4().hex[:8]}"
- cls.client_id = f"test-client-{uuid4().hex[:8]}"
- cls.thing_id = f"test-thing-{uuid4().hex[:8]}"
-
- def validate_request_message(self, request_message: RequestMessage) -> None:
- """call this method to validate request message"""
-
- # req. 1. check message ID is a UUID
- self.assertTrue(isinstance(request_message.id, UUID) or isinstance(UUID(request_message.id, version=4), UUID))
- # req. 2. generated byte array must confine to predefined length (which is readonly & fixed)
- self.assertEqual(len(request_message.byte_array), request_message.length)
- # req. 3. receiver which must be the server ID
- self.assertEqual(request_message.receiver_id, self.server_id)
- # req. 4. sender_id is the client ID
- self.assertEqual(request_message.sender_id, self.client_id)
- # req. 5. all indices of byte array are bytes
- for obj in request_message.byte_array:
- self.assertIsInstance(obj, bytes)
- # req. 6. check that header is correct type (RequestHeader dataclass/struct)
- self.assertIsInstance(request_message.header, RequestHeader)
- # req. 7 check that body is correct type (list of SerializableData and PreserializedData)
- self.assertIsInstance(request_message.body, list)
- self.assertEqual(len(request_message.body), 2)
- self.assertIsInstance(request_message.body[0], SerializableData)
- self.assertIsInstance(request_message.body[1], PreserializedData)
-
- def validate_response_message(self, response_message: ResponseMessage) -> None:
- """call this method to validate response message"""
-
- # check message ID is a UUID
- self.assertTrue(isinstance(response_message.id, UUID) or isinstance(UUID(response_message.id, version=4), UUID))
- # check message length
- self.assertEqual(len(response_message.byte_array), response_message.length)
- # check receiver which must be the client
- self.assertEqual(response_message.receiver_id, self.client_id)
- # sender_id is not set before sending message on the socket
- self.assertEqual(response_message.sender_id, self.server_id)
- # check that all indices are bytes
- for obj in response_message.byte_array:
- self.assertIsInstance(obj, bytes)
- # check that header is correct type
- self.assertIsInstance(response_message.header, ResponseHeader)
- # check that body is correct type
- self.assertIsInstance(response_message.body, list)
- self.assertEqual(len(response_message.body), 2)
- self.assertIsInstance(response_message.body[0], SerializableData)
- self.assertIsInstance(response_message.body[1], PreserializedData)
-
- def validate_event_message(self, event_message: EventMessage) -> None:
- """call this method to validate event message"""
-
- # check message ID is a UUID
- self.assertTrue(isinstance(event_message.id, UUID) or isinstance(UUID(event_message.id, version=4), UUID))
- # check message length
- self.assertEqual(len(event_message.byte_array), event_message.length)
- # no receiver id for event message, only event id
- self.assertIsInstance(event_message.event_id, str)
- # sender_id is not set before sending message on the socket
- self.assertEqual(event_message.sender_id, self.server_id)
- # check that all indices are bytes
- for obj in event_message.byte_array:
- self.assertIsInstance(obj, bytes)
- # check that header is correct type
- self.assertIsInstance(event_message.header, EventHeader)
- # check that body is correct type
- self.assertIsInstance(event_message.body, list)
- self.assertEqual(len(event_message.body), 2)
- self.assertIsInstance(event_message.body[0], SerializableData)
- self.assertIsInstance(event_message.body[1], PreserializedData)
-
-
-class TestMessagingContract(MessageValidatorMixin):
- """Tests request and response messages"""
-
- @classmethod
- def setUpClass(cls):
- super().setUpClass()
- print(f"test message contract with {cls.__name__}")
-
- def test_1_request_message(self):
- """test the request message"""
-
- # request messages types are OPERATION, HANDSHAKE & EXIT
- request_message = RequestMessage.craft_from_arguments(
- receiver_id=self.server_id,
- sender_id=self.client_id,
- thing_id=self.thing_id,
- objekt="some_prop",
- operation="readproperty",
- )
- self.validate_request_message(request_message)
- # check message type for the above craft_from_arguments method
- self.assertEqual(request_message.type, OPERATION)
-
- request_message = RequestMessage.craft_with_message_type(
- receiver_id=self.server_id, sender_id=self.client_id, message_type=HANDSHAKE
- )
- self.validate_request_message(request_message)
- # check message type for the above craft_with_message_type method
- self.assertEqual(request_message.type, HANDSHAKE)
-
- request_message = RequestMessage.craft_with_message_type(
- receiver_id=self.server_id, sender_id=self.client_id, message_type=EXIT
- )
- self.validate_request_message(request_message)
- # check message type for the above craft_with_message_type method
- self.assertEqual(request_message.type, EXIT)
-
- def test_2_response_message(self):
- """test the response message"""
-
- # response messages types are HANDSHAKE, TIMEOUT, INVALID_MESSAGE, ERROR and REPLY
- response_message = ResponseMessage.craft_from_arguments(
- receiver_id=self.client_id,
- sender_id=self.server_id,
- message_type=HANDSHAKE,
- message_id=uuid4(),
- )
- self.validate_response_message(response_message)
- # check message type for the above craft_with_message_type method
- self.assertEqual(response_message.type, HANDSHAKE)
-
- response_message = ResponseMessage.craft_from_arguments(
- receiver_id=self.client_id,
- sender_id=self.server_id,
- message_type=TIMEOUT,
- message_id=uuid4(),
- )
- self.validate_response_message(response_message)
- # check message type for the above craft_with_message_type method
- self.assertEqual(response_message.type, TIMEOUT)
-
- response_message = ResponseMessage.craft_from_arguments(
- receiver_id=self.client_id,
- sender_id=self.server_id,
- message_type=INVALID_MESSAGE,
- message_id=uuid4(),
- )
- self.validate_response_message(response_message)
- # check message type for the above craft_with_message_type method
- self.assertEqual(response_message.type, INVALID_MESSAGE)
-
- response_message = ResponseMessage.craft_from_arguments(
- receiver_id=self.client_id,
- sender_id=self.server_id,
- message_type=ERROR,
- message_id=uuid4(),
- payload=SerializableData(Exception("test")),
- )
- self.validate_response_message(response_message)
- self.assertEqual(response_message.type, ERROR)
- self.assertIsInstance(Serializers.json.loads(response_message._bytes[2]), dict)
-
- request_message = RequestMessage.craft_from_arguments(
- sender_id=self.client_id,
- receiver_id=self.server_id,
- thing_id=self.thing_id,
- objekt="some_prop",
- operation="readProperty",
- )
- request_message._sender_id = self.client_id # will be done by craft_from_self
- response_message = ResponseMessage.craft_reply_from_request(
- request_message=request_message,
- )
- self.validate_response_message(response_message)
- self.assertEqual(response_message.type, REPLY)
- self.assertEqual(Serializers.json.loads(response_message._bytes[3]), None) # INDEX_BODY = 3
- self.assertEqual(request_message.id, response_message.id)
-
- def test_3_event_message(self):
- """test the event message"""
- event_message = EventMessage.craft_from_arguments(
- event_id="test-event",
- sender_id=self.server_id,
- payload=SerializableData("test"),
- preserialized_payload=PreserializedData(b"test"),
- )
- self.validate_event_message(event_message)
-
-
-if __name__ == "__main__":
- unittest.main(testRunner=TestRunner())
+ from conftest import AppIDs
+
+
+def validate_request_message(request_message: RequestMessage, app_ids: AppIDs) -> None:
+ """call this method to validate request message"""
+ # req. 1. check message ID is a UUID
+ assert isinstance(request_message.id, UUID) or isinstance(UUID(request_message.id, version=4), UUID)
+ # req. 2. generated byte array must confine to predefined length (which is readonly & fixed)
+ assert len(request_message.byte_array) == request_message.length
+ # req. 3. receiver which must be the server ID
+ assert request_message.receiver_id == app_ids.server_id
+ # req. 4. sender_id is the client ID
+ assert request_message.sender_id == app_ids.client_id
+ # req. 5. all indices of byte array are bytes
+ for obj in request_message.byte_array:
+ assert isinstance(obj, bytes)
+ # req. 6. check that header is correct type (RequestHeader dataclass/struct)
+ assert isinstance(request_message.header, RequestHeader)
+ # req. 7 check that body is correct type (list of SerializableData and PreserializedData)
+ assert isinstance(request_message.body, list)
+ assert len(request_message.body) == 2
+ assert isinstance(request_message.body[0], SerializableData)
+ assert isinstance(request_message.body[1], PreserializedData)
+
+
+def validate_response_message(response_message: ResponseMessage, app_ids: AppIDs) -> None:
+ """call this method to validate response message"""
+
+ # check message ID is a UUID
+ assert isinstance(response_message.id, UUID) or isinstance(UUID(response_message.id, version=4), UUID)
+ # check message length
+ assert len(response_message.byte_array) == response_message.length
+ # check receiver which must be the client
+ assert response_message.receiver_id == app_ids.client_id
+ # sender_id is not set before sending message on the socket
+ assert response_message.sender_id == app_ids.server_id
+ # check that all indices are bytes
+ for obj in response_message.byte_array:
+ assert isinstance(obj, bytes)
+ # check that header is correct type
+ assert isinstance(response_message.header, ResponseHeader)
+ # check that body is correct type
+ assert isinstance(response_message.body, list)
+ assert len(response_message.body) == 2
+ assert isinstance(response_message.body[0], SerializableData)
+ assert isinstance(response_message.body[1], PreserializedData)
+
+
+def validate_event_message(event_message: EventMessage, app_ids: AppIDs) -> None:
+ """call this method to validate event message"""
+
+ # check message ID is a UUID
+ assert isinstance(event_message.id, UUID) or isinstance(UUID(event_message.id, version=4), UUID)
+ # check message length
+ assert len(event_message.byte_array) == event_message.length
+ # no receiver id for event message, only event id
+ assert isinstance(event_message.event_id, str)
+ # sender_id is not set before sending message on the socket
+ assert event_message.sender_id == app_ids.server_id
+ # check that all indices are bytes
+ for obj in event_message.byte_array:
+ assert isinstance(obj, bytes)
+ # check that header is correct type
+ assert isinstance(event_message.header, EventHeader)
+ # check that body is correct type
+ assert isinstance(event_message.body, list)
+ assert len(event_message.body) == 2
+ assert isinstance(event_message.body[0], SerializableData)
+ assert isinstance(event_message.body[1], PreserializedData)
+
+
+def test_01_request_message(app_ids: AppIDs) -> None:
+ """test the request message"""
+
+ # request messages types are OPERATION, HANDSHAKE & EXIT
+ request_message = RequestMessage.craft_from_arguments(
+ receiver_id=app_ids.server_id,
+ sender_id=app_ids.client_id,
+ thing_id=app_ids.thing_id,
+ objekt="some_prop",
+ operation="readproperty",
+ )
+ validate_request_message(request_message, app_ids)
+ # check message type for the above craft_from_arguments method
+ assert request_message.type == OPERATION
+
+ request_message = RequestMessage.craft_with_message_type(
+ receiver_id=app_ids.server_id, sender_id=app_ids.client_id, message_type=HANDSHAKE
+ )
+ validate_request_message(request_message, app_ids)
+ # check message type for the above craft_with_message_type method
+ assert request_message.type == HANDSHAKE
+
+ request_message = RequestMessage.craft_with_message_type(
+ receiver_id=app_ids.server_id, sender_id=app_ids.client_id, message_type=EXIT
+ )
+ validate_request_message(request_message, app_ids)
+ # check message type for the above craft_with_message_type method
+ assert request_message.type == EXIT
+
+
+def test_02_response_message(app_ids: AppIDs) -> None:
+ """test the response message"""
+
+ # response messages types are HANDSHAKE, TIMEOUT, INVALID_MESSAGE, ERROR and REPLY
+ response_message = ResponseMessage.craft_from_arguments(
+ receiver_id=app_ids.client_id,
+ sender_id=app_ids.server_id,
+ message_type=HANDSHAKE,
+ message_id=uuid4(),
+ )
+ validate_response_message(response_message, app_ids)
+ # check message type for the above craft_with_message_type method
+ assert response_message.type == HANDSHAKE
+
+ response_message = ResponseMessage.craft_from_arguments(
+ receiver_id=app_ids.client_id,
+ sender_id=app_ids.server_id,
+ message_type=TIMEOUT,
+ message_id=uuid4(),
+ )
+ validate_response_message(response_message, app_ids)
+ # check message type for the above craft_with_message_type method
+ assert response_message.type == TIMEOUT
+
+ response_message = ResponseMessage.craft_from_arguments(
+ receiver_id=app_ids.client_id,
+ sender_id=app_ids.server_id,
+ message_type=INVALID_MESSAGE,
+ message_id=uuid4(),
+ )
+ validate_response_message(response_message, app_ids)
+ # check message type for the above craft_with_message_type method
+ assert response_message.type == INVALID_MESSAGE
+
+ response_message = ResponseMessage.craft_from_arguments(
+ receiver_id=app_ids.client_id,
+ sender_id=app_ids.server_id,
+ message_type=ERROR,
+ message_id=uuid4(),
+ payload=SerializableData(Exception("test")),
+ )
+ validate_response_message(response_message, app_ids)
+ assert response_message.type == ERROR
+ assert isinstance(Serializers.json.loads(response_message._bytes[2]), dict)
+
+ request_message = RequestMessage.craft_from_arguments(
+ sender_id=app_ids.client_id,
+ receiver_id=app_ids.server_id,
+ thing_id=app_ids.thing_id,
+ objekt="some_prop",
+ operation="readProperty",
+ )
+ request_message._sender_id = app_ids.client_id # will be done by craft_from_self
+ response_message = ResponseMessage.craft_reply_from_request(
+ request_message=request_message,
+ )
+ validate_response_message(response_message, app_ids)
+ assert response_message.type == REPLY
+ assert Serializers.json.loads(response_message._bytes[3]) is None # INDEX_BODY = 3
+ assert request_message.id == response_message.id
+
+
+def test_03_event_message(app_ids: AppIDs) -> None:
+ """test the event message"""
+ event_message = EventMessage.craft_from_arguments(
+ event_id="test-event",
+ sender_id=app_ids.server_id,
+ payload=SerializableData("test"),
+ preserialized_payload=PreserializedData(b"test"),
+ )
+ validate_event_message(event_message, app_ids)
diff --git a/tests/test_02_socket.py b/tests/test_02_socket.py
index 7a5c02e9..6dc21e61 100644
--- a/tests/test_02_socket.py
+++ b/tests/test_02_socket.py
@@ -1,251 +1,237 @@
-import unittest
+import pytest
import zmq.asyncio
-from hololinked.core.zmq.brokers import BaseZMQ
+from hololinked.config import global_config
from hololinked.constants import ZMQ_TRANSPORTS
+from hololinked.core.zmq.brokers import BaseZMQ
-try:
- from .utils import TestCase, TestRunner
-except ImportError:
- from utils import TestCase, TestRunner
-
-
-class TestSocket(TestCase):
- @classmethod
- def setUpClass(cls):
- super().setUpClass()
- print(f"test ZMQ socket creation with {cls.__name__}")
-
- def test_1_socket_creation_defaults(self):
- """check the default settings of socket creation - an IPC socket which is a ROUTER and async"""
- socket, socket_address = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=zmq.asyncio.Context(),
- )
- self.assertIsInstance(socket, zmq.asyncio.Socket)
- self.assertTrue(socket.getsockopt_string(zmq.IDENTITY) == "test-server")
- self.assertTrue(socket.socket_type == zmq.ROUTER)
- self.assertTrue(socket_address.startswith("ipc://"))
- self.assertTrue(socket_address.endswith(".ipc"))
- socket.close()
-
- def test_2_context_options(self):
- """
- Check that context and socket type are as expected.
- Async context should be used for async socket and sync context for sync socket.
- """
- context = zmq.Context()
- socket, _ = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- )
- self.assertTrue(isinstance(socket, zmq.Socket))
- self.assertTrue(not isinstance(socket, zmq.asyncio.Socket))
- socket.close()
- context.term()
-
- context = zmq.asyncio.Context()
- socket, _ = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- )
- self.assertTrue(isinstance(socket, zmq.Socket))
- self.assertTrue(isinstance(socket, zmq.asyncio.Socket))
- socket.close()
- context.term()
-
- def test_3_transport_options(self):
- """check only three transport options are supported"""
- context = zmq.asyncio.Context()
- socket, socket_address = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- access_point="tcp://*:5555",
- )
- for sock_addr in [socket_address, socket.getsockopt_string(zmq.LAST_ENDPOINT)]:
- self.assertTrue(sock_addr.startswith("tcp://"))
- self.assertTrue(sock_addr.endswith(":5555"))
- socket.close()
-
- socket, socket_address = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- access_point="IPC",
- )
-
- self.assertEqual(socket_address, socket.getsockopt_string(zmq.LAST_ENDPOINT))
- self.assertTrue(socket_address.startswith("ipc://"))
- self.assertTrue(socket_address.endswith(".ipc"))
- socket.close()
-
- socket, socket_address = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- access_point="INPROC",
- )
- self.assertEqual(socket_address, socket.getsockopt_string(zmq.LAST_ENDPOINT))
- self.assertTrue(socket_address.startswith("inproc://"))
- self.assertTrue(socket_address.endswith("test-server"))
- socket.close()
- context.term()
-
- # Specify transport as enum and do the same tests
- context = zmq.Context()
- socket, socket_address = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- access_point=ZMQ_TRANSPORTS.INPROC,
- )
- self.assertTrue(socket_address.startswith("inproc://"))
- self.assertTrue(socket_address.endswith("test-server"))
- socket.close()
-
- socket, socket_address = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- access_point=ZMQ_TRANSPORTS.IPC,
- )
- self.assertTrue(socket_address.startswith("ipc://"))
- self.assertTrue(socket_address.endswith(".ipc"))
- socket.close()
-
- socket, socket_address = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- access_point=ZMQ_TRANSPORTS.TCP,
- )
- self.assertTrue(socket_address.startswith("tcp://"))
- # Strip the port number from TCP address and check if it's a valid port integer
- host, port_str = socket_address.rsplit(":", 1)
- self.assertTrue(port_str.isdigit())
- self.assertTrue(0 < int(port_str) < 65536)
- socket.close()
- context.term()
-
- # check that other transport options raise error
- context = zmq.asyncio.Context()
- self.assertRaises(
- NotImplementedError,
- lambda: BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- access_point="PUB",
- ),
- )
- context.term()
-
- def test_4_socket_options(self):
- """check that socket options are as expected"""
- context = zmq.asyncio.Context()
-
- socket, _ = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- socket_type=zmq.ROUTER,
- )
- self.assertTrue(socket.socket_type == zmq.ROUTER)
- self.assertTrue(socket.getsockopt_string(zmq.IDENTITY) == "test-server")
- self.assertTrue(isinstance(socket, zmq.asyncio.Socket))
- socket.close()
-
- socket, _ = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- socket_type=zmq.DEALER,
- )
- self.assertTrue(socket.socket_type == zmq.DEALER)
- self.assertTrue(socket.getsockopt_string(zmq.IDENTITY) == "test-server")
- self.assertTrue(isinstance(socket, zmq.asyncio.Socket))
- socket.close()
-
- socket, _ = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- socket_type=zmq.PUB,
- )
- self.assertTrue(socket.socket_type == zmq.PUB)
- self.assertTrue(socket.getsockopt_string(zmq.IDENTITY) == "test-server")
- self.assertTrue(isinstance(socket, zmq.asyncio.Socket))
- socket.close()
-
- socket, _ = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- socket_type=zmq.SUB,
- )
- self.assertTrue(socket.socket_type == zmq.SUB)
- self.assertTrue(socket.getsockopt_string(zmq.IDENTITY) == "test-server")
- self.assertTrue(isinstance(socket, zmq.asyncio.Socket))
- socket.close()
-
- socket, _ = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- socket_type=zmq.PAIR,
- )
- self.assertTrue(socket.socket_type == zmq.PAIR)
- self.assertTrue(socket.getsockopt_string(zmq.IDENTITY) == "test-server")
- self.assertTrue(isinstance(socket, zmq.asyncio.Socket))
- socket.close()
-
- socket, _ = BaseZMQ.get_socket(
- server_id="test-server",
- socket_id="test-server",
- node_type="server",
- context=context,
- socket_type=zmq.PUSH,
- )
- self.assertTrue(socket.socket_type == zmq.PUSH)
- self.assertTrue(socket.getsockopt_string(zmq.IDENTITY) == "test-server")
- self.assertTrue(isinstance(socket, zmq.asyncio.Socket))
- socket.close()
- socket, _ = BaseZMQ.get_socket(
+def test_01_socket_creation_defaults():
+ """check the default settings of socket creation - an IPC socket which is a ROUTER and async"""
+ socket, socket_address = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=global_config.zmq_context(),
+ )
+ assert isinstance(socket, zmq.asyncio.Socket)
+ assert socket.getsockopt_string(zmq.IDENTITY) == "test-server"
+ assert socket.socket_type == zmq.ROUTER
+ assert socket_address.startswith("ipc://")
+ assert socket_address.endswith(".ipc")
+ socket.close()
+
+
+def test_02_context_options():
+ """
+ Check that context and socket type are as expected.
+ Async context should be used for async socket and sync context for sync socket.
+ """
+ context = zmq.Context()
+ socket, _ = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ )
+ assert isinstance(socket, zmq.Socket)
+ assert not isinstance(socket, zmq.asyncio.Socket)
+ socket.close()
+ context.term()
+
+ context = zmq.asyncio.Context()
+ socket, _ = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ )
+ assert isinstance(socket, zmq.Socket)
+ assert isinstance(socket, zmq.asyncio.Socket)
+ socket.close()
+ context.term()
+
+
+def test_03_transport_options():
+ """check only three transport options are supported"""
+ context = zmq.asyncio.Context()
+ socket, socket_address = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ access_point="tcp://*:5555",
+ )
+ for sock_addr in [socket_address, socket.getsockopt_string(zmq.LAST_ENDPOINT)]:
+ assert sock_addr.startswith("tcp://")
+ assert sock_addr.endswith(":5555")
+ socket.close()
+
+ socket, socket_address = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ access_point="IPC",
+ )
+
+ assert socket_address == socket.getsockopt_string(zmq.LAST_ENDPOINT)
+ assert socket_address.startswith("ipc://")
+ assert socket_address.endswith(".ipc")
+ socket.close()
+
+ socket, socket_address = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ access_point="INPROC",
+ )
+ assert socket_address == socket.getsockopt_string(zmq.LAST_ENDPOINT)
+ assert socket_address.startswith("inproc://")
+ assert socket_address.endswith("test-server")
+ socket.close()
+ context.term()
+
+ # Specify transport as enum and do the same tests
+ context = zmq.Context()
+ socket, socket_address = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ access_point=ZMQ_TRANSPORTS.INPROC,
+ )
+ assert socket_address.startswith("inproc://")
+ assert socket_address.endswith("test-server")
+ socket.close()
+
+ socket, socket_address = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ access_point=ZMQ_TRANSPORTS.IPC,
+ )
+ assert socket_address.startswith("ipc://")
+ assert socket_address.endswith(".ipc")
+ socket.close()
+
+ socket, socket_address = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ access_point=ZMQ_TRANSPORTS.TCP,
+ )
+ assert socket_address.startswith("tcp://")
+ # Strip the port number from TCP address and check if it's a valid port integer
+ host, port_str = socket_address.rsplit(":", 1)
+ assert port_str.isdigit()
+ assert 0 < int(port_str) < 65536
+ socket.close()
+ context.term()
+
+ # check that other transport options raise error
+ context = zmq.asyncio.Context()
+ with pytest.raises(NotImplementedError):
+ BaseZMQ.get_socket(
server_id="test-server",
socket_id="test-server",
node_type="server",
context=context,
- socket_type=zmq.PULL,
- )
- self.assertTrue(socket.socket_type == zmq.PULL)
- self.assertTrue(socket.getsockopt_string(zmq.IDENTITY) == "test-server")
- self.assertTrue(isinstance(socket, zmq.asyncio.Socket))
- socket.close()
- context.term()
-
-
-if __name__ == "__main__":
- unittest.main(testRunner=TestRunner())
+ access_point="PUB",
+ )
+
+
+def test_04_socket_options():
+ """check that socket options are as expected"""
+ context = zmq.asyncio.Context()
+
+ socket, _ = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ socket_type=zmq.ROUTER,
+ )
+ assert socket.socket_type == zmq.ROUTER
+ assert socket.getsockopt_string(zmq.IDENTITY) == "test-server"
+ assert isinstance(socket, zmq.asyncio.Socket)
+ socket.close()
+
+ socket, _ = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ socket_type=zmq.DEALER,
+ )
+ assert socket.socket_type == zmq.DEALER
+ assert socket.getsockopt_string(zmq.IDENTITY) == "test-server"
+ assert isinstance(socket, zmq.asyncio.Socket)
+ socket.close()
+
+ socket, _ = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ socket_type=zmq.PUB,
+ )
+ assert socket.socket_type == zmq.PUB
+ assert socket.getsockopt_string(zmq.IDENTITY) == "test-server"
+ assert isinstance(socket, zmq.asyncio.Socket)
+ socket.close()
+
+ socket, _ = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ socket_type=zmq.SUB,
+ )
+ assert socket.socket_type == zmq.SUB
+ assert socket.getsockopt_string(zmq.IDENTITY) == "test-server"
+ assert isinstance(socket, zmq.asyncio.Socket)
+ socket.close()
+
+ socket, _ = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ socket_type=zmq.PAIR,
+ )
+ assert socket.socket_type == zmq.PAIR
+ assert socket.getsockopt_string(zmq.IDENTITY) == "test-server"
+ assert isinstance(socket, zmq.asyncio.Socket)
+ socket.close()
+
+ socket, _ = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ socket_type=zmq.PUSH,
+ )
+ assert socket.socket_type == zmq.PUSH
+ assert socket.getsockopt_string(zmq.IDENTITY) == "test-server"
+ assert isinstance(socket, zmq.asyncio.Socket)
+ socket.close()
+
+ socket, _ = BaseZMQ.get_socket(
+ server_id="test-server",
+ socket_id="test-server",
+ node_type="server",
+ context=context,
+ socket_type=zmq.PULL,
+ )
+ assert socket.socket_type == zmq.PULL
+ assert socket.getsockopt_string(zmq.IDENTITY) == "test-server"
+ assert isinstance(socket, zmq.asyncio.Socket)
+ socket.close()
+ context.term()
"""
diff --git a/tests/test_03_serializers.py b/tests/test_03_serializers.py
index 0ff24a96..bbaf350c 100644
--- a/tests/test_03_serializers.py
+++ b/tests/test_03_serializers.py
@@ -1,182 +1,145 @@
-import unittest
+import pytest
+
+from things import TestThing
from hololinked.serializers import Serializers
from hololinked.serializers.serializers import BaseSerializer
-try:
- from .utils import TestRunner, TestCase
- from .things import TestThing
-except ImportError:
- from utils import TestRunner, TestCase
- from things import TestThing
+class YAMLSerializer(BaseSerializer):
+ """just a dummy, does not really serialize to YAML"""
+
+ @property
+ def content_type(self):
+ return "application/yaml"
-class TestSerializer(TestCase):
- """Test the Serializers class"""
+@pytest.fixture(scope="module")
+def yaml_serializer() -> BaseSerializer:
# test register a new serializer with content type
- class YAMLSerializer(BaseSerializer):
- """just a dummy, does not really serialize to YAML"""
-
- @property
- def content_type(self):
- return "application/yaml"
-
- def test_1_singleton(self):
- """Test the singleton nature of the Serializers class."""
-
- serializers = Serializers()
- self.assertEqual(serializers, Serializers())
- self.assertNotEqual(Serializers, Serializers())
- self.assertIsInstance(serializers, Serializers)
- # all are class attributes
- self.assertEqual(serializers.json, Serializers.json)
- self.assertEqual(serializers.pickle, Serializers.pickle)
- self.assertEqual(serializers.msgpack, Serializers.msgpack)
- self.assertEqual(serializers.content_types, Serializers.content_types)
- self.assertEqual(serializers.object_content_type_map, Serializers.object_content_type_map)
- self.assertEqual(serializers.object_serializer_map, Serializers.object_serializer_map)
- self.assertEqual(serializers.protocol_serializer_map, Serializers.protocol_serializer_map)
- # check existing serializers are all instances of BaseSerializer
- for name, serializer in Serializers.content_types.items():
- self.assertIsInstance(serializer, BaseSerializer)
- # check default serializer, given that we know its JSON at least for the current test
- self.assertEqual(serializers.default, Serializers.json)
- self.assertEqual(serializers.default, Serializers.default)
- self.assertEqual(serializers.default, Serializers().json)
- self.assertEqual(serializers.default, Serializers().default)
- # check default content type, given that we know its JSON at least for the current test
- self.assertEqual(serializers.default_content_type, Serializers.json.content_type)
- # change default to pickle and check if it is set correctly
- # serializers.default = serializers.pickle
- # self.assertEqual(serializers.default, Serializers.pickle)
- # self.assertEqual(Serializers().default, Serializers.pickle)
-
- def test_2_protocol_registration(self):
- """i.e. test if a new serializer (protocol) can be registered"""
-
- # get existing number of serializers
- num_serializers = len(Serializers.content_types)
-
- # test register a new serializer
- base_serializer = BaseSerializer()
- # register with name
- self.assertWarns(UserWarning, Serializers.register, base_serializer, "base")
- # user warning because content type property is not defined
- # above is same as Serializers.register(base_serializer, 'base')
-
- # check if name became a class attribute and name can be accessed as an attribute
- self.assertIn("base", Serializers)
- self.assertEqual(Serializers.base, base_serializer)
- self.assertEqual(Serializers().base, base_serializer)
- # we dont support getitem at instance level yet so we cannot test assertIn
-
- # since a content type is not set, it should not be in the content types
- self.assertNotIn(base_serializer, Serializers.content_types.values())
- # so the length of content types should be the same
- self.assertEqual(len(Serializers.content_types), num_serializers)
-
- # instantiate
- yaml_serializer = self.YAMLSerializer()
- # register with name
- Serializers.register(yaml_serializer, "yaml")
- # check if name became a class attribute and name can be accessed as an attribute
- self.assertIn("yaml", Serializers)
- self.assertEqual(Serializers.yaml, yaml_serializer)
- self.assertEqual(Serializers().yaml, yaml_serializer)
- # we dont support getitem at instance level yet
-
- # since a content type is set, it should be in the content types
- self.assertIn(yaml_serializer.content_type, Serializers.content_types.keys())
- self.assertIn(yaml_serializer, Serializers.content_types.values())
- # so the length of content types should have increased by 1
- self.assertEqual(len(Serializers.content_types), num_serializers + 1)
-
- def test_3_registration_for_objects(self):
- """i.e. test if a new serializer can be registered for a specific property, action or event"""
- Serializers.register_content_type_for_object(TestThing.base_property, "application/x-pickle")
- Serializers.register_content_type_for_object(TestThing.action_echo, "application/msgpack")
- Serializers.register_content_type_for_object(TestThing.test_event, "application/yaml")
-
- self.assertEqual(
- Serializers.for_object(None, "TestThing", "action_echo"),
- Serializers.msgpack,
- )
- self.assertEqual(
- Serializers.for_object(None, "TestThing", "base_property"),
- Serializers.pickle,
- )
- self.assertEqual(Serializers.for_object(None, "TestThing", "test_event"), Serializers.yaml)
- self.assertEqual(
- Serializers.for_object(None, "TestThing", "test_unknown_property"),
- Serializers.default,
- )
-
- def test_4_registration_for_objects_by_name(self):
- Serializers.register_content_type_for_object_per_thing_instance(
- "test_thing", "base_property", "application/yaml"
- )
- self.assertIsInstance(
- Serializers.for_object("test_thing", None, "base_property"),
- self.YAMLSerializer,
- )
-
- def test_5_registration_dict(self):
- """test the dictionary where all serializers are stored"""
- # depends on test 3
- self.assertIn("test_thing", Serializers.object_content_type_map)
- self.assertIn("base_property", Serializers.object_content_type_map["test_thing"])
- self.assertEqual(
- Serializers.object_content_type_map["test_thing"]["base_property"],
- "application/yaml",
- )
-
- self.assertIn("action_echo", Serializers.object_content_type_map["TestThing"])
- self.assertEqual(
- Serializers.object_content_type_map["TestThing"]["action_echo"],
- "application/msgpack",
- )
- self.assertIn("test_event", Serializers.object_content_type_map["TestThing"])
- self.assertEqual(
- Serializers.object_content_type_map["TestThing"]["test_event"],
- "application/yaml",
- )
-
- def test_6_retrieval(self):
- # added in previous tests
- self.assertIsInstance(
- Serializers.for_object("test_thing", None, "base_property"),
- self.YAMLSerializer,
- )
- # unknown object should retrieve the default serializer
- self.assertEqual(
- Serializers.for_object("test_thing", None, "test_unknown_property"),
- Serializers.default,
- )
- # unknown thing should retrieve the default serializer
- self.assertEqual(
- Serializers.for_object("test_unknown_thing", None, "base_property"),
- Serializers.default,
- )
-
- def test_7_set_default(self):
- """test setting the default serializer"""
- # get existing default
- old_default = Serializers.default
- # set new default and check if default is set
- Serializers.default = Serializers.yaml
- self.assertEqual(Serializers.default, Serializers.yaml)
- self.test_6_retrieval() # check if retrieval is consistent with default
- # reset default and check if default is reset
- Serializers.default = old_default
- self.assertEqual(Serializers.default, old_default)
- self.assertEqual(Serializers.default, Serializers.json) # because we know its JSON
-
- @classmethod
- def tearDownClass(cls):
- Serializers.reset()
- return super().tearDownClass()
-
-
-if __name__ == "__main__":
- unittest.main(testRunner=TestRunner())
+ return YAMLSerializer()
+
+
+def test_01_singleton():
+ """Test the singleton nature of the Serializers class."""
+
+ serializers = Serializers()
+ assert serializers == Serializers()
+ assert Serializers != Serializers()
+ assert isinstance(serializers, Serializers)
+ # all are class attributes
+ assert serializers.json == Serializers.json
+ assert serializers.pickle == Serializers.pickle
+ assert serializers.msgpack == Serializers.msgpack
+ assert serializers.content_types == Serializers.content_types
+ assert serializers.object_content_type_map == Serializers.object_content_type_map
+ assert serializers.object_serializer_map == Serializers.object_serializer_map
+ assert serializers.protocol_serializer_map == Serializers.protocol_serializer_map
+ # check existing serializers are all instances of BaseSerializer
+ for name, serializer in Serializers.content_types.items():
+ assert isinstance(serializer, BaseSerializer)
+ # check default serializer, given that we know its JSON at least for the current test
+ assert serializers.default == Serializers.json
+ assert serializers.default == Serializers.default
+ assert serializers.default == Serializers().json
+ assert serializers.default == Serializers().default
+ # check default content type, given that we know its JSON at least for the current test
+ assert serializers.default_content_type == Serializers.json.content_type
+ # change default to pickle and check if it is set correctly
+ # serializers.default = serializers.pickle
+ # self.assertEqual(serializers.default, Serializers.pickle)
+ # self.assertEqual(Serializers().default, Serializers.pickle)
+
+
+def test_02_protocol_registration(yaml_serializer: BaseSerializer):
+ """i.e. test if a new serializer (protocol) can be registered"""
+
+ # get existing number of serializers
+ num_serializers = len(Serializers.content_types)
+
+ # test register a new serializer
+ base_serializer = BaseSerializer()
+ # register with name
+ with pytest.warns(UserWarning):
+ Serializers.register(base_serializer, "base")
+ # user warning because content type property is not defined
+ # above is same as Serializers.register(base_serializer, 'base')
+
+ # check if name became a class attribute and name can be accessed as an attribute
+ assert "base" in Serializers
+ assert Serializers.base == base_serializer
+ assert Serializers().base == base_serializer
+ # we dont support getitem at instance level yet so we cannot test assertIn
+
+ # since a content type is not set, it should not be in the content types
+ assert base_serializer not in Serializers.content_types.values()
+ # so the length of content types should be the same
+ assert len(Serializers.content_types) == num_serializers
+
+ # register with name
+ Serializers.register(yaml_serializer, "yaml")
+ # check if name became a class attribute and name can be accessed as an attribute
+ assert "yaml" in Serializers
+ assert Serializers.yaml == yaml_serializer
+ assert Serializers().yaml == yaml_serializer
+ # we dont support getitem at instance level yet
+
+ # since a content type is set, it should be in the content types
+ assert yaml_serializer.content_type in Serializers.content_types.keys()
+ assert yaml_serializer in Serializers.content_types.values()
+ # so the length of content types should have increased by 1
+ assert len(Serializers.content_types) == num_serializers + 1
+
+
+def test_03_registration_for_objects():
+ """i.e. test if a new serializer can be registered for a specific property, action or event"""
+ Serializers.register_content_type_for_object(TestThing.base_property, "application/x-pickle")
+ Serializers.register_content_type_for_object(TestThing.action_echo, "application/msgpack")
+ Serializers.register_content_type_for_object(TestThing.test_event, "application/yaml")
+
+ assert Serializers.for_object(None, "TestThing", "action_echo") == Serializers.msgpack
+ assert Serializers.for_object(None, "TestThing", "base_property") == Serializers.pickle
+ assert Serializers.for_object(None, "TestThing", "test_event") == Serializers.yaml
+ assert Serializers.for_object(None, "TestThing", "test_unknown_property") == Serializers.default
+
+
+def test_04_registration_for_objects_by_name():
+ Serializers.register_content_type_for_object_per_thing_instance("test_thing", "base_property", "application/yaml")
+ assert isinstance(Serializers.for_object("test_thing", None, "base_property"), YAMLSerializer)
+
+
+def test_05_registration_dict():
+ """test the dictionary where all serializers are stored"""
+ # depends on test 3
+ assert "test_thing" in Serializers.object_content_type_map
+ assert "base_property" in Serializers.object_content_type_map["test_thing"]
+ assert Serializers.object_content_type_map["test_thing"]["base_property"] == "application/yaml"
+ assert Serializers.object_content_type_map["test_thing"]["base_property"] == "application/yaml"
+
+ assert "action_echo" in Serializers.object_content_type_map["TestThing"]
+ assert Serializers.object_content_type_map["TestThing"]["action_echo"] == "application/msgpack"
+ assert "test_event" in Serializers.object_content_type_map["TestThing"]
+ assert Serializers.object_content_type_map["TestThing"]["test_event"] == "application/yaml"
+
+
+def test_06_retrieval():
+ # added in previous tests
+ assert isinstance(Serializers.for_object("test_thing", None, "base_property"), YAMLSerializer)
+ # unknown object should retrieve the default serializer
+ assert Serializers.for_object("test_thing", None, "test_unknown_property") == Serializers.default
+ # unknown thing should retrieve the default serializer
+ assert Serializers.for_object("test_unknown_thing", None, "base_property") == Serializers.default
+
+
+def test_07_set_default():
+ """test setting the default serializer"""
+ # get existing default
+ old_default = Serializers.default
+ # set new default and check if default is set
+ Serializers.default = Serializers.yaml
+ assert Serializers.default == Serializers.yaml
+ test_06_retrieval() # check if retrieval is consistent with default
+ # reset default and check if default is reset
+ Serializers.default = old_default
+ assert Serializers.default == old_default
+ assert Serializers.default == Serializers.json # because we know its JSON
diff --git a/tests/test_04_thing_init.py b/tests/test_04_thing_init.py
index 7cbb6ab9..460dfb36 100644
--- a/tests/test_04_thing_init.py
+++ b/tests/test_04_thing_init.py
@@ -1,30 +1,24 @@
-import typing
-import unittest
-import logging
+from typing import Any
+import pytest
+
+from things import OceanOpticsSpectrometer
+
+from hololinked.core import Action, Event, Property, Thing, ThingMeta
from hololinked.core.actions import BoundAction
from hololinked.core.events import EventDispatcher
-from hololinked.core.zmq.brokers import EventPublisher
-from hololinked.core.zmq.rpc_server import RPCServer
-from hololinked.core import Thing, ThingMeta, Action, Event, Property
+from hololinked.core.logger import RemoteAccessHandler
from hololinked.core.meta import (
- DescriptorRegistry, # noqa: F401
- PropertiesRegistry,
ActionsRegistry,
+ DescriptorRegistry, # noqa: F401
EventsRegistry,
+ PropertiesRegistry,
)
-from hololinked.core.properties import Parameter
+from hololinked.core.properties import Parameter # noqa: F401
from hololinked.core.state_machine import BoundFSM
+from hololinked.core.zmq.brokers import EventPublisher
+from hololinked.core.zmq.rpc_server import RPCServer
from hololinked.utils import get_default_logger
-from hololinked.core.logger import RemoteAccessHandler
-from hololinked.logger import setup_logging
-
-try:
- from .things import OceanOpticsSpectrometer
- from .utils import TestCase, TestRunner
-except ImportError:
- from things import OceanOpticsSpectrometer
- from utils import TestCase, TestRunner
"""
@@ -35,789 +29,694 @@
4. Test ActionRegistry class
5. Test EventRegistry class
6. Test PropertiesRegistry class
-"""
-setup_logging(logging.WARN)
-
-
-class TestThingInit(TestCase):
- """Test Thing class which is the bread and butter of this package."""
-
- @classmethod
- def setUpClass(cls):
- super().setUpClass()
- print(f"test Thing instantiation with {cls.__name__}")
- cls.thing_cls = Thing
- # using a variable called thing_cls because same tests are repeated for different thing class
-
- """
- Test sequence is as follows:
- 1. Test id requirements
- 2. Test logger setup
- 3. Test state and state_machine setup
- 4. Test composition of subthings
- 5. Test servers init
- 6. Test thing model generation
- """
-
- def test_1_id(self):
- """Test id property of Thing class"""
- # req. 1. instance name must be a string and cannot be changed after set
- thing = self.thing_cls(id="test_id")
- self.assertEqual(thing.id, "test_id")
- with self.assertRaises(ValueError):
- thing.id = "new_instance"
- with self.assertRaises(NotImplementedError):
- del thing.id
- # req. 2. regex is r'[A-Za-z]+[A-Za-z_0-9\-\/]*', simple URI like
- valid_ids = ["test_id", "A123", "valid_id-123", "another/valid-id"]
- invalid_ids = ["123_invalid", "invalid id", "invalid@id", ""]
- for valid_id in valid_ids:
- thing.properties.descriptors["id"].validate_and_adapt(valid_id)
- for invalid_id in invalid_ids:
- with self.assertRaises(ValueError):
- thing.properties.descriptors["id"].validate_and_adapt(invalid_id)
-
- def notest_2_logger(self):
- """Test logger setup"""
- # This test will no longer work and needs to rewritten
- # req. 1. logger must have remote access handler if remote_accessible_logger is True
- logger = get_default_logger("test_logger")
- thing = self.thing_cls(
- id="test_remote_accessible_logger",
- logger=logger,
- remote_accessible_logger=True,
- )
- self.assertEqual(thing.logger, logger)
- self.assertTrue(any(isinstance(handler, RemoteAccessHandler) for handler in thing.logger.handlers))
- # Therefore also check the false condition
- logger = get_default_logger("test_logger_2")
- thing = self.thing_cls(
- id="test_logger_without_remote_access",
- logger=logger,
- remote_accessible_logger=False,
- )
- self.assertFalse(any(isinstance(handler, RemoteAccessHandler) for handler in thing.logger.handlers))
- # NOTE - logger is modifiable after instantiation
-
- # req. 2. logger is created automatically if not provided
- thing = self.thing_cls(id="test_logger_auto_creation")
- self.assertIsNotNone(thing.logger)
- self.assertFalse(any(isinstance(handler, RemoteAccessHandler) for handler in thing.logger.handlers))
- self.assertNotEqual(thing.logger, logger) # not the above logger that we used.
- # remote accessible only when we ask for it
- thing = self.thing_cls(id="test_logger_auto_creation_2", remote_accessible_logger=True)
- self.assertIsNotNone(thing.logger)
- self.assertTrue(any(isinstance(handler, RemoteAccessHandler) for handler in thing.logger.handlers))
- self.assertNotEqual(thing.logger, logger)
-
- def test_3_state(self):
- """Test state and state_machine setup"""
- # req. 1. state property must be None when no state machine is present
- thing1 = self.thing_cls(id="test_no_state_machine")
- self.assertIsNone(thing1.state)
- self.assertIsNone(thing1.state_machine)
- # detailed checks in another file
-
- def test_4_subthings(self):
- """Test composition"""
- thing = self.thing_cls(id="test_subthings", remote_accessible_logger=True)
- # req. 1. subthings must be a dictionary
- self.assertIsInstance(thing.sub_things, dict)
- self.assertEqual(len(thing.sub_things), 1) # logger
- # req. 2. subthings are always recomputed when accessed (at least thats the way it is right now),
- # so we can add new subthings anytime
- thing.another_thing = OceanOpticsSpectrometer(id="another_thing")
- self.assertIsInstance(thing.sub_things, dict)
- self.assertEqual(len(thing.sub_things), 2)
- # req. 3. subthings must be instances of Thing and have the parent as owner
- for name, subthing in thing.sub_things.items():
- self.assertTrue(thing in subthing._owners)
- self.assertIsInstance(subthing, Thing)
- # req. 4. name of subthing must match name of the attribute
- self.assertTrue(hasattr(thing, name))
-
- def test_5_servers_init(self):
- """Test if servers can be initialized/instantiated"""
- # req. 1. rpc_server and event_publisher must be None when not run()
- thing = self.thing_cls(id="test_servers_init")
- self.assertIsNone(thing.rpc_server)
- self.assertIsNone(thing.event_publisher)
- # req. 2. rpc_server and event_publisher must be instances of their respective classes when run()
- RPCServer(id="test-rpc-server-init", things=[thing], logger=thing.logger) # prepare server class
- self.assertIsInstance(thing.rpc_server, RPCServer)
- self.assertIsInstance(thing.event_publisher, EventPublisher)
- # exit to quit nicely
- thing.rpc_server.exit()
- thing.event_publisher.exit()
-
-
-class TestOceanOpticsSpectrometer(TestThingInit):
- """test Thing subclass example"""
-
- @classmethod
- def setUpClass(cls):
- super().setUpClass()
- cls.thing_cls = OceanOpticsSpectrometer
-
- # check docs of the parent class for the test sequence
-
- def test_3_state(self):
- """Test state and state_machine setup"""
- thing1 = self.thing_cls(id="test_state_machine")
- # req. 1. state and state machine must be present because we create this subclass with a state machine
- self.assertIsNotNone(thing1.state)
- self.assertIsInstance(thing1.state_machine, BoundFSM)
- # req. 2. state and state machine must be different for different instances
- thing2 = self.thing_cls(id="test_state_machine_2")
- # first check if state machine exists
- self.assertIsNotNone(thing2.state)
- self.assertIsInstance(thing2.state_machine, BoundFSM)
- # then check if they are different
- self.assertNotEqual(thing1.state_machine, thing2.state_machine)
- # until state is set, initial state is equal
- self.assertEqual(thing1.state, thing2.state)
- self.assertEqual(thing1.state_machine.initial_state, thing2.state_machine.initial_state)
- # after state is set, they are different
- thing1.state_machine.set_state(thing1.states.ALARM)
- self.assertNotEqual(thing1.state, thing2.state)
- self.assertNotEqual(thing1.state_machine, thing2.state_machine)
- # initial state is still same
- self.assertEqual(thing1.state_machine.initial_state, thing2.state_machine.initial_state)
-
-
-class TestMetaclass(TestCase):
- """Test ThingMeta metaclass which instantiates a Thing (sub-)class"""
-
- @classmethod
- def setUpClass(cls):
- super().setUpClass()
- print(f"test ThingMeta with {cls.__name__}")
-
- """
- Test sequence is as follows:
- 1. Test metaclass of Thing class
- 2. Test registry creation and access which is currently the main purpose of the metaclass
- """
-
- def test_1_metaclass(self):
- """test metaclass of Thing class"""
- # req. 1 metaclass must be ThingMeta of any Thing class
- self.assertEqual(Thing.__class__, ThingMeta)
- self.assertEqual(OceanOpticsSpectrometer.__class__, ThingMeta)
- self.assertEqual(Thing.__class__, OceanOpticsSpectrometer.__class__)
-
- def test_2_registry_creation(self):
- """test registry creation and access which is currently the main purpose of the metaclass"""
- # req. 1. registry attributes must be instances of their respective classes
- self.assertIsInstance(Thing.properties, PropertiesRegistry)
- self.assertIsInstance(Thing.actions, ActionsRegistry)
- self.assertIsInstance(Thing.events, EventsRegistry)
-
- # req. 2. new registries are not created on the fly and are same between accesses
- self.assertEqual(Thing.properties, Thing.properties)
- self.assertEqual(Thing.actions, Thing.actions)
- self.assertEqual(Thing.events, Thing.events)
- # This test is done as the implementation deviates from `param`
-
- # req. 3. different subclasses have different registries
- self.assertNotEqual(Thing.properties, OceanOpticsSpectrometer.properties)
- self.assertNotEqual(Thing.actions, OceanOpticsSpectrometer.actions)
- self.assertNotEqual(Thing.events, OceanOpticsSpectrometer.events)
-
- # create instances for further tests
- thing = Thing(id="test_registry_creation")
- spectrometer = OceanOpticsSpectrometer(id="test_registry_creation_2")
-
- # req. 4. registry attributes must be instances of their respective classes also for instances
- self.assertIsInstance(thing.properties, PropertiesRegistry)
- self.assertIsInstance(thing.actions, ActionsRegistry)
- self.assertIsInstance(thing.events, EventsRegistry)
-
- # req. 5. registries are not created on the fly and are same between accesses also for instances
- self.assertEqual(thing.properties, thing.properties)
- self.assertEqual(thing.actions, thing.actions)
- self.assertEqual(thing.events, thing.events)
-
- # req. 6. registries are not shared between instances
- self.assertNotEqual(thing.properties, spectrometer.properties)
- self.assertNotEqual(thing.actions, spectrometer.actions)
- self.assertNotEqual(thing.events, spectrometer.events)
-
- # req. 7. registries are not shared between instances and their classes
- self.assertNotEqual(thing.properties, Thing.properties)
- self.assertNotEqual(thing.actions, Thing.actions)
- self.assertNotEqual(thing.events, Thing.events)
- self.assertNotEqual(spectrometer.properties, OceanOpticsSpectrometer.properties)
- self.assertNotEqual(spectrometer.actions, OceanOpticsSpectrometer.actions)
- self.assertNotEqual(spectrometer.events, OceanOpticsSpectrometer.events)
-
-
-# Uncomment the following for type hints while coding registry tests,
-# comment it before testing, otherwise tests will fail due to overriding Thing object
-# class Thing(Thing):
-# class_registry: PropertiesRegistry | ActionsRegistry | EventsRegistry
-# instance_registry: PropertiesRegistry | ActionsRegistry | EventsRegistry | None
-# descriptor_object: type[Property | Action | Event]
-
-# class OceanOpticsSpectrometer(OceanOpticsSpectrometer):
-# class_registry: PropertiesRegistry | ActionsRegistry | EventsRegistry
-# instance_registry: PropertiesRegistry | ActionsRegistry | EventsRegistry | None
-# descriptor_object: type[Property | Action | Event]
-
-
-class TestRegistry(TestCase):
- # Read the commented section above before proceeding to this test
-
- @classmethod
- def setUpClass(cls):
- super().setUpClass()
- cls.setUpRegistryObjects()
- cls.setUpRegistryAttributes()
- if cls.is_abstract_test_class:
- return
- print(f"test {cls.registry_cls.__name__} with {cls.__name__}")
-
- @classmethod
- def setUpRegistryObjects(cls):
- cls.registry_cls = None # type: DescriptorRegistry | None
- cls.registry_object = None # type: type[Property | Action | Event]
-
- @property
- def is_abstract_test_class(self):
- # if self.registry_cls is None:
- # print("registry_cls is None")
- # if self.registry_object is None:
- # print("registry_object is None")
- return self.registry_cls is None or self.registry_object is None
-
- @classmethod
- def setUpRegistryAttributes(cls):
- if cls.registry_cls is None or cls.registry_object is None:
- return
-
- # create instances for further tests
- cls.thing = Thing(id=f"test_{cls.registry_object.__name__}_registry")
- cls.spectrometer = OceanOpticsSpectrometer(id=f"test_{cls.registry_object.__name__}_registry")
- if cls.registry_cls == ActionsRegistry:
- Thing.class_registry = Thing.actions
- OceanOpticsSpectrometer.class_registry = OceanOpticsSpectrometer.actions
- cls.thing.instance_registry = cls.thing.actions
- cls.spectrometer.instance_registry = cls.spectrometer.actions
- cls.bound_object = BoundAction
- elif cls.registry_cls == PropertiesRegistry:
- Thing.class_registry = Thing.properties
- OceanOpticsSpectrometer.class_registry = OceanOpticsSpectrometer.properties
- cls.thing.instance_registry = cls.thing.properties
- cls.spectrometer.instance_registry = cls.spectrometer.properties
- cls.bound_object = typing.Any
- elif cls.registry_cls == EventsRegistry:
- Thing.class_registry = Thing.events
- OceanOpticsSpectrometer.class_registry = OceanOpticsSpectrometer.events
- cls.thing.instance_registry = cls.thing.events
- cls.spectrometer.instance_registry = cls.spectrometer.events
- cls.bound_object = EventDispatcher
- else:
- raise NotImplementedError("This registry class is not implemented")
-
- """
- Test action registry first because actions are the easiest to test.
- 1. Test owner attribute
- 2. Test descriptors access
- 3. Test dunders
- """
-
- def test_1_owner(self):
- """Test owner attribute of DescriptorRegistry"""
- if self.is_abstract_test_class:
- return
- # See comment above TestRegistry class to enable type definitions
- # req. 1. owner attribute must be the class itself when accessed as class attribute
- self.assertEqual(Thing.class_registry.owner, Thing)
- self.assertEqual(OceanOpticsSpectrometer.class_registry.owner, OceanOpticsSpectrometer)
- # therefore owner instance must be None
- self.assertIsNone(Thing.class_registry.owner_inst)
- self.assertIsNone(OceanOpticsSpectrometer.class_registry.owner_inst)
-
- # req. 2. owner attribute must be the instance for instance registries (i.e. when accessed as instance attribute)
- self.assertEqual(self.thing.instance_registry.owner, self.thing)
- self.assertEqual(self.spectrometer.instance_registry.owner, self.spectrometer)
- self.assertEqual(self.thing.instance_registry.owner_cls, Thing)
- self.assertEqual(self.spectrometer.instance_registry.owner_cls, OceanOpticsSpectrometer)
-
- # req. 3. descriptor_object must be defined correctly and is a class
- self.assertEqual(Thing.class_registry.descriptor_object, self.registry_object)
- self.assertEqual(
- OceanOpticsSpectrometer.class_registry.descriptor_object,
- self.registry_object,
- )
- self.assertEqual(self.thing.instance_registry.descriptor_object, self.registry_object)
- self.assertEqual(
- self.thing.instance_registry.descriptor_object,
- Thing.class_registry.descriptor_object,
- )
+Test sequence is as follows:
+1. Test id requirements
+2. Test logger setup
+3. Test state and state_machine setup
+4. Test composition of subthings
+5. Test servers init
+6. Test thing model generation
+"""
- def test_2_descriptors(self):
- """Test descriptors access"""
- if self.is_abstract_test_class:
- return
-
- # req. 1. descriptors are instances of the descriptor object - Property | Action | Event
- for name, value in Thing.class_registry.descriptors.items():
- self.assertIsInstance(value, self.registry_object)
- self.assertIsInstance(name, str)
- for name, value in OceanOpticsSpectrometer.class_registry.descriptors.items():
- self.assertIsInstance(value, self.registry_object)
- self.assertIsInstance(name, str)
- # subclass have more descriptors than parent class because our example Thing OceanOpticsSpectrometer
- # has defined its own actions, properties and events
- self.assertTrue(len(OceanOpticsSpectrometer.class_registry.descriptors) > len(Thing.class_registry.descriptors))
- # req. 2. either class level or instance level descriptors are same - not a strict requirement for different
- # use cases, one can always add instance level descriptors
- for name, value in self.thing.instance_registry.descriptors.items():
- self.assertIsInstance(value, self.registry_object)
- self.assertIsInstance(name, str)
- for name, value in self.spectrometer.instance_registry.descriptors.items():
- self.assertIsInstance(value, self.registry_object)
- self.assertIsInstance(name, str)
- # req. 3. because class level and instance level descriptors are same, they are equal
- for (name, value), (name2, value2) in zip(
- Thing.class_registry.descriptors.items(),
- self.thing.instance_registry.descriptors.items(),
- ):
- self.assertEqual(name, name2)
- self.assertEqual(value, value2)
- for (name, value), (name2, value2) in zip(
- OceanOpticsSpectrometer.class_registry.descriptors.items(),
- self.spectrometer.instance_registry.descriptors.items(),
- ):
- self.assertEqual(name, name2)
- self.assertEqual(value, value2)
- # req. 4. descriptors can be cleared
- self.assertTrue(
- hasattr(
- self.thing.instance_registry,
- f"_{self.thing.instance_registry._qualified_prefix}_{self.registry_cls.__name__.lower()}",
- )
- )
- self.thing.instance_registry.clear()
- self.assertTrue(
- not hasattr(
- self.thing.instance_registry,
- f"_{self.thing.instance_registry._qualified_prefix}_{self.registry_cls.__name__.lower()}",
- )
- )
- # clearing again any number of times should not raise error
- self.thing.instance_registry.clear()
- self.thing.instance_registry.clear()
- self.assertTrue(
- not hasattr(
- self.thing.instance_registry,
- f"_{self.thing.instance_registry._qualified_prefix}_{self.registry_cls.__name__.lower()}",
- )
- )
- def test_3_dunders(self):
- """Test dunders of DescriptorRegistry"""
- if self.is_abstract_test_class:
- return
-
- # req. 1. __getitem__ must return the descriptor object
- for name, value in Thing.class_registry.descriptors.items():
- self.assertEqual(Thing.class_registry[name], value)
- # req. 2. __contains__ must return True if the descriptor is present
- self.assertIn(value, Thing.class_registry)
- self.assertIn(name, Thing.class_registry.descriptors.keys())
-
- # req. 2. __iter__ must return an iterator over the descriptors dictionary
- # which in turn iterates over the keys
- self.assertTrue(all(isinstance(descriptor_name, str) for descriptor_name in Thing.class_registry))
- self.assertTrue(
- all(isinstance(descriptor_name, str) for descriptor_name in OceanOpticsSpectrometer.class_registry)
- )
- # __iter__ can also be casted as other iterators like lists
- thing_descriptors = list(self.thing.instance_registry)
- spectrometer_descriptors = list(self.spectrometer.instance_registry)
- self.assertIsInstance(thing_descriptors, list)
- self.assertIsInstance(spectrometer_descriptors, list)
- self.assertTrue(all(isinstance(descriptor_name, str) for descriptor_name in thing_descriptors))
- self.assertTrue(all(isinstance(descriptor_name, str) for descriptor_name in spectrometer_descriptors))
-
- # req. 3. __len__ must return the number of descriptors
- self.assertTrue(len(Thing.class_registry) == len(Thing.class_registry.descriptors))
- self.assertTrue(
- len(OceanOpticsSpectrometer.class_registry) == len(OceanOpticsSpectrometer.class_registry.descriptors)
- )
- self.assertTrue(len(self.thing.instance_registry) == len(self.thing.instance_registry.descriptors))
- self.assertTrue(
- len(self.spectrometer.instance_registry) == len(self.spectrometer.instance_registry.descriptors)
- )
- self.assertTrue(len(self.thing.instance_registry) == len(Thing.class_registry))
- self.assertTrue(len(self.spectrometer.instance_registry) == len(OceanOpticsSpectrometer.class_registry))
-
- # req. 4. registries have their unique hashes
- # NOTE - not sure if this is really a useful feature or just plain stupid
- # The requirement was to be able to generate unique hashes for each registry like foodict[