pypck 0.8.10__tar.gz → 0.8.11__tar.gz

{pypck-0.8.10/pypck.egg-info → pypck-0.8.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pypck
-Version: 0.8.10
+Version: 0.8.11
 Summary: LCN-PCK library
 Home-page: https://github.com/alengwenus/pypck
 Author-email: Andre Lengwenus <alengwenus@gmail.com>

pypck-0.8.11/VERSION

@@ -0,0 +1 @@
+0.8.11

{pypck-0.8.10 → pypck-0.8.11/pypck.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pypck
-Version: 0.8.10
+Version: 0.8.11
 Summary: LCN-PCK library
 Home-page: https://github.com/alengwenus/pypck
 Author-email: Andre Lengwenus <alengwenus@gmail.com>

{pypck-0.8.10 → pypck-0.8.11}/pypck.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ pypck/lcn_addr.py
 pypck/lcn_defs.py
 pypck/module.py
 pypck/pck_commands.py
+pypck/py.typed
 pypck/request_handlers.py
 pypck/timeout_retry.py
 pypck.egg-info/PKG-INFO
@@ -21,5 +22,6 @@ pypck.egg-info/top_level.txt
 tests/test_commands.py
 tests/test_connection.py
 tests/test_dyn_text.py
+tests/test_input.py
 tests/test_messages.py
 tests/test_vars.py

{pypck-0.8.10 → pypck-0.8.11}/pyproject.toml

@@ -38,6 +38,9 @@ version = {file = "VERSION"}
 [tool.setuptools.packages.find]
 include = ["pypck*"]
 
+[tool.setuptools.package-data]
+mypkg = ["py.typed"]
+
 [tool.black]
 target-version = ["py311", "py312", "py313"]
 

pypck-0.8.11/tests/test_connection.py

@@ -0,0 +1,155 @@
+"""Connection tests."""
+
+import asyncio
+from unittest.mock import AsyncMock, Mock, call, patch
+
+import pytest
+
+from pypck import inputs
+from pypck.connection import (
+    PchkAuthenticationError,
+    PchkConnectionFailedError,
+    PchkConnectionManager,
+    PchkConnectionRefusedError,
+    PchkLicenseError,
+)
+from pypck.lcn_defs import LcnEvent
+from pypck.pck_commands import PckGenerator
+
+from .conftest import HOST, PASSWORD, PORT, USERNAME, MockPchkConnectionManager
+
+
+async def test_close_without_connect(pypck_client: MockPchkConnectionManager) -> None:
+    """Test closing of PchkConnectionManager without connecting."""
+    await pypck_client.async_close()
+
+
+@patch.object(PchkConnectionManager, "open_connection")
+@patch.object(PchkConnectionManager, "scan_segment_couplers")
+async def test_async_connect(
+    mock_scan_segment_couplers: AsyncMock,
+    mock_open_connection: AsyncMock,
+) -> None:
+    """Test successful connection."""
+    pypck_client = PchkConnectionManager(HOST, PORT, USERNAME, PASSWORD)
+    connect_task = asyncio.create_task(pypck_client.async_connect())
+    await asyncio.sleep(0)
+
+    pypck_client.license_error_future.set_result(True)
+    pypck_client.authentication_completed_future.set_result(True)
+    pypck_client.segment_scan_completed_event.set()
+
+    await connect_task
+
+    mock_scan_segment_couplers.assert_awaited()
+    mock_open_connection.assert_awaited()
+    assert pypck_client.is_ready()
+
+
+@patch.object(PchkConnectionManager, "ping")
+@patch.object(PchkConnectionManager, "open_connection")
+@patch.object(PchkConnectionManager, "scan_segment_couplers")
+@patch.object(PchkConnectionManager, "send_command")
+async def test_successful_connection_procedure(
+    mock_send_command: AsyncMock,
+    mock_scan_segment_couplers: AsyncMock,
+    mock_open_connection: AsyncMock,
+    mock_ping: AsyncMock,
+) -> None:
+    """Test successful connection procedure."""
+    pypck_client = PchkConnectionManager(HOST, PORT, USERNAME, PASSWORD)
+    connect_task = asyncio.create_task(pypck_client.async_connect())
+    await asyncio.sleep(0)
+
+    await pypck_client.async_process_input(inputs.AuthUsername())
+    mock_send_command.assert_awaited_with(USERNAME, to_host=True)
+
+    await pypck_client.async_process_input(inputs.AuthPassword())
+    mock_send_command.assert_awaited_with(PASSWORD, to_host=True)
+
+    await pypck_client.async_process_input(inputs.AuthOk())
+    mock_send_command.assert_awaited_with(PckGenerator.set_dec_mode(), to_host=True)
+    assert pypck_client.authentication_completed_future.result()
+
+    await pypck_client.async_process_input(inputs.DecModeSet())
+    mock_send_command.assert_awaited_with(
+        PckGenerator.set_operation_mode(
+            pypck_client.dim_mode, pypck_client.status_mode
+        ),
+        to_host=True,
+    )
+    assert pypck_client.license_error_future.result()
+
+    await connect_task
+
+    mock_open_connection.assert_awaited()
+    mock_scan_segment_couplers.assert_awaited()
+    mock_ping.assert_awaited()
+
+
+@pytest.mark.parametrize("side_effect", [ConnectionRefusedError, OSError])
+async def test_connection_error(side_effect: ConnectionRefusedError | OSError) -> None:
+    """Test connection error."""
+    with (
+        patch.object(PchkConnectionManager, "open_connection", side_effect=side_effect),
+        pytest.raises(PchkConnectionRefusedError),
+    ):
+        pypck_client = PchkConnectionManager(HOST, PORT, USERNAME, PASSWORD)
+        await pypck_client.async_connect()
+
+
+@patch.object(PchkConnectionManager, "open_connection")
+async def test_authentication_error(mock_open_connection: AsyncMock) -> None:
+    """Test wrong login credentials."""
+    pypck_client = PchkConnectionManager(HOST, PORT, USERNAME, PASSWORD)
+    connect_task = asyncio.create_task(pypck_client.async_connect())
+    await asyncio.sleep(0)
+    await pypck_client.async_process_input(inputs.AuthFailed())
+
+    with (
+        pytest.raises(PchkAuthenticationError),
+    ):
+        await connect_task
+
+
+@patch.object(PchkConnectionManager, "open_connection")
+async def test_license_error(mock_open_connection: AsyncMock) -> None:
+    """Test wrong login credentials."""
+    pypck_client = PchkConnectionManager(HOST, PORT, USERNAME, PASSWORD)
+    connect_task = asyncio.create_task(pypck_client.async_connect())
+    await asyncio.sleep(0)
+    await pypck_client.async_process_input(inputs.LicenseError())
+
+    with (
+        pytest.raises(PchkLicenseError),
+    ):
+        await connect_task
+
+
+@patch.object(PchkConnectionManager, "open_connection")
+async def test_timeout_error(mock_open_connection: AsyncMock) -> None:
+    """Test timeout when connecting."""
+    with pytest.raises(PchkConnectionFailedError):
+        pypck_client = PchkConnectionManager(HOST, PORT, USERNAME, PASSWORD)
+        await pypck_client.async_connect(timeout=0)
+
+
+async def test_lcn_connected(pypck_client: MockPchkConnectionManager) -> None:
+    """Test lcn connected events."""
+    event_callback = Mock()
+    pypck_client.register_for_events(event_callback)
+    await pypck_client.async_connect()
+
+    # bus disconnected
+    await pypck_client.async_process_input(inputs.LcnConnState(is_lcn_connected=False))
+    assert not pypck_client.is_lcn_connected
+    event_callback.assert_has_calls(
+        (call(LcnEvent.BUS_CONNECTION_STATUS_CHANGED), call(LcnEvent.BUS_DISCONNECTED))
+    )
+
+    # bus connected
+    await pypck_client.async_process_input(inputs.LcnConnState(is_lcn_connected=True))
+    assert pypck_client.is_lcn_connected
+    event_callback.assert_has_calls(
+        (call(LcnEvent.BUS_CONNECTION_STATUS_CHANGED), call(LcnEvent.BUS_CONNECTED))
+    )

{pypck-0.8.10 → pypck-0.8.11}/tests/test_dyn_text.py

@@ -1,11 +1,8 @@
 """Module connection tests."""
 
-from unittest.mock import patch
-
 import pytest
 
 from pypck.lcn_addr import LcnAddr
-from pypck.module import ModuleConnection
 
 from .conftest import MockPchkConnectionManager
 
@@ -58,7 +55,6 @@ TEST_VECTORS = {
 }
 
 
-@pytest.mark.asyncio
 @pytest.mark.parametrize("text, parts", TEST_VECTORS.items())
 async def test_dyn_text(
     pypck_client: MockPchkConnectionManager,
@@ -66,14 +62,12 @@ async def test_dyn_text(
     parts: tuple[bytes, bytes, bytes, bytes, bytes],
 ) -> None:
     """Tests for dynamic text."""
-    # await pypck_client.async_connect()
     module = pypck_client.get_address_conn(LcnAddr(0, 10, False))
 
-    with patch.object(ModuleConnection, "send_command") as send_command:
-        await module.dyn_text(3, text)
+    await module.dyn_text(3, text)
 
-    send_command.assert_awaited()
-    await_args = (call.args for call in send_command.await_args_list)
+    module.send_command.assert_awaited()  # type: ignore[attr-defined]
+    await_args = (call.args for call in module.send_command.await_args_list)  # type: ignore[attr-defined]
     _, commands = zip(*await_args)
 
     for i, part in enumerate(parts):

pypck-0.8.11/tests/test_input.py

@@ -0,0 +1,46 @@
+"""Test the data flow for Input objects."""
+
+from unittest.mock import patch
+
+from pypck.inputs import Input, ModInput
+from pypck.lcn_addr import LcnAddr
+from pypck.module import ModuleConnection
+
+from .conftest import MockPchkConnectionManager
+
+
+async def test_message_to_input(pypck_client: MockPchkConnectionManager) -> None:
+    """Test data flow from message to input."""
+    inp = Input()
+    message = "dummy_message"
+    with patch.object(
+        pypck_client, "async_process_input"
+    ) as pypck_client_process_input:
+        with patch("pypck.inputs.InputParser.parse", return_value=[inp]) as inp_parse:
+            await pypck_client.process_message(message)
+
+        inp_parse.assert_called_with(message)
+        pypck_client_process_input.assert_awaited_with(inp)
+
+
+async def test_physical_to_logical_segment_id(
+    pypck_client: MockPchkConnectionManager,
+) -> None:
+    """Test conversion from logical to physical segment id."""
+    pypck_client.local_seg_id = 20
+    module = pypck_client.get_address_conn(LcnAddr(20, 7, False))
+    assert isinstance(module, ModuleConnection)
+    with (
+        patch("tests.conftest.MockPchkConnectionManager.is_ready", return_value=True),
+        patch.object(module, "async_process_input") as module_process_input,
+    ):
+        inp = ModInput(LcnAddr(20, 7, False))
+        await pypck_client.async_process_input(inp)
+
+        inp = ModInput(LcnAddr(0, 7, False))
+        await pypck_client.async_process_input(inp)
+
+        inp = ModInput(LcnAddr(4, 7, False))
+        await pypck_client.async_process_input(inp)
+
+        assert module_process_input.await_count == 3

pypck-0.8.10/VERSION

@@ -1 +0,0 @@
-0.8.10

pypck-0.8.10/tests/test_connection.py

@@ -1,471 +0,0 @@
-"""Connection tests."""
-
-import asyncio
-import json
-from unittest.mock import Mock, call
-
-import pytest
-
-from pypck.connection import (
-    PchkAuthenticationError,
-    PchkConnectionFailedError,
-    PchkConnectionRefusedError,
-    PchkLicenseError,
-)
-from pypck.lcn_addr import LcnAddr
-from pypck.lcn_defs import LcnEvent
-from pypck.module import ModuleConnection
-
-from .conftest import MockPchkConnectionManager
-from .mock_pchk import MockPchkServer
-
-
-@pytest.mark.asyncio
-async def test_close_without_connect(pypck_client: MockPchkConnectionManager) -> None:
-    """Test closing of PchkConnectionManager without connecting."""
-    await pypck_client.async_close()
-
-
-@pytest.mark.asyncio
-async def test_authenticate(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test authentication procedure."""
-    await pypck_client.async_connect()
-    assert pypck_client.is_ready()
-
-
-@pytest.mark.asyncio
-async def test_port_error(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test wrong port."""
-    pypck_client.port = 55555
-    with pytest.raises(PchkConnectionRefusedError):
-        await pypck_client.async_connect()
-
-
-@pytest.mark.asyncio
-async def test_authentication_error(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test wrong login credentials."""
-    pypck_client.password = "wrong_password"
-    with pytest.raises(PchkAuthenticationError):
-        await pypck_client.async_connect()
-
-
-@pytest.mark.asyncio
-async def test_license_error(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test license error."""
-    pchk_server.set_license_error(True)
-
-    with pytest.raises(PchkLicenseError):
-        await pypck_client.async_connect()
-
-
-@pytest.mark.asyncio
-async def test_timeout_error(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test timeout when connecting."""
-    with pytest.raises(PchkConnectionFailedError):
-        await pypck_client.async_connect(timeout=0)
-
-
-@pytest.mark.asyncio
-async def test_lcn_connected(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test lcn disconnected event."""
-    event_callback = Mock()
-    pypck_client.register_for_events(event_callback)
-    await pypck_client.async_connect()
-    await pchk_server.send_message("$io:#LCN:connected")
-    await pypck_client.received("$io:#LCN:connected")
-
-    event_callback.assert_has_calls(
-        [
-            call(LcnEvent.BUS_CONNECTION_STATUS_CHANGED),
-            call(LcnEvent.BUS_CONNECTED),
-        ]
-    )
-
-
-@pytest.mark.asyncio
-async def test_lcn_disconnected(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test lcn disconnected event."""
-    event_callback = Mock()
-    pypck_client.register_for_events(event_callback)
-    await pypck_client.async_connect()
-    await pchk_server.send_message("$io:#LCN:disconnected")
-    await pypck_client.received("$io:#LCN:disconnected")
-
-    event_callback.assert_has_calls(
-        [call(LcnEvent.BUS_CONNECTION_STATUS_CHANGED), call(LcnEvent.BUS_DISCONNECTED)]
-    )
-
-
-@pytest.mark.asyncio
-async def test_connection_lost(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test pchk server connection close."""
-    event_callback = Mock()
-    pypck_client.register_for_events(event_callback)
-    await pypck_client.async_connect()
-
-    await pchk_server.stop()
-    # ensure that pypck_client is about to be closed
-    await pypck_client.wait_closed()
-
-    event_callback.assert_has_calls([call(LcnEvent.CONNECTION_LOST)])
-
-
-@pytest.mark.asyncio
-async def test_multiple_connections(
-    pchk_server: MockPchkServer,
-    pypck_client: MockPchkConnectionManager,
-    pchk_server_2: MockPchkServer,
-    pypck_client_2: MockPchkConnectionManager,
-) -> None:
-    """Test that two independent connections can coexists."""
-    await pypck_client_2.async_connect()
-
-    event_callback = Mock()
-    pypck_client.register_for_events(event_callback)
-    await pypck_client.async_connect()
-
-    await pchk_server.stop()
-    await pypck_client.wait_closed()
-
-    event_callback.assert_has_calls([call(LcnEvent.CONNECTION_LOST)])
-
-    assert len(pypck_client.task_registry.tasks) == 0
-    assert len(pypck_client_2.task_registry.tasks) > 0
-
-
-@pytest.mark.asyncio
-async def test_segment_coupler_search(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test segment coupler search."""
-    await pypck_client.async_connect()
-    await pypck_client.scan_segment_couplers(3, 0)
-
-    assert await pchk_server.received(">G003003.SK")
-    assert await pchk_server.received(">G003003.SK")
-    assert await pchk_server.received(">G003003.SK")
-
-    assert pypck_client.is_ready()
-
-
-@pytest.mark.asyncio
-async def test_segment_coupler_response(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test segment coupler response."""
-    await pypck_client.async_connect()
-
-    assert pypck_client.local_seg_id == 0
-
-    await pchk_server.send_message("=M000005.SK020")
-    await pchk_server.send_message("=M021021.SK021")
-    await pchk_server.send_message("=M022010.SK022")
-    assert await pypck_client.received("=M000005.SK020")
-    assert await pypck_client.received("=M021021.SK021")
-    assert await pypck_client.received("=M022010.SK022")
-
-    assert pypck_client.local_seg_id == 20
-    assert set(pypck_client.segment_coupler_ids) == {20, 21, 22}
-
-
-@pytest.mark.asyncio
-async def test_module_scan(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test module scan."""
-    await pypck_client.async_connect()
-    await pypck_client.scan_modules(3, 0)
-
-    assert await pchk_server.received(">G000003!LEER")
-    assert await pchk_server.received(">G000003!LEER")
-    assert await pchk_server.received(">G000003!LEER")
-
-
-@pytest.mark.asyncio
-async def test_module_sn_response(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test module scan."""
-    await pypck_client.async_connect()
-    module = pypck_client.get_address_conn(LcnAddr(0, 7, False))
-
-    message = "=M000007.SN1AB20A123401FW190B11HW015"
-    await pchk_server.send_message(message)
-    assert await pypck_client.received(message)
-
-    assert await module.serial_known
-    assert module.hardware_serial == 0x1AB20A1234
-    assert module.manu == 1
-    assert module.software_serial == 0x190B11
-    assert module.hardware_type.value == 15
-
-
-@pytest.mark.asyncio
-async def test_send_command_to_server(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test sending a command to the PCHK server."""
-    await pypck_client.async_connect()
-    message = ">M000007.PIN003"
-    await pypck_client.send_command(message)
-    assert await pchk_server.received(message)
-
-
-@pytest.mark.asyncio
-async def test_ping(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test if pings are send."""
-    await pypck_client.async_connect()
-    assert await pchk_server.received("^ping0")
-
-
-@pytest.mark.asyncio
-async def test_add_address_connections(pypck_client: MockPchkConnectionManager) -> None:
-    """Test if new address connections are added on request."""
-    lcn_addr = LcnAddr(0, 10, False)
-    assert lcn_addr not in pypck_client.address_conns
-
-    addr_conn = pypck_client.get_address_conn(lcn_addr)
-    assert isinstance(addr_conn, ModuleConnection)
-
-    assert lcn_addr in pypck_client.address_conns
-
-
-@pytest.mark.asyncio
-async def test_add_address_connections_by_message(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test if new address connections are added by received message."""
-    await pypck_client.async_connect()
-    lcn_addr = LcnAddr(0, 10, False)
-    assert lcn_addr not in pypck_client.address_conns
-
-    message = ":M000010A1050"
-    await pchk_server.send_message(message)
-    assert await pypck_client.received(message)
-
-    assert lcn_addr in pypck_client.address_conns
-
-
-@pytest.mark.asyncio
-async def test_groups_static_membership_discovery(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test module scan."""
-    await pypck_client.async_connect()
-    module = pypck_client.get_address_conn(LcnAddr(0, 10, False))
-    assert isinstance(module, ModuleConnection)
-
-    task = asyncio.create_task(module.request_static_groups())
-    assert await pchk_server.received(">M000010.GP")
-    await pchk_server.send_message("=M000010.GP012011200051")
-    assert await task == {
-        LcnAddr(0, 11, True),
-        LcnAddr(0, 200, True),
-        LcnAddr(0, 51, True),
-    }
-
-
-@pytest.mark.asyncio
-async def test_groups_dynamic_membership_discovery(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test module scan."""
-    await pypck_client.async_connect()
-    module = pypck_client.get_address_conn(LcnAddr(0, 10, False))
-    assert isinstance(module, ModuleConnection)
-
-    task = asyncio.create_task(module.request_dynamic_groups())
-    assert await pchk_server.received(">M000010.GD")
-    await pchk_server.send_message("=M000010.GD008011200051")
-    assert await task == {
-        LcnAddr(0, 11, True),
-        LcnAddr(0, 200, True),
-        LcnAddr(0, 51, True),
-    }
-
-
-@pytest.mark.asyncio
-async def test_groups_membership_discovery(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test module scan."""
-    await pypck_client.async_connect()
-    module = pypck_client.get_address_conn(LcnAddr(0, 10, False))
-    assert isinstance(module, ModuleConnection)
-
-    task = asyncio.create_task(module.request_groups())
-    assert await pchk_server.received(">M000010.GP")
-    await pchk_server.send_message("=M000010.GP012011200051")
-    assert await pchk_server.received(">M000010.GD")
-    await pchk_server.send_message("=M000010.GD008015100052")
-    assert await task == {
-        LcnAddr(0, 11, True),
-        LcnAddr(0, 200, True),
-        LcnAddr(0, 51, True),
-        LcnAddr(0, 15, True),
-        LcnAddr(0, 100, True),
-        LcnAddr(0, 52, True),
-    }
-
-
-@pytest.mark.asyncio
-async def test_multiple_serial_requests(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test module scan."""
-    await pypck_client.async_connect()
-
-    pypck_client.get_address_conn(LcnAddr(0, 10, False))
-    pypck_client.get_address_conn(LcnAddr(0, 11, False))
-    pypck_client.get_address_conn(LcnAddr(0, 12, False))
-
-    assert await pchk_server.received(">M000010.SN")
-    assert await pchk_server.received(">M000011.SN")
-    assert await pchk_server.received(">M000012.SN")
-
-    message = "=M000010.SN1AB20A123401FW190B11HW015"
-    await pchk_server.send_message(message)
-    assert await pypck_client.received(message)
-
-    await pypck_client.async_close()
-
-
-@pytest.mark.asyncio
-async def test_dump_modules_no_segement_couplers(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test module information dumping."""
-    await pypck_client.async_connect()
-
-    for msg in (
-        "=M000007.SN1AB20A123401FW190B11HW015",
-        "=M000008.SN1BB20A123401FW1A0B11HW015",
-        "=M000007.GP012011200051",
-        "=M000008.GP012011220051",
-        "=M000007.GD008015100052",
-        "=M000008.GD008015120052",
-    ):
-        await pchk_server.send_message(msg)
-        assert await pypck_client.received(msg)
-
-    dump = pypck_client.dump_modules()
-    json.dumps(dump)
-
-    assert dump == {
-        "0": {
-            "7": {
-                "segment": 0,
-                "address": 7,
-                "is_local_segment": True,
-                "serials": {
-                    "hardware_serial": "1AB20A1234",
-                    "manu": "01",
-                    "software_serial": "190B11",
-                    "hardware_type": "15",
-                    "hardware_name": "LCN-SH-Plus",
-                },
-                "name": "",
-                "comment": "",
-                "oem_text": ["", "", "", ""],
-                "groups": {"static": [11, 51, 200], "dynamic": [15, 52, 100]},
-            },
-            "8": {
-                "segment": 0,
-                "address": 8,
-                "is_local_segment": True,
-                "serials": {
-                    "hardware_serial": "1BB20A1234",
-                    "manu": "01",
-                    "software_serial": "1A0B11",
-                    "hardware_type": "15",
-                    "hardware_name": "LCN-SH-Plus",
-                },
-                "name": "",
-                "comment": "",
-                "oem_text": ["", "", "", ""],
-                "groups": {"static": [11, 51, 220], "dynamic": [15, 52, 120]},
-            },
-        }
-    }
-
-
-@pytest.mark.asyncio
-async def test_dump_modules_multi_segment(
-    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
-) -> None:
-    """Test module information dumping."""
-    await pypck_client.async_connect()
-
-    # Populate the bus topology information
-    for msg in (
-        "=M000007.SK020",
-        "=M022008.SK022",
-        "=M000007.SN1AB20A123401FW190B11HW015",
-        "=M022008.SN1BB20A123401FW1A0B11HW015",
-        "=M000007.GP012011200051",
-        "=M022008.GP012011220051",
-        "=M000007.GD008015100052",
-        "=M022008.GD008015120052",
-    ):
-        await pchk_server.send_message(msg)
-        assert await pypck_client.received(msg)
-
-    dump = pypck_client.dump_modules()
-    json.dumps(dump)
-
-    assert dump == {
-        "20": {
-            "7": {
-                "segment": 20,
-                "address": 7,
-                "is_local_segment": True,
-                "serials": {
-                    "hardware_serial": "1AB20A1234",
-                    "manu": "01",
-                    "software_serial": "190B11",
-                    "hardware_type": "15",
-                    "hardware_name": "LCN-SH-Plus",
-                },
-                "name": "",
-                "comment": "",
-                "oem_text": ["", "", "", ""],
-                "groups": {"static": [11, 51, 200], "dynamic": [15, 52, 100]},
-            },
-        },
-        "22": {
-            "8": {
-                "segment": 22,
-                "address": 8,
-                "is_local_segment": False,
-                "serials": {
-                    "hardware_serial": "1BB20A1234",
-                    "manu": "01",
-                    "software_serial": "1A0B11",
-                    "hardware_type": "15",
-                    "hardware_name": "LCN-SH-Plus",
-                },
-                "name": "",
-                "comment": "",
-                "oem_text": ["", "", "", ""],
-                "groups": {"static": [11, 51, 220], "dynamic": [15, 52, 120]},
-            },
-        },
-    }