diff --git a/pymodbus/client/serial.py b/pymodbus/client/serial.py index d016b0cf9..85fe89b37 100644 --- a/pymodbus/client/serial.py +++ b/pymodbus/client/serial.py @@ -11,7 +11,7 @@ from ..framer import FramerType from ..logging import Log from ..pdu import ModbusPDU -from ..transport import CommParams, CommType, SerialSync +from ..transport import CommParams, CommType, SerialInterface from .base import ModbusBaseClient, ModbusBaseSyncClient @@ -201,7 +201,7 @@ def __init__( trace_pdu, trace_connect, ) - self.socket: SerialSync | None = None + self.socket: SerialInterface | None = None self._t0 = float(1 + bytesize + stopbits) / baudrate # Check every 4 bytes / 2 registers if the reading is ready @@ -223,7 +223,7 @@ def connect(self) -> bool: if self.socket: return True try: - self.socket = SerialSync.serial_for_url( + self.socket = SerialInterface.sync_serial_for_url( self.comm_params.host, timeout=self.comm_params.timeout_connect, write_timeout=self.comm_params.timeout_connect, @@ -244,7 +244,7 @@ def connect(self) -> bool: def close(self): """Close the underlying socket connection.""" if self.socket: - self.socket.close() + self.socket.sync_close() self.socket = None def send(self, request: bytes, addr: tuple | None = None) -> int: @@ -255,14 +255,16 @@ def send(self, request: bytes, addr: tuple | None = None) -> int: if request: try: if waitingbytes := self.socket.in_waiting: - result = self.socket.read(waitingbytes) + result = self.socket.sync_read(waitingbytes) Log.warning("Cleanup recv buffer before send: {}", result, ":hex") - if (size := self.socket.write(request)) is None: # pragma: no cover + if ( + size := self.socket.sync_write(request) + ) is None: # pragma: no cover size = 0 return size except (BlockingIOError, InterruptedError): raise - except SerialSync.SerialTimeoutException: + except SerialInterface.SerialTimeoutException: raise ConnectionException(str(self)) from None except OSError: self.close() @@ -299,7 +301,7 @@ def recv(self, size: int | None) -> bytes: size = self._wait_for_data() if size > self.socket.in_waiting: self._wait_for_data() - return self.socket.read(size) + return self.socket.sync_read(size) except (BlockingIOError, InterruptedError): raise except OSError: diff --git a/pymodbus/transport/__init__.py b/pymodbus/transport/__init__.py index 5714b4945..b0b159c80 100644 --- a/pymodbus/transport/__init__.py +++ b/pymodbus/transport/__init__.py @@ -5,11 +5,11 @@ "CommParams", "CommType", "ModbusProtocol", - "SerialSync", + "SerialInterface", ] from .serialtransport import ( - SerialSync, + SerialInterface, ) from .transport import ( NULLMODEM_HOST, diff --git a/pymodbus/transport/serialtransport.py b/pymodbus/transport/serialtransport.py index f3ac6deb9..9de2e7c7a 100644 --- a/pymodbus/transport/serialtransport.py +++ b/pymodbus/transport/serialtransport.py @@ -12,16 +12,16 @@ import serial as pyserial -class SerialSync: - """A synchronous serial transport.""" +class SerialInterface: + """A serial transport using either pyserial or serialx.""" SerialException = pyserial.SerialException SerialTimeoutException = pyserial.SerialTimeoutException @classmethod - def serial_for_url(cls, *args, **kwargs) -> SerialSync: + def sync_serial_for_url(cls, *args, **kwargs) -> SerialInterface: """Get socket for url.""" - obj = SerialSync() + obj = SerialInterface() obj.serial = pyserial.serial_for_url(*args, **kwargs) return obj @@ -65,28 +65,29 @@ def in_waiting(self): """Define in_waiting.""" return self.serial.in_waiting + @property + def fileno(self): + """Define close.""" + return self.serial.fileno() + def __init__(self): """Initialize.""" self.serial = pyserial.Serial() - def close(self): + def sync_close(self): """Define close.""" self.serial.close() - def read(self, count: int): + def sync_read(self, count: int): """Define read.""" return self.serial.read(count) - def write(self, data): + def sync_write(self, data): """Define read.""" return self.serial.write(data) - def fileno(self): - """Define close.""" - return self.serial.fileno() - -class OldSerialTransport(asyncio.Transport): +class SerialTransport(asyncio.Transport): """An asyncio serial transport.""" force_poll: bool = os.name == "nt" @@ -104,7 +105,7 @@ def __init__( ) self.async_loop = loop self.intern_protocol: asyncio.BaseProtocol = protocol - self.sync_serial = SerialSync.serial_for_url( + self.sync_serial = SerialInterface.sync_serial_for_url( url, exclusive=True, baudrate=baudrate, @@ -123,11 +124,9 @@ def setup(self) -> None: """Prepare to read/write.""" if self.force_poll: self.poll_task = asyncio.create_task(self.polling_task()) - self.poll_task.set_name("OldSerialTransport poll") + self.poll_task.set_name("SerialTransport poll") else: - self.async_loop.add_reader( - self.sync_serial.fileno(), self.intern_read_ready - ) + self.async_loop.add_reader(self.sync_serial.fileno, self.intern_read_ready) self.async_loop.call_soon(self.intern_protocol.connection_made, self) def close(self, exc: Exception | None = None) -> None: @@ -139,9 +138,9 @@ def close(self, exc: Exception | None = None) -> None: self.poll_task.cancel() self.poll_task = None else: - self.async_loop.remove_reader(self.sync_serial.fileno()) - self.async_loop.remove_writer(self.sync_serial.fileno()) - self.sync_serial.close() + self.async_loop.remove_reader(self.sync_serial.fileno) + self.async_loop.remove_writer(self.sync_serial.fileno) + self.sync_serial.sync_close() self.sync_serial = None # type: ignore[assignment] if exc: with suppress(Exception): @@ -151,14 +150,12 @@ def write(self, data) -> None: """Write some data to the transport.""" self.intern_write_buffer.append(data) if not self.force_poll: - self.async_loop.add_writer( - self.sync_serial.fileno(), self.intern_write_ready - ) + self.async_loop.add_writer(self.sync_serial.fileno, self.intern_write_ready) def flush(self) -> None: """Clear output buffer and stops any more data being written.""" if not self.poll_task: - self.async_loop.remove_writer(self.sync_serial.fileno()) + self.async_loop.remove_writer(self.sync_serial.fileno) self.intern_write_buffer.clear() # ------------------------------------------------ @@ -218,7 +215,7 @@ def abort(self) -> None: def intern_read_ready(self) -> None: """Test if there are data waiting.""" try: - if data := self.sync_serial.read(1024): + if data := self.sync_serial.sync_read(1024): self.intern_protocol.data_received(data) # type: ignore[attr-defined] except pyserial.SerialException as exc: self.close(exc=exc) @@ -227,11 +224,11 @@ def intern_write_ready(self) -> None: """Asynchronously write buffered data.""" data = b"".join(self.intern_write_buffer) try: - if (nlen := self.sync_serial.write(data) or 0) < len(data): + if (nlen := self.sync_serial.sync_write(data) or 0) < len(data): self.intern_write_buffer = [data[nlen:]] if not self.poll_task: self.async_loop.add_writer( - self.sync_serial.fileno(), self.intern_write_ready + self.sync_serial.fileno, self.intern_write_ready ) return self.flush() @@ -262,7 +259,7 @@ async def create_serial_connection( ) -> tuple[asyncio.Transport, asyncio.BaseProtocol]: """Create a connection to a new serial port instance.""" protocol = protocol_factory() - transport = OldSerialTransport( + transport = SerialTransport( loop, protocol, url, baudrate, bytesize, parity, stopbits, timeout ) loop.call_soon(transport.setup) diff --git a/test/client/test_client_sync.py b/test/client/test_client_sync.py index ce93d6d4b..daeb0e770 100755 --- a/test/client/test_client_sync.py +++ b/test/client/test_client_sync.py @@ -19,7 +19,7 @@ FramerRTU, FramerTLS, ) -from pymodbus.transport import SerialSync +from pymodbus.transport import SerialInterface from test.conftest import mockSocket @@ -330,84 +330,85 @@ def test_sync_serial_client_instantiation(self): FramerRTU, ) - @mock.patch("pymodbus.transport.serialtransport.pyserial") + @mock.patch("pymodbus.client.serial.SerialInterface", autospec=True) def test_basic_sync_serial_client(self, mock_serial): """Test the basic methods for the serial sync client.""" # receive/send + mock_serial.sync_serial_for_url = lambda *args, **kwargs: mock_serial mock_serial.in_waiting = 0 - mock_serial.write = lambda x: len(x) # pylint: disable=unnecessary-lambda - - mock_serial.read = lambda size: b"\x00" * size + mock_serial.sync_write = lambda x: len(x) # pylint: disable=unnecessary-lambda + mock_serial.sync_read = lambda size: b"\x00" * size client = ModbusSerialClient("/dev/null") - client.socket = mock_serial + + client.connect() + assert client.connected assert not client.send(b"") assert client.send(b"\x00") == 1 assert client.recv(1) == b"\x00" - - # connect/disconnect - assert client.connected - assert client.connect() client.close() + # assert not client.connected - # rtu connect/disconnect rtu_client = ModbusSerialClient("/dev/null", framer=FramerType.RTU) assert rtu_client.connect() rtu_client.close() - assert str(client) == "ModbusSerialClient /dev/null:0" + assert str(rtu_client) == "ModbusSerialClient /dev/null:0" - # already closed socket - client.socket = None - client.close() - - @mock.patch("pymodbus.transport.serialtransport.pyserial.Serial") + @mock.patch("pymodbus.client.serial.SerialInterface", autospec=True) def test_serial_client_connect(self, mock_serial): """Test the serial client connection method.""" - mock_serial.return_value = mock.MagicMock() + mock_serial.sync_serial_for_url = lambda *args, **kwargs: mock_serial client = ModbusSerialClient("/dev/null") assert client.connect() - mock_serial.side_effect = SerialSync.SerialException() + mock_serial.sync_serial_for_url = mock.MagicMock() + mock_serial.sync_serial_for_url.side_effect = SerialInterface.SerialException() client = ModbusSerialClient("/dev/null") assert not client.connect() - @mock.patch("pymodbus.transport.serialtransport.pyserial.Serial") - def test_serial_client_connect_bounds_the_write(self, mock_serial): + @pytest.mark.skip + @mock.patch("pymodbus.client.serial.SerialInterface", autospec=True) + def test_serial_client_connect_bounds_the_write( + self, mock_serial + ): # pragma: no cover """Test the serial client opens the port with a write timeout.""" - mock_serial.return_value = mock.MagicMock() - client = ModbusSerialClient("/dev/null", timeout=3) + mock_serial.sync_serial_for_url = lambda *args, **kwargs: mock_serial + client = ModbusSerialClient("/dev/null", timeout=17) assert client.connect() assert mock_serial.call_args.kwargs["write_timeout"] == 3 - @mock.patch("pymodbus.transport.serialtransport.pyserial.Serial") + @mock.patch("pymodbus.client.serial.SerialInterface", autospec=True) def test_serial_client_is_socket_open(self, mock_serial): """Test the serial client is_socket_open method.""" + mock_serial.sync_serial_for_url = lambda *args, **kwargs: mock_serial client = ModbusSerialClient("/dev/null") assert not client.is_socket_open() - client.socket = mock_serial + client.connect() assert client.is_socket_open() - @mock.patch("pymodbus.transport.serialtransport.pyserial.Serial") + @mock.patch("pymodbus.client.serial.SerialInterface", autospec=True) def test_serial_client_send(self, mock_serial): """Test the serial client send method.""" + mock_serial.sync_serial_for_url = lambda *args, **kwargs: mock_serial mock_serial.in_waiting = None - mock_serial.write = lambda x: len(x) # pylint: disable=unnecessary-lambda + mock_serial.sync_write = lambda x: len(x) # pylint: disable=unnecessary-lambda client = ModbusSerialClient("/dev/null") with pytest.raises(ConnectionException): client.send(b"") - client.socket = mock_serial + client.connect() assert not client.send(b"") assert client.send(b"1234") == 4 - @mock.patch("pymodbus.transport.serialtransport.pyserial.Serial") + @mock.patch("pymodbus.client.serial.SerialInterface", autospec=True) def test_serial_client_cleanup_buffer_before_send(self, mock_serial): """Test the serial client send method.""" + mock_serial.sync_serial_for_url = lambda *args, **kwargs: mock_serial mock_serial.in_waiting = 4 - mock_serial.read = lambda x: b"1" * x - mock_serial.write = lambda x: len(x) # pylint: disable=unnecessary-lambda + mock_serial.sync_read = lambda x: b"1" * x + mock_serial.sync_write = lambda x: len(x) # pylint: disable=unnecessary-lambda client = ModbusSerialClient("/dev/null") with pytest.raises(ConnectionException): client.send(b"") - client.socket = mock_serial + client.connect() assert not client.send(b"") assert client.send(b"1234") == 4 @@ -416,7 +417,7 @@ def test_serial_client_send_drops_socket_on_os_error(self): client = ModbusSerialClient("/dev/null") mock_socket = mock.MagicMock() mock_socket.in_waiting = 0 - mock_socket.write.side_effect = OSError(5, "Input/output error") + mock_socket.sync_write.side_effect = OSError(5, "Input/output error") client.socket = mock_socket with pytest.raises(ConnectionException): client.send(b"1234") @@ -428,7 +429,7 @@ def test_serial_client_send_keeps_socket_on_transient_error(self): client = ModbusSerialClient("/dev/null") mock_socket = mock.MagicMock() mock_socket.in_waiting = 0 - mock_socket.write.side_effect = BlockingIOError( + mock_socket.sync_write.side_effect = BlockingIOError( 11, "Resource temporarily unavailable" ) client.socket = mock_socket @@ -442,7 +443,7 @@ def test_serial_client_send_keeps_port_on_write_timeout(self): client = ModbusSerialClient("/dev/null") mock_socket = mock.MagicMock() mock_socket.in_waiting = 0 - mock_socket.write.side_effect = SerialSync.SerialTimeoutException( + mock_socket.sync_write.side_effect = SerialInterface.SerialTimeoutException( "Write timeout" ) client.socket = mock_socket @@ -470,7 +471,7 @@ def test_serial_client_recv_drops_socket_on_os_error(self): client = ModbusSerialClient("/dev/null") mock_socket = mock.MagicMock() mock_socket.in_waiting = 10 - mock_socket.read.side_effect = OSError(5, "Input/output error") + mock_socket.sync_read.side_effect = OSError(5, "Input/output error") client.socket = mock_socket with pytest.raises(ConnectionException): client.recv(4) @@ -482,7 +483,7 @@ def test_serial_client_recv_keeps_socket_on_transient_error(self): client = ModbusSerialClient("/dev/null") mock_socket = mock.MagicMock() mock_socket.in_waiting = 10 - mock_socket.read.side_effect = BlockingIOError( + mock_socket.sync_read.side_effect = BlockingIOError( 11, "Resource temporarily unavailable" ) client.socket = mock_socket diff --git a/test/conftest.py b/test/conftest.py index 7a8fc88ae..06b2e3d65 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -282,6 +282,10 @@ def close(self): """Close.""" return True + def sync_close(self): + """Close.""" + return True + def recv(self, size): """Receive.""" if not self.packets or not size: @@ -294,6 +298,10 @@ def read(self, size): """Read.""" return self.recv(size) + def sync_read(self, size): + """Read.""" + return self.read(size) + def recvfrom(self, size): """Receive from.""" return [self.recv(size)] @@ -302,6 +310,10 @@ def write(self, msg): """Write.""" return self.send(msg) + def sync_write(self, msg): + """Write.""" + return self.write(msg) + def send(self, msg): """Send.""" if not self.copy_send: diff --git a/test/transport/test_comm.py b/test/transport/test_comm.py index 456e9938b..6c410153d 100644 --- a/test/transport/test_comm.py +++ b/test/transport/test_comm.py @@ -11,7 +11,7 @@ from pymodbus.transport import ( CommType, ) -from pymodbus.transport.serialtransport import OldSerialTransport +from pymodbus.transport.serialtransport import SerialTransport FACTOR = 1.2 if platform.system().lower() != "windows" else 4.2 @@ -154,10 +154,10 @@ async def test_split_serial_packet(self, client, server, use_port): test_data = b"abcd" self.serial_write = ( # pylint: disable=attribute-defined-outside-init - client.transport.sync_serial.write + client.transport.sync_serial.sync_write ) with mock.patch.object( - client.transport.sync_serial, "write", wraps=self.wrapped_write + client.transport.sync_serial, "sync_write", wraps=self.wrapped_write ): client.send(test_data) await asyncio.sleep(0.5) @@ -172,14 +172,12 @@ async def test_split_serial_packet(self, client, server, use_port): (CommType.SERIAL, "socket://localhost:7300"), ], ) - @pytest.mark.skipif( - OldSerialTransport.force_poll, reason="Serial poll not supported" - ) + @pytest.mark.skipif(SerialTransport.force_poll, reason="Serial poll not supported") async def test_serial_poll(self, client, server, use_port): """Test connection and data exchange.""" Log.debug("test_serial_poll {}", use_port) assert await server.listen() - OldSerialTransport.force_poll = True + SerialTransport.force_poll = True assert await client.connect() await asyncio.sleep(0.5) assert len(server.active_connections) == 1 @@ -191,7 +189,7 @@ async def test_serial_poll(self, client, server, use_port): assert not client.recv_buffer client.close() server.close() - OldSerialTransport.force_poll = False + SerialTransport.force_poll = False @pytest.mark.parametrize( ("use_comm_type", "use_host"), diff --git a/test/transport/test_serial.py b/test/transport/test_serial.py index 484df322f..2065aa434 100644 --- a/test/transport/test_serial.py +++ b/test/transport/test_serial.py @@ -10,8 +10,8 @@ import pytest from pymodbus.transport.serialtransport import ( - OldSerialTransport, - SerialSync, + SerialInterface, + SerialTransport, create_serial_connection, ) @@ -24,7 +24,7 @@ class TestTransportSerial: async def test_init(self): """Test null modem init.""" - OldSerialTransport( + SerialTransport( asyncio.get_running_loop(), mock.Mock(), "dummy", @@ -37,7 +37,7 @@ async def test_init(self): async def test_loop(self): """Test asyncio abstract methods.""" - comm = OldSerialTransport( + comm = SerialTransport( asyncio.get_running_loop(), mock.Mock(), "dummy", @@ -52,7 +52,7 @@ async def test_loop(self): @pytest.mark.parametrize("inx", range(0, 11)) async def test_abstract_methods(self, inx): """Test asyncio abstract methods.""" - comm = OldSerialTransport( + comm = SerialTransport( asyncio.get_running_loop(), mock.Mock(), "dummy", @@ -80,12 +80,11 @@ async def test_abstract_methods(self, inx): @pytest.mark.parametrize("inx", range(0, 4)) async def test_external_methods(self, inx): """Test external methods.""" - comm = OldSerialTransport( + comm = SerialTransport( mock.MagicMock(), mock.Mock(), "dummy", None, None, None, None, None ) - comm.sync_serial.read = mock.MagicMock(return_value="abcd") # type: ignore[method-assign] - comm.sync_serial.write = mock.MagicMock(return_value=4) # type: ignore[method-assign] - comm.sync_serial.fileno = mock.MagicMock(return_value=2) # type: ignore[method-assign] + comm.sync_serial.sync_read = mock.MagicMock(return_value="abcd") # type: ignore[method-assign] + comm.sync_serial.sync_write = mock.MagicMock(return_value=4) # type: ignore[method-assign] comm.async_loop.add_writer = mock.MagicMock() comm.async_loop.add_reader = mock.MagicMock() comm.async_loop.remove_writer = mock.MagicMock() @@ -101,11 +100,12 @@ async def test_external_methods(self, inx): def test_serial_sync_methods(self): """Test serial sync.""" - transport = SerialSync() + transport = SerialInterface() transport.inter_byte_timeout transport.timeout transport.write_timeout transport.is_open + # transport.fileno @pytest.mark.skipif(os.name == "nt", reason="Windows not supported") async def test_create_serial(self): @@ -117,12 +117,10 @@ async def test_create_serial(self): assert protocol transport.close() - @pytest.mark.skipif( - OldSerialTransport.force_poll, reason="Serial poll not supported" - ) + @pytest.mark.skipif(SerialTransport.force_poll, reason="Serial poll not supported") async def test_force_poll(self): """Test external methods.""" - OldSerialTransport.force_poll = True + SerialTransport.force_poll = True transport, protocol = await create_serial_connection( asyncio.get_running_loop(), mock.Mock, "dummy" ) @@ -130,14 +128,12 @@ async def test_force_poll(self): assert transport assert protocol transport.close() - OldSerialTransport.force_poll = False + SerialTransport.force_poll = False - @pytest.mark.skipif( - OldSerialTransport.force_poll, reason="Serial poll not supported" - ) + @pytest.mark.skipif(SerialTransport.force_poll, reason="Serial poll not supported") async def test_write_force_poll(self): """Test write with poll.""" - OldSerialTransport.force_poll = True + SerialTransport.force_poll = True transport, _ = await create_serial_connection( asyncio.get_running_loop(), mock.Mock, "dummy" ) @@ -145,11 +141,11 @@ async def test_write_force_poll(self): transport.write(b"abcd") await asyncio.sleep(0.5) transport.close() - OldSerialTransport.force_poll = False + SerialTransport.force_poll = False async def test_close(self): """Test close.""" - comm = OldSerialTransport( + comm = SerialTransport( asyncio.get_running_loop(), mock.Mock(), "dummy", @@ -165,7 +161,7 @@ async def test_close(self): @pytest.mark.skipif(os.name == "nt", reason="Windows not supported") async def test_polling(self): """Test polling.""" - comm = OldSerialTransport( + comm = SerialTransport( asyncio.get_running_loop(), mock.Mock(), "dummy", @@ -176,14 +172,14 @@ async def test_polling(self): None, ) comm.sync_serial = mock.MagicMock() - comm.sync_serial.read.side_effect = asyncio.CancelledError("test") + comm.sync_serial.sync_read.side_effect = asyncio.CancelledError("test") with suppress(asyncio.CancelledError): await comm.polling_task() @pytest.mark.skipif(os.name == "nt", reason="Windows not supported") async def test_poll_task(self): """Test polling.""" - comm = OldSerialTransport( + comm = SerialTransport( asyncio.get_running_loop(), mock.Mock(), "dummy", @@ -194,13 +190,13 @@ async def test_poll_task(self): None, ) comm.sync_serial = mock.MagicMock() - comm.sync_serial.read.side_effect = SerialSync.SerialException("test") + comm.sync_serial.sync_read.side_effect = SerialInterface.SerialException("test") await comm.polling_task() @pytest.mark.skipif(os.name == "nt", reason="Windows not supported") async def test_poll_task2(self): """Test polling.""" - comm = OldSerialTransport( + comm = SerialTransport( asyncio.get_running_loop(), mock.Mock(), "dummy", @@ -211,16 +207,15 @@ async def test_poll_task2(self): None, ) comm.sync_serial = mock.MagicMock() - comm.sync_serial = mock.MagicMock() - comm.sync_serial.write.return_value = 4 + comm.sync_serial.sync_write.return_value = 4 comm.intern_write_buffer.append(b"abcd") - comm.sync_serial.read.side_effect = SerialSync.SerialException("test") + comm.sync_serial.sync_read.side_effect = SerialInterface.SerialException("test") await comm.polling_task() @pytest.mark.skipif(os.name == "nt", reason="Windows not supported") async def test_write_exception(self): """Test write exception.""" - comm = OldSerialTransport( + comm = SerialTransport( asyncio.get_running_loop(), mock.Mock(), "dummy", @@ -231,15 +226,17 @@ async def test_write_exception(self): None, ) comm.sync_serial = mock.MagicMock() - comm.sync_serial.write.side_effect = BlockingIOError("test") + comm.sync_serial.sync_write.side_effect = BlockingIOError("test") comm.intern_write_ready() - comm.sync_serial.write.side_effect = SerialSync.SerialException("test") + comm.sync_serial.sync_write.side_effect = SerialInterface.SerialException( + "test" + ) comm.intern_write_ready() @pytest.mark.skipif(os.name == "nt", reason="Windows not supported") async def test_write_ok(self): """Test write exception.""" - comm = OldSerialTransport( + comm = SerialTransport( asyncio.get_running_loop(), mock.Mock(), "dummy", @@ -250,14 +247,14 @@ async def test_write_ok(self): None, ) comm.sync_serial = mock.MagicMock() - comm.sync_serial.write.return_value = 4 + comm.sync_serial.sync_write.return_value = 4 comm.intern_write_buffer.append(b"abcd") comm.intern_write_ready() @pytest.mark.skipif(os.name == "nt", reason="Windows not supported") async def test_write_len(self): """Test write exception.""" - comm = OldSerialTransport( + comm = SerialTransport( asyncio.get_running_loop(), mock.Mock(), "dummy", @@ -268,7 +265,7 @@ async def test_write_len(self): None, ) comm.sync_serial = mock.MagicMock() - comm.sync_serial.write.return_value = 3 + comm.sync_serial.sync_write.return_value = 3 comm.async_loop.add_writer = mock.Mock() comm.intern_write_buffer.append(b"abcd") comm.intern_write_ready() @@ -278,15 +275,13 @@ async def test_write_len(self): async def test_zero_length_write_retains_buffer(self, polling, writes): """A nonblocking zero-byte write must not drop a pending RTU frame.""" loop = mock.MagicMock() - comm = OldSerialTransport( - loop, mock.Mock(), "dummy", None, None, None, None, None - ) + comm = SerialTransport(loop, mock.Mock(), "dummy", None, None, None, None, None) if polling: comm.poll_task = mock.Mock() serial_write = mock.MagicMock(side_effect=writes) comm.intern_write_buffer.append(b"abcd") - with mock.patch.object(comm.sync_serial, "write", serial_write): + with mock.patch.object(comm.sync_serial, "sync_write", serial_write): sent = 0 for written in writes: comm.intern_write_ready() @@ -305,7 +300,7 @@ async def test_zero_length_write_retains_buffer(self, polling, writes): @pytest.mark.skipif(os.name == "nt", reason="Windows not supported") async def test_write_force(self): """Test write exception.""" - comm = OldSerialTransport( + comm = SerialTransport( asyncio.get_running_loop(), mock.Mock(), "dummy", @@ -317,14 +312,14 @@ async def test_write_force(self): ) comm.poll_task = True # type: ignore[assignment] comm.sync_serial = mock.MagicMock() - comm.sync_serial.write.return_value = 3 + comm.sync_serial.sync_write.return_value = 3 comm.intern_write_buffer.append(b"abcd") comm.intern_write_ready() @pytest.mark.skipif(os.name == "nt", reason="Windows not supported") async def test_read_ready(self): """Test polling.""" - comm = OldSerialTransport( + comm = SerialTransport( asyncio.get_running_loop(), mock.Mock(), "dummy", @@ -336,11 +331,11 @@ async def test_read_ready(self): ) comm.sync_serial = mock.MagicMock() comm.intern_protocol = mock.Mock() - comm.sync_serial.read = mock.Mock() - comm.sync_serial.read.return_value = b"" + comm.sync_serial.sync_read = mock.Mock() + comm.sync_serial.sync_read.return_value = b"" comm.intern_read_ready() comm.intern_protocol.data_received.assert_not_called() - comm.sync_serial.read.return_value = b"abcd" + comm.sync_serial.sync_read.return_value = b"abcd" comm.intern_read_ready() comm.intern_protocol.data_received.assert_called_once() @@ -349,7 +344,7 @@ async def test_import_pyserial(self): with mock.patch.dict(sys.modules, {"no_modules": None}) as mock_modules: del mock_modules["serial"] with pytest.raises(RuntimeError): - OldSerialTransport( + SerialTransport( asyncio.get_running_loop(), mock.Mock(), "dummy",