def testSerialClientInit(self):
""" Test the tornado serial client client initialize """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP, framer=ModbusRtuFramer(ClientDecoder()), port=SERIAL_PORT)
self.assertEqual(0, len(list(client.transaction)))
self.assertTrue(isinstance(client.framer, ModbusRtuFramer))
framer = object()
client = AsyncModbusSerialClient(framer=framer)
self.assertTrue(framer is client.framer)
def testSerialClientConnect(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client connect """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
self.assertTrue(client.port, SERIAL_PORT)
self.assertFalse(client._connected)
client.connect()
self.assertTrue(client._connected)
client.close()
def testSerialClientExecute(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client execute method """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
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 testSerialClientBuildResponse(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client builds responses """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
self.assertEqual(0, len(list(client.transaction)))
def handle_failure(failure):
exc = failure.exception()
self.assertTrue(isinstance(exc, ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
self.assertEqual(0, len(list(client.transaction)))
client._connected = True
d = client._build_response(0x00)
self.assertEqual(1, len(list(client.transaction)))
def testSerialClientBuildResponse(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client builds responses """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
self.assertEqual(0, len(list(client.transaction)))
def handle_failure(failure):
exc = failure.exception()
self.assertTrue(isinstance(exc, ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
self.assertEqual(0, len(list(client.transaction)))
client._connected = True
d = client._build_response(0x00)
self.assertEqual(1, len(list(client.transaction)))
def testSerialClientHandleResponse(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client handles responses """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
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 io_loop_factory(port=None, framer=None, **kwargs):
"""
Factory to create Tornado based asynchronous serial clients
:param port: Serial port
:param framer: Modbus Framer
:param kwargs:
:return: event_loop_thread and tornado future
"""
from tornado.ioloop import IOLoop
from pymodbus.client.asynchronous.tornado import (AsyncModbusSerialClient as
Client)
ioloop = IOLoop()
protocol = EventLoopThread("ioloop", ioloop.start, ioloop.stop)
protocol.start()
client = Client(port=port, framer=framer, ioloop=ioloop, **kwargs)
future = client.connect()
return protocol, future
def io_loop_factory(port=None, framer=None, **kwargs):
"""
Factory to create Tornado based asynchronous serial clients
:param port: Serial port
:param framer: Modbus Framer
:param kwargs:
:return: event_loop_thread and tornado future
"""
from tornado.ioloop import IOLoop
from pymodbus.client.asynchronous.tornado import (AsyncModbusSerialClient as
Client)
ioloop = IOLoop()
protocol = EventLoopThread("ioloop", ioloop.start, ioloop.stop)
protocol.start()
client = Client(port=port, framer=framer, ioloop=ioloop, **kwargs)
future = client.connect()
return protocol, future
def testSerialClientConnect(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client connect """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
self.assertTrue(client.port, SERIAL_PORT)
self.assertFalse(client._connected)
client.connect()
self.assertTrue(client._connected)
client.close()
def testSerialClientDisconnect(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client disconnect """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
client.connect()
self.assertTrue(client._connected)
def handle_failure(failure):
self.assertTrue(isinstance(failure.exception(), ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
client.close()
self.assertFalse(client._connected)
def testSerialClientExecute(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client execute method """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
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 testSerialClientDisconnect(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client disconnect """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
client.connect()
self.assertTrue(client._connected)
def handle_failure(failure):
self.assertTrue(isinstance(failure.exception(), ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
client.close()
self.assertFalse(client._connected)
def testSerialClientHandleResponse(self, mock_serial, mock_seriostream,
mock_ioloop):
""" Test the tornado serial client client handles responses """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
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)