def testTcpClientConnect(self, mock_iostream, mock_ioloop):
""" Test the tornado tcp client client connect """
client = AsyncModbusTCPClient(port=5020)
self.assertTrue(client.port, 5020)
self.assertFalse(client._connected)
client.connect()
self.assertTrue(client._connected)
def io_loop_factory(host="127.0.0.1",
port=Defaults.Port,
framer=None,
source_address=None,
timeout=None,
**kwargs):
"""
Factory to create Tornado based asynchronous tcp clients
:param host: Host IP address
:param port: Port
:param framer: Modbus Framer
:param source_address: Bind address
:param timeout: Timeout in seconds
:param kwargs:
:return: event_loop_thread and tornado future
"""
from tornado.ioloop import IOLoop
from pymodbus.client.asynchronous.tornado import AsyncModbusTCPClient as \
Client
ioloop = IOLoop()
protocol = EventLoopThread("ioloop", ioloop.start, ioloop.stop)
protocol.start()
client = Client(host=host,
port=port,
framer=framer,
source_address=source_address,
timeout=timeout,
ioloop=ioloop,
**kwargs)
future = client.connect()
return protocol, future
def testTcpClientConnect(self, mock_iostream, mock_ioloop):
""" Test the tornado tcp client client connect """
client = AsyncModbusTCPClient(port=5020)
self.assertTrue(client.port, 5020)
self.assertFalse(client._connected)
client.connect()
self.assertTrue(client._connected)
def io_loop_factory(host="127.0.0.1", port=Defaults.Port, framer=None,
source_address=None, timeout=None, **kwargs):
"""
Factory to create Tornado based asynchronous tcp clients
:param host: Host IP address
:param port: Port
:param framer: Modbus Framer
:param source_address: Bind address
:param timeout: Timeout in seconds
:param kwargs:
:return: event_loop_thread and tornado future
"""
from tornado.ioloop import IOLoop
from pymodbus.client.asynchronous.tornado import AsyncModbusTCPClient as \
Client
ioloop = IOLoop()
protocol = EventLoopThread("ioloop", ioloop.start, ioloop.stop)
protocol.start()
client = Client(host=host, port=port, framer=framer,
source_address=source_address,
timeout=timeout, ioloop=ioloop, **kwargs)
future = client.connect()
return protocol, future
def testTcpClientInit(self):
""" Test the tornado tcp client client initialize """
client = AsyncModbusTCPClient()
self.assertEqual(0, len(list(client.transaction)))
self.assertTrue(isinstance(client.framer, ModbusSocketFramer))
framer = object()
client = AsyncModbusTCPClient(framer=framer)
self.assertTrue(framer is client.framer)
def testBaseClientExecute(self, mock_iostream, mock_ioloop):
""" Test the BaseTornado client execute method """
client = AsyncModbusTCPClient(port=5020)
client.connect()
client.stream = Mock()
client.stream.write = Mock()
request = ReadCoilsRequest(1, 1)
d = client.execute(request)
tid = request.transaction_id
self.assertEqual(d, client.transaction.getTransaction(tid))
def testBaseClientHandleResponse(self, mock_iostream, mock_ioloop):
""" Test the BaseTornado client handles responses """
client = AsyncModbusTCPClient(port=5020)
client.connect()
out = []
reply = ReadCoilsRequest(1, 1)
reply.transaction_id = 0x00
# handle skipped cases
client._handle_response(None)
client._handle_response(reply)
# handle existing cases
d = client._build_response(0x00)
d.add_done_callback(lambda v: out.append(v))
client._handle_response(reply)
self.assertEqual(out[0].result(), reply)
def testBaseClientOn_receive(self, mock_iostream, mock_ioloop):
""" Test the BaseTornado client data received """
client = AsyncModbusTCPClient(port=5020)
client.connect()
out = []
data = b'\x00\x00\x12\x34\x00\x06\xff\x01\x01\x02\x00\x04'
# setup existing request
d = client._build_response(0x00)
d.add_done_callback(lambda v: out.append(v))
client.on_receive(data)
self.assertTrue(isinstance(d.result(), ReadCoilsResponse))
data = b''
out = []
d = client._build_response(0x01)
client.on_receive(data)
d.add_done_callback(lambda v: out.append(v))
self.assertFalse(out)
def testBaseClientOn_receive(self, mock_iostream, mock_ioloop):
""" Test the BaseTornado client data received """
client = AsyncModbusTCPClient(port=5020)
client.connect()
out = []
data = b'\x00\x00\x12\x34\x00\x06\xff\x01\x01\x02\x00\x04'
# setup existing request
d = client._build_response(0x00)
d.add_done_callback(lambda v: out.append(v))
client.on_receive(data)
self.assertTrue(isinstance(out[0].result(), ReadCoilsResponse))
data = b''
out = []
d = client._build_response(0x01)
client.on_receive(data)
d.add_done_callback(lambda v: out.append(v))
self.assertFalse(out)
def testTcpClientDisconnect(self, mock_iostream, mock_ioloop):
""" Test the tornado tcp client client disconnect """
client = AsyncModbusTCPClient(port=5020)
client.connect()
def handle_failure(failure):
self.assertTrue(isinstance(failure.exception(), ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
self.assertTrue(client._connected)
client.close()
self.assertFalse(client._connected)
def testBaseClientExecute(self, mock_iostream, mock_ioloop):
""" Test the BaseTornado client execute method """
client = AsyncModbusTCPClient(port=5020)
client.connect()
client.stream = Mock()
client.stream.write = Mock()
request = ReadCoilsRequest(1, 1)
d = client.execute(request)
tid = request.transaction_id
self.assertEqual(d, client.transaction.getTransaction(tid))
def testTcpClientDisconnect(self, mock_iostream, mock_ioloop):
""" Test the tornado tcp client client disconnect """
client = AsyncModbusTCPClient(port=5020)
client.connect()
def handle_failure(failure):
self.assertTrue(isinstance(failure.exception(), ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
self.assertTrue(client._connected)
client.close()
self.assertFalse(client._connected)
def testBaseClientHandleResponse(self, mock_iostream, mock_ioloop):
""" Test the BaseTornado client handles responses """
client = AsyncModbusTCPClient(port=5020)
client.connect()
out = []
reply = ReadCoilsRequest(1, 1)
reply.transaction_id = 0x00
# handle skipped cases
client._handle_response(None)
client._handle_response(reply)
# handle existing cases
d = client._build_response(0x00)
d.add_done_callback(lambda v: out.append(v))
client._handle_response(reply)
self.assertEqual(d.result(), reply)
