blob: 9fcebdef046610f79eb6538d0726938bb98b6062 [file]
# Copyright 2026 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import importlib
import pkgutil
import types
import typing
import unittest
from typing import Any, ClassVar
import shared.protocol
from pydantic import BaseModel, ValidationError
from shared.protocol import (
BaseRequest,
RequestType,
ResponseType,
deserialize_response,
make_request,
)
from shared.tests.helpers import ProtocolTestCase
class _SampleBody(BaseModel):
count: int
label: str
class _TypedStubRequest(BaseRequest[_SampleBody]):
command: str = "stub-typed"
response_type: ClassVar[Any] = _SampleBody
class _DictStubRequest(BaseRequest[dict[str, Any]]):
command: str = "stub-dict"
response_type: ClassVar[Any] = dict[str, Any]
class _NoneStubRequest(BaseRequest[None]):
command: str = "stub-none"
response_type: ClassVar[Any] = None
class TestProtocolRegistryAndFraming(ProtocolTestCase):
def test_all_requests_and_responses_registered(self) -> None:
for module_info in pkgutil.iter_modules(shared.protocol.__path__):
if not module_info.ispkg:
importlib.import_module(f"shared.protocol.{module_info.name}")
request_union = typing.get_args(RequestType)[0]
registered_requests = set(typing.get_args(request_union))
registered_responses = set(typing.get_args(ResponseType))
protocol_requests: list[type[BaseRequest[Any]]] = []
pending = list(BaseRequest.__subclasses__())
while pending:
cls = pending.pop()
pending.extend(cls.__subclasses__())
if (
cls.__module__.startswith("shared.protocol.")
and cls.__module__ != "shared.protocol.base"
):
protocol_requests.append(cls)
self.assertGreater(len(protocol_requests), 0)
for req_cls in protocol_requests:
self.assertIn(
req_cls,
registered_requests,
f"{req_cls.__name__} is missing from RequestType",
)
resp_type = req_cls.response_type
if resp_type is None:
self.assertIn(type(None), registered_responses)
elif isinstance(resp_type, types.UnionType):
for member in typing.get_args(resp_type):
self.assertIn(
member,
registered_responses,
f"{member} for {req_cls.__name__} is missing from ResponseType",
)
else:
self.assertIn(
resp_type,
registered_responses,
f"{resp_type} for {req_cls.__name__} is missing from ResponseType",
)
def test_parse_unknown_command(self) -> None:
with self.assertRaises(ValidationError):
make_request({"command": "unknown-cmd"})
def test_deserialize_typed_response(self) -> None:
req = _TypedStubRequest()
body = self.assert_deserializes_body(
req,
{"count": 3, "label": "ok"},
_SampleBody,
)
self.assertEqual(body.count, 3)
self.assertEqual(body.label, "ok")
def test_deserialize_dict_response(self) -> None:
req = _DictStubRequest()
body = self.assert_deserializes_body(
req,
{"threads": [{"id": 1, "name": "t1"}]},
dict,
)
self.assertEqual(body, {"threads": [{"id": 1, "name": "t1"}]})
def test_deserialize_none_response(self) -> None:
req = _NoneStubRequest()
json_line = self.make_response_json(body=None, message="stopped")
resp = deserialize_response(json_line, req)
self.assertTrue(resp.success)
self.assertIsNone(resp.body)
self.assertEqual(resp.message, "stopped")
def test_deserialize_error_response_typed_request(self) -> None:
req = _TypedStubRequest()
json_line = self.make_response_json(
body=None, success=False, message="Handler failed"
)
resp = deserialize_response(json_line, req)
self.assertFalse(resp.success)
self.assertIsNone(resp.body)
self.assertEqual(resp.message, "Handler failed")
if __name__ == "__main__":
unittest.main()