Update async tests. (#1003)

Author: janiversen

examples/client_async.py

@@ -42,13 +42,13 @@
 )
 
 
-def setup_async_client(loop):
+async def setup_async_client(loop):
     """Run client setup."""
     args = get_commandline()
     _logger.info("### Create client object")
 
     if args.comm == "tcp":
-        client = AsyncModbusTCPClient(
+        client = await AsyncModbusTCPClient(
             host="127.0.0.1",  # define tcp address where to connect to.
             port=args.port,  # on which port
             framer=ModbusSocketFramer,  # how to interpret the messages
@@ -60,7 +60,7 @@ def setup_async_client(loop):
             loop=loop,
         )
     elif args.comm == "udp":
-        client = AsyncModbusUDPClient(
+        client = await AsyncModbusUDPClient(
             host="localhost",  # define tcp address where to connect to.
             port=args.port,  # on which port
             framer=args.framer,  # how to interpret the messages
@@ -72,7 +72,7 @@ def setup_async_client(loop):
             loop=loop,
         )
     elif args.comm == "serial":
-        client = AsyncModbusSerialClient(
+        client = await AsyncModbusSerialClient(
             port=args.port,  # serial port
             framer=args.framer,  # how to interpret the messages
             stopbits=1,  # The number of stop bits to use
@@ -85,7 +85,7 @@ def setup_async_client(loop):
             loop=loop,
         )
     elif args.comm == "tls":
-        client = AsyncModbusTLSClient(
+        client = await AsyncModbusTLSClient(
             host="localhost",  # define tcp address where to connect to.
             port=args.port,  # on which port
             sslctx=None,  # ssl control
@@ -100,7 +100,7 @@ def setup_async_client(loop):
             strict=True,  # use strict timing, t1.5 for Modbus RTU
             loop=loop,
         )
-    return loop, client
+    return client
 
 
 async def run_async_client(modbus_calls=None):
@@ -125,7 +125,7 @@ def start_loop(loop):
     assert loop.is_running()  # nosec
     asyncio.set_event_loop(loop)
 
-    loop, client = setup_async_client(loop)
+    client = await setup_async_client(loop)
 
     # Run supplied modbus calls
     if modbus_calls:

pymodbus/client/asynchronous/serial.py

@@ -1,5 +1,4 @@
 """SERIAL communication."""
-import asyncio
 import logging
 
 from pymodbus.factory import ClientDecoder
@@ -11,6 +10,15 @@
 _logger = logging.getLogger(__name__)
 
 
+async def init_serial_client(port, proto_cls, framer, **kwargs):
+    """Initialize UDP client with helper function."""
+    client = AsyncioModbusSerialClient(
+        port, proto_cls, framer=framer, **kwargs
+    )
+    await client.connect()
+    return client
+
+
 class AsyncModbusSerialClient(AsyncioModbusSerialClient):
     """Actual Async Serial Client to be used.
 
@@ -32,18 +40,7 @@ def __new__(cls, framer, port, **kwargs):
         :return:
         """
         framer = framer(ClientDecoder())
-        try:
-            loop = kwargs.pop("loop", None) or asyncio.get_running_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-
         proto_cls = kwargs.get("proto_cls") or ModbusClientProtocol
 
-        client = AsyncioModbusSerialClient(port, proto_cls, framer, **kwargs)
-        coro = client.connect
-        if not loop.is_running():
-            loop.run_until_complete(coro())
-        else:  # loop is not asyncio.get_event_loop():
-            future = asyncio.run_coroutine_threadsafe(coro(), loop=loop)
-            future.result()
+        client = init_serial_client(port, proto_cls, framer=framer, **kwargs)
         return client

pymodbus/client/asynchronous/tcp.py

@@ -1,12 +1,13 @@
 """TCP communication."""
-import asyncio
 import logging
 
 from pymodbus.client.asynchronous.async_io import (
     init_tcp_client,
     ReconnectingAsyncioModbusTcpClient,
 )
 from pymodbus.constants import Defaults
+from pymodbus.factory import ClientDecoder
+from pymodbus.transaction import ModbusSocketFramer
 
 _logger = logging.getLogger(__name__)
 
@@ -22,6 +23,7 @@ def __new__(
         cls,
         host="127.0.0.1",
         port=Defaults.Port,
+        framer=None,
         **kwargs
     ):
         """Scheduler to use async_io (asyncio)
@@ -34,23 +36,7 @@ def __new__(
         :param kwargs: Other extra args specific to Backend being used
         :return:
         """
-        try:
-            loop = kwargs.pop("loop", None) or asyncio.get_event_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-
+        framer = framer or ModbusSocketFramer(ClientDecoder())
         proto_cls = kwargs.pop("proto_cls", None)
 
-        if not loop.is_running():
-            asyncio.set_event_loop(loop)
-            cor = init_tcp_client(proto_cls, host, port, **kwargs)
-            client = loop.run_until_complete(asyncio.gather(cor))[0]
-
-        elif loop is asyncio.get_event_loop():
-            cor = init_tcp_client(proto_cls, host, port, **kwargs)
-            client = asyncio.create_task(cor)
-        else:
-            cor = init_tcp_client(proto_cls, host, port, **kwargs)
-            future = asyncio.run_coroutine_threadsafe(cor, loop=loop)
-            client = future.result()
-        return client
+        return init_tcp_client(proto_cls, host, port, framer=framer, **kwargs)

pymodbus/client/asynchronous/tls.py

@@ -1,5 +1,4 @@
 """TLS communication."""
-import asyncio
 import logging
 
 from pymodbus.client.asynchronous.async_io import (
@@ -44,26 +43,9 @@ def __new__(
         :return:
         """
         framer = framer or ModbusTlsFramer(ClientDecoder())
-        try:
-            loop = kwargs.pop("loop", None) or asyncio.get_event_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-
         proto_cls = kwargs.pop("proto_cls", None)
-        if not loop.is_running():
-            asyncio.set_event_loop(loop)
-            cor = init_tls_client(
-                proto_cls, host, port, sslctx, server_hostname, framer, **kwargs
-            )
-            client = loop.run_until_complete(asyncio.gather(cor))[0]
-        elif loop is asyncio.get_event_loop():
-            return init_tls_client(
-                proto_cls, host, port, sslctx, server_hostname, framer, **kwargs
-            )
-        else:
-            cor = init_tls_client(
-                proto_cls, host, port, sslctx, server_hostname, framer, **kwargs
-            )
-            future = asyncio.run_coroutine_threadsafe(cor, loop=loop)
-            client = future.result()
+
+        client = init_tls_client(
+            proto_cls, host, port, sslctx, server_hostname, framer, **kwargs
+        )
         return client

pymodbus/client/asynchronous/udp.py

@@ -1,12 +1,13 @@
 """UDP communication."""
-import asyncio
 import logging
 
 from pymodbus.client.asynchronous.async_io import (
     init_udp_client,
     ReconnectingAsyncioModbusUdpClient,
 )
 from pymodbus.constants import Defaults
+from pymodbus.factory import ClientDecoder
+from pymodbus.transaction import ModbusSocketFramer
 
 _logger = logging.getLogger(__name__)
 
@@ -22,6 +23,7 @@ def __new__(
         cls,
         host="127.0.0.1",
         port=Defaults.Port,
+        framer=None,
         **kwargs
     ):
         """Do setup of client.
@@ -34,20 +36,8 @@ def __new__(
         :param kwargs: Other extra args specific to Backend being used
         :return:
         """
-        try:
-            loop = kwargs.pop("loop", None) or asyncio.get_event_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-
+        framer = framer or ModbusSocketFramer(ClientDecoder())
         proto_cls = kwargs.pop("proto_cls", None)
-        cor = init_udp_client(proto_cls, host, port, **kwargs)
-        if not loop.is_running():
-            cor = init_udp_client(proto_cls, host, port)
-            client = loop.run_until_complete(asyncio.gather(cor))[0]
-        elif loop is asyncio.get_event_loop():
-            return init_udp_client(proto_cls, host, port)
-
-        cor = init_udp_client(proto_cls, host, port)
-        client = asyncio.run_coroutine_threadsafe(cor, loop=loop)
-        client = client.result()
+
+        client = init_udp_client(proto_cls, host, port, framer=framer, **kwargs)
         return client

test/test_client_async.py

@@ -4,18 +4,19 @@
 import contextlib
 import ssl
 import unittest
-from unittest.mock import patch
 
 import pytest
 
 from pymodbus.client.asynchronous.async_io import (
     AsyncioModbusSerialClient,
     ReconnectingAsyncioModbusTcpClient,
     ReconnectingAsyncioModbusTlsClient,
+    ReconnectingAsyncioModbusUdpClient,
 )
 from pymodbus.client.asynchronous.serial import AsyncModbusSerialClient
 from pymodbus.client.asynchronous.tls import AsyncModbusTLSClient
 from pymodbus.client.asynchronous.tcp import AsyncModbusTCPClient
+from pymodbus.client.asynchronous.udp import AsyncModbusUDPClient
 from pymodbus.transaction import (
     ModbusAsciiFramer,
     ModbusBinaryFramer,
@@ -50,11 +51,16 @@ class TestAsynchronousClient:
     # -----------------------------------------------------------------------#
     # Test TCP Client client
     # -----------------------------------------------------------------------#
-    def test_tcp_asyncio_client(self):
+    def test_tcp_no_asyncio_client(self):
         """Test the TCP client."""
         client = AsyncModbusTCPClient()
+        assert asyncio.iscoroutine(client)
+
+    async def test_tcp_asyncio_client(self):
+        """Test the TCP client."""
+        client = await AsyncModbusTCPClient()
         assert isinstance(client, ReconnectingAsyncioModbusTcpClient)  # nosec
-        # assert isinstance(client.framer, ModbusSocketFramer)  # nosec
+        assert isinstance(client.framer, ModbusSocketFramer)  # nosec
         assert client.port == 502  # nosec
 
         client.stop()
@@ -64,9 +70,14 @@ def test_tcp_asyncio_client(self):
     # Test TLS Client client
     # -----------------------------------------------------------------------#
 
-    def test_tls_asyncio_client(self):
+    def test_tls_no_asyncio_client(self):
         """Test the TLS AsyncIO client."""
         client = AsyncModbusTLSClient()
+        assert asyncio.iscoroutine(client)
+
+    async def test_tls_asyncio_client(self):
+        """Test the TLS AsyncIO client."""
+        client = await AsyncModbusTLSClient()
         assert isinstance(client, ReconnectingAsyncioModbusTlsClient)  # nosec
         assert isinstance(client.framer, ModbusTlsFramer)  # nosec
         assert isinstance(client.sslctx, ssl.SSLContext)  # nosec
@@ -78,22 +89,30 @@ def test_tls_asyncio_client(self):
     # -----------------------------------------------------------------------#
     # Test UDP client
     # -----------------------------------------------------------------------#
-    def test_udp_asyncio_client(self):
+    def test_udp_no_asyncio_client(self):
         """Test the udp asyncio client"""
-        # client = AsyncModbusUDPClient()
-        # assert isinstance(client, ReconnectingAsyncioModbusTcpClient)  # nosec
-        # assert isinstance(client.framer, ModbusSocketFramer)  # nosec
-        # assert client.port == 502  # nosec
+        client = AsyncModbusUDPClient()
+        assert asyncio.iscoroutine(client)
 
-        # client.stop()
-        # assert client.host is None  # nosec
+    async def test_udp_asyncio_client(self):
+        """Test the udp asyncio client"""
+        client = await AsyncModbusUDPClient()
+        assert isinstance(client, ReconnectingAsyncioModbusUdpClient)  # nosec
+        assert isinstance(client.framer, ModbusSocketFramer)  # nosec
+        assert client.port == 502  # nosec
+
+        client.stop()
+        assert client.host is None  # nosec
 
     # -----------------------------------------------------------------------#
     # Test Serial client
     # -----------------------------------------------------------------------#
 
-    @patch("asyncio.get_event_loop")
-    @patch("asyncio.gather", side_effect=mock_asyncio_gather)
+    def test_serial_no_asyncio_client(self):
+        """Test that AsyncModbusSerialClient instantiates AsyncioModbusSerialClient for asyncio scheduler."""
+        client = AsyncModbusSerialClient(port="not here", framer=ModbusRtuFramer)
+        assert asyncio.iscoroutine(client)
+
     @pytest.mark.parametrize(
         "framer",
         [
@@ -103,20 +122,14 @@ def test_udp_asyncio_client(self):
             ModbusAsciiFramer,
         ],
     )
-    @pytest.mark.asyncio
     async def test_serial_asyncio_client(
         self,
-        mock_gather,  # pylint: disable=unused-argument
-        mock_event_loop,
         framer,
-    ):  # pylint: disable=unused-argument
+    ):
         """Test that AsyncModbusSerialClient instantiates AsyncioModbusSerialClient for asyncio scheduler."""
-        loop = asyncio.get_event_loop()
-        loop.is_running.side_effect = lambda: False
-        client = AsyncModbusSerialClient(
+        client = await AsyncModbusSerialClient(
             framer=framer,
             port=pytest.SERIAL_PORT,
-            loop=loop,
             baudrate=19200,
             parity="E",
             stopbits=2,
@@ -132,7 +145,6 @@ async def test_serial_asyncio_client(
         assert client.bytesize == 7  # nosec
         asyncio.wait_for(client.connect(), timeout=1)
         client.stop()
-        loop.stop()
 
 
 # ---------------------------------------------------------------------------#