def test_transport_write_from_queue(self, device, loop):
payload = b'\x01\x01'
unit = AsyncioTransport(device, loop, callback=mock.Mock())
unit.write(payload)
device.write.assert_called_once_with(payload)
def run_event_loop():
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
self.rfxcom = AsyncioTransport(dev, loop, callback=self.handler)
#time.sleep(1)
#self.rfxcom.write(b'\r\x00\x00\x01\x03S\x00\xff\x0e/\x00\x00\x00\x00')
loop.run_forever()
def create_transport(self, device, event_loop):
return AsyncioTransport(device,
event_loop,
callbacks={
protocol.TempHumidity:
self.handle_temp_humidity,
'*': self.default_callback
})
def test_transport_read(self, device, loop):
unit = AsyncioTransport(device, loop, callback=mock.Mock())
call_map = {(): b'\x02', (2, ): b'\x01\x01'}
device.read = lambda *x: call_map[x]
self.assertEquals(unit.read(), b'\x02\x01\x01')
def test_transport_read_nothing(self, device, loop):
device.read.return_value = b''
unit = AsyncioTransport(device, loop, callback=mock.Mock())
with mock.patch.object(unit, 'log') as unit_log:
unit.read()
unit_log.warning.assert_called_once_with("READ : Nothing received")
class AsyncioTransportTestCase(TestCase):
"""AsyncioTransport test case."""
@mock.patch('rfxcom.transport.asyncio.AsyncioTransport._setup')
@mock.patch('asyncio.async')
@mock.patch('asyncio.AbstractEventLoop')
@mock.patch('serial.Serial')
def test_transport_setup(self, device, loop, async, _setup):
AsyncioTransport(device, loop, callback=mock.Mock())
async .assert_called_once_with(_setup())
def test_transport_read_empty_patcket(self, device, loop):
device.read.return_value = b'\x00'
unit = AsyncioTransport(device, loop, callback=mock.Mock())
with mock.patch.object(unit, 'log') as unit_log:
unit.read()
unit_log.warning.assert_called_once_with(
"READ : Empty packet (Got \\x00)")
def test_transport_setup(self, unit_write, device, loop):
unit = AsyncioTransport(device, loop, callback=mock.Mock())
unit.setup()
loop.remove_writer.assert_called_with(device.fd)
device.write.assert_called_once(RESET_PACKET)
loop.call_later.assert_any_call(mock.ANY,
super(AsyncioTransport, unit).write,
STATUS_PACKET)
unit_write.assert_called_once_with(MODE_PACKET)
def collect(dev_name, callbacks):
loop = get_event_loop()
try:
AsyncioTransport(dev_name, loop, callbacks=callbacks)
loop.run_forever()
finally:
loop.close()
def test_transport_write_from_queue(self, device, loop):
payload = b'\x01\x01'
unit = AsyncioTransport(device, loop, callback=mock.Mock())
# Call write and verify it was added to the queue
unit.write(payload)
self.assertIn(payload, unit.write_queue)
unit._writer()
device.write.assert_called_once_with(payload)
def collect(dev_name=None, callbacks=None):
if callbacks is None:
callbacks = dict(load_handlers(config.PACKET_HANDLERS))
loop = get_event_loop()
try:
logger.info("Starting collection from:", dev_name)
AsyncioTransport(dev_name, loop, callbacks=callbacks)
loop.run_forever()
finally:
loop.close()
def test_transport_read(self, device, loop, callback):
unit = AsyncioTransport(device, loop, callback=mock.Mock())
def fake_read(*x):
data = {(): b'\x02', (2, ): b'\x01\x01'}
return data[x]
device.read.side_effect = fake_read
expected_result = b'\x02\x01\x01'
self.assertEquals(unit.read(), expected_result)
callback.assert_called_once_with(expected_result)
def test_transport_do_callback(self, device, loop, get_parser):
cb = mock.Mock()
get_parser.return_value = (cb, "test")
unit = AsyncioTransport(device, loop, callback=mock.Mock())
def fake_read(*x):
data = {(): b'\x02', (2, ): b'\x01\x01'}
return data[x]
device.read.side_effect = fake_read
expected_result = b'\x02\x01\x01'
self.assertEquals(unit.read(), expected_result)
loop.call_soon_threadsafe.assert_called_once_with(
AsyncioTransport._do_async_callback, cb, "test")
def test_transport__setup(self, device, loop, sleep, mode, status, reset):
unit = AsyncioTransport(device, loop, callback=mock.Mock())
# reset mocks which have been 'called' by the constructor
device.reset_mock()
loop.reset_mock()
# run: exaust the coroutine generator
execute_coroutine(unit._setup())
loop.add_reader.assert_called_with(device.fd, unit.read)
reset.assert_called_once_with()
sleep.assert_has_calls((mock.ANY, mock.ANY))
slept_time = sleep.call_args[0][0]
# by spec it needs to be between 0.5ms and 9000ms
self.assertGreater(slept_time, 0.05)
self.assertLess(slept_time, 9)
mode.assert_called_once_with()
status.assert_called_once_with()
def main():
dictConfig(LOGGING)
loop = get_event_loop()
parser = ArgumentParser()
parser.add_argument('device')
args = parser.parse_args()
try:
rfxcom = AsyncioTransport(args.device,
loop,
callbacks={
protocol.Status: printer,
protocol.Elec: printer,
protocol.TempHumidity: printer,
'*': printer,
})
loop.call_later(2, partial(write, rfxcom))
loop.run_forever()
finally:
loop.close()
def test_transport_constructor(self, device, loop):
unit = AsyncioTransport(device, loop, callback=mock.Mock())
loop.add_writer.assert_called_once_with(device.fd, unit.setup)
