def test_background_consumer_passthrough(self):
action = master_api.basic_action()
fields = {'action_type': 1, 'action_number': 2}
pty = DummyPty([action.create_input(1, fields)])
SetUpTestInjections(controller_serial=pty)
got_output = {'passed': False}
def callback(output_):
""" Callback that check if the correct result was returned for OL. """
self.assertEqual([(3, int(12 * 10.0 / 6.0))], output_['outputs'])
got_output['passed'] = True
consumer = BackgroundConsumer(master_api.output_list(), 0, callback, True)
comm = MasterCommunicator(init_master=False)
comm.enable_passthrough()
comm.register_consumer(consumer)
comm.start()
pty.fd.write(bytearray(b'OL\x00\x01'))
pty.fd.write(bytearray(b'\x03\x0c\r\n'))
pty.master_reply(action.create_output(1, {'resp': 'OK'}))
output = comm.do_command(action, fields)
self.assertEqual('OK', output['resp'])
try:
consumer._consume()
except:
pass # Just ensure it has at least consumed once
self.assertEqual(True, got_output['passed'])
self.assertEqual(bytearray(b'OL\x00\x01\x03\x0c\r\n'), comm.get_passthrough_data())
def test_split_data(self):
action = master_api.basic_action()
fields = {'action_type': 1, 'action_number': 2}
sequence = []
for i in range(1, 18):
sequence.append(action.create_input(i, fields))
pty = DummyPty(sequence)
SetUpTestInjections(controller_serial=pty)
comm = MasterCommunicator(init_master=False)
comm.start()
for i in range(1, 18):
data = action.create_output(i, {'resp': 'OK'})
ready = threading.Event()
def write():
pty.master_reply(data[:i])
ready.set()
pty.master_wait()
pty.fd.write(data[i:])
thread = threading.Thread(target=write)
thread.start()
ready.wait(2)
output = comm.do_command(action, fields)
self.assertEqual('OK', output['resp'])
thread.join(2)
assert not thread.is_alive()
def test_maintenance_mode(self):
action = master_api.basic_action(self.master_version)
fields = {'action_type': 1, 'action_number': 2}
pty = DummyPty([
master_api.to_cli_mode().create_input(0),
bytearray(b'error list\r\n'),
bytearray(b'exit\r\n')
])
SetUpTestInjections(controller_serial=pty)
comm = MasterCommunicator(init_master=False)
comm.start()
comm.start_maintenance_mode()
pty.fd.write(bytearray(b'OK'))
self.assertRaises(InMaintenanceModeException, comm.do_command, action,
fields)
self.assertEqual(bytearray(b'OK'), comm.get_maintenance_data())
comm.send_maintenance_data(bytearray(b'error list\r\n'))
pty.fd.write(bytearray(b'the list\n'))
self.assertEqual(bytearray(b'the list\n'), comm.get_maintenance_data())
comm.stop_maintenance_mode()
def test_background_consumer(self):
action = master_api.basic_action()
fields = {'action_type': 1, 'action_number': 2}
pty = DummyPty([action.create_input(1, fields)])
SetUpTestInjections(controller_serial=pty)
got_output = {'phase': 1}
def callback(output):
""" Callback that check if the correct result was returned for OL. """
if got_output['phase'] == 1:
self.assertEqual([(3, int(12 * 10.0 / 6.0))], output['outputs'])
got_output['phase'] = 2
elif got_output['phase'] == 2:
self.assertEqual([(3, int(12 * 10.0 / 6.0)), (5, int(6 * 10.0 / 6.0))],
output['outputs'])
got_output['phase'] = 3
comm = MasterCommunicator(init_master=False)
comm.enable_passthrough()
comm.register_consumer(BackgroundConsumer(master_api.output_list(), 0, callback))
comm.start()
pty.fd.write(bytearray(b'OL\x00\x01\x03\x0c\r\n'))
pty.fd.write(bytearray(b'junkOL\x00\x02\x03\x0c\x05\x06\r\n here'))
pty.master_reply(action.create_output(1, {'resp': 'OK'}))
output = comm.do_command(action, fields)
self.assertEqual('OK', output['resp'])
time.sleep(0.2)
self.assertEqual(3, got_output['phase'])
self.assertEqual(bytearray(b'junk here'), comm.get_passthrough_data())
def test_passthrough_with_commands(self):
action = master_api.basic_action(self.master_version)
fields = {'action_type': 1, 'action_number': 2}
pty = DummyPty([
action.create_input(1, fields),
action.create_input(2, fields),
action.create_input(3, fields)
])
SetUpTestInjections(controller_serial=pty)
comm = MasterCommunicator(init_master=False)
comm.enable_passthrough()
comm.start()
pty.master_reply(
bytearray(b'hello') + action.create_output(1, {'resp': 'OK'}))
self.assertEqual('OK', comm.do_command(action, fields)['resp'])
self.assertEqual(bytearray(b'hello'), comm.get_passthrough_data())
pty.master_reply(
action.create_output(2, {'resp': 'OK'}) + bytearray(b'world'))
self.assertEqual('OK', comm.do_command(action, fields)['resp'])
self.assertEqual(bytearray(b'world'), comm.get_passthrough_data())
pty.master_reply(
bytearray(b'hello') + action.create_output(3, {'resp': 'OK'}) +
bytearray(b' world'))
self.assertEqual('OK', comm.do_command(action, fields)['resp'])
self.assertEqual(bytearray(b'hello world'),
comm.get_passthrough_data())
def test_timeout(self):
action = master_api.basic_action()
fields = {'action_type': 1, 'action_number': 2}
pty = DummyPty([action.create_input(1, fields)])
SetUpTestInjections(controller_serial=pty)
comm = MasterCommunicator(init_master=False)
comm.start()
self.assertRaises(CommunicationTimedOutException, comm.do_command, action, fields)
def test_do_command(self):
action = master_api.basic_action()
fields = {'action_type': 1, 'action_number': 2}
pty = DummyPty([action.create_input(1, fields)])
SetUpTestInjections(controller_serial=pty)
comm = MasterCommunicator(init_master=False)
comm.start()
pty.master_reply(action.create_output(1, {'resp': 'OK'}))
output = comm.do_command(action, fields)
self.assertEqual('OK', output['resp'])
def do_basic_action(self, action_type, action_number, timeout=2):
# type: (int, int, Union[T_co, int]) -> Union[T_co, Dict[str,Any]]
"""
Sends a basic action to the master with the given action type and action number
:param action_type: The action type to execute
:param action_number: The action number to execute
:returns: dict containing the output fields of the command
"""
logger.info('BA: Execute {0} {1}'.format(action_type, action_number))
return self.do_command(
master_api.basic_action(),
{'action_type': action_type,
'action_number': action_number}
)
def test_timeout_ongoing(self):
action = master_api.basic_action()
fields = {'action_type': 1, 'action_number': 2}
pty = DummyPty([action.create_input(1, fields),
action.create_input(2, fields)])
SetUpTestInjections(controller_serial=pty)
comm = MasterCommunicator(init_master=False)
comm.start()
self.assertRaises(CommunicationTimedOutException, comm.do_command, action, fields,
timeout=0.1)
pty.master_reply(action.create_output(2, {'resp': 'OK'}))
output = comm.do_command(action, fields)
self.assertEqual('OK', output['resp'])
def test_maintenance_passthrough(self):
action = master_api.basic_action(self.master_version)
fields = {'action_type': 1, 'action_number': 2}
pty = DummyPty([
master_api.to_cli_mode().create_input(0),
bytearray(b'error list\r\n'),
bytearray(b'exit\r\n')
])
SetUpTestInjections(controller_serial=pty)
comm = MasterCommunicator(init_master=False)
comm.enable_passthrough()
comm.start()
ready = threading.Event()
def get_passthrough():
""" Background thread that reads the passthrough data. """
self.assertEqual('Before maintenance', comm.get_passthrough_data())
ready.set()
self.assertEqual('After maintenance', comm.get_passthrough_data())
thread = threading.Thread(target=get_passthrough)
thread.start()
pty.fd.write(bytearray(b'Before maintenance'))
ready.wait(2)
comm.start_maintenance_mode()
pty.fd.write(bytearray(b'OK'))
time.sleep(0.2)
self.assertRaises(InMaintenanceModeException, comm.do_command, action,
fields)
self.assertEqual(bytearray(b'OK'), comm.get_maintenance_data())
comm.send_maintenance_data(bytearray(b'error list\r\n'))
pty.fd.write(bytearray(b'the list\n'))
time.sleep(0.2)
self.assertEqual(bytearray(b'the list\n'), comm.get_maintenance_data())
comm.stop_maintenance_mode()
pty.fd.write(bytearray(b'After maintenance'))
thread.join(2)
assert not thread.is_alive()
def test_bytes_counter(self):
action = master_api.basic_action()
fields = {'action_type': 1, 'action_number': 2}
pty = DummyPty([action.create_input(1, fields)])
SetUpTestInjections(controller_serial=pty)
comm = MasterCommunicator(init_master=False)
comm.enable_passthrough()
comm.start()
pty.fd.write(bytearray(b'hello'))
pty.master_reply(action.create_output(1, {'resp': 'OK'}))
comm.do_command(action, fields)
self.assertEqual(bytearray(b'hello'), comm.get_passthrough_data())
self.assertEqual(21, comm.get_communication_statistics()['bytes_written'])
self.assertEqual(5 + 18, comm.get_communication_statistics()['bytes_read'])
def test_misalignment(self):
action = master_api.basic_action()
fields = {'action_type': 1, 'action_number': 2}
pty = DummyPty([action.create_input(1, fields),
action.create_input(2, fields)])
SetUpTestInjections(controller_serial=pty)
comm = MasterCommunicator(init_master=False)
comm.start()
data = action.create_output(1, {'resp': 'OK'})
# Only send partial data.
pty.master_reply(data[:-4])
pty.master_reply(b'\r\n')
with self.assertRaises(CommunicationTimedOutException):
comm.do_command(action, fields)
# Next message processed correctly.
pty.master_reply(action.create_output(2, {'resp': 'OK'}))
output = comm.do_command(action, fields)
self.assertEqual('OK', output['resp'])
def test_output_has_crc(self):
""" Test for MasterCommandSpec.output_has_crc. """
self.assertFalse(master_api.basic_action().output_has_crc())
self.assertTrue(master_api.read_output().output_has_crc())
