def test_encode_command_string(self):
# test strings
command = 'play'
kwargs = dict(some_value='7', another_value='2')
expected_strings = ('play?some_value=7&another_value=2',
'play?another_value=2&some_value=7')
actual_string = encode_command_string(command, **kwargs)
self.assertIn(actual_string, expected_strings)
# test ints, floats, bools, and none
command = 'play'
kwargs = dict(some_int=7,
some_float=2.0,
some_none=None,
some_true=True,
some_false=False)
expected_snippets = ('play?', 'some_int=int:7', 'some_float=float:2.0',
'some_none=NoneType:', 'some_true=bool:True',
'some_false=bool:False')
actual_string = encode_command_string(command, **kwargs)
for snippet in expected_snippets:
self.assertIn(snippet, actual_string)
def testConnect(self):
# check that server was opened
self.assertTrue(self.mock_server.is_bound)
# add client
client = MockQueueSocket()
self.mock_server.add_client(client)
self.advance_time_and_run()
# check hello
self.assertEqual(1, len(client.send_queue))
cmd, kwargs = decode_command_string(
client.send_queue.pop()[0:-1].decode())
self.assertEqual("hello", cmd)
# test trigger
self.mock_event("test_event")
client.recv_queue.append(
(encode_command_string("trigger", name="test_event") +
'\n').encode())
self.advance_time_and_run()
self.assertEqual(1, self._events['test_event'])
# register for event/trigger
client.recv_queue.append(
(encode_command_string("register_trigger", event="test_trigger") +
'\n').encode())
self.advance_time_and_run()
self.assertEqual(0, len(client.send_queue))
# post trigger event
self.post_event("test_trigger")
self.advance_time_and_run()
self.assertEqual(1, len(client.send_queue))
cmd, kwargs = decode_command_string(
client.send_queue.pop()[0:-1].decode())
self.assertEqual("trigger", cmd)
self.assertEqual("test_trigger", kwargs['name'])
# send goodbye. machine should continue to run.
client.close = MagicMock()
client.recv_queue.append(
(encode_command_string("goodbye") + '\n').encode())
self.advance_time_and_run()
client.close.assert_called_with()
self.assertFalse(self.machine._done)
def test_roundtrip(self):
test_kwargs = {
"registered_handlers": [{
"calling_context":
"logicblock_baby_bonus_hit{count%10==5}"
}]
}
encoded_cmd = encode_command_string("test", **test_kwargs)
decoded_cmd, decoded_cmd_kwargs = decode_command_string(encoded_cmd)
self.assertEqual(decoded_cmd_kwargs, test_kwargs)
def test_json_encoding_decoding_with_hashtags(self):
# see: https://github.com/missionpinball/mpf/issues/1495
command = 'play'
kwargs = dict()
kwargs['dict1'] = dict(key1='value1 #', key2='value2 #')
encoded_string = encode_command_string(command, **kwargs)
decoded_command, decoded_dict = decode_command_string(encoded_string)
self.assertEqual('play', decoded_command)
self.assertIn('dict1', decoded_dict)
self.assertEqual(decoded_dict['dict1']['key1'], 'value1 #')
self.assertEqual(decoded_dict['dict1']['key2'], 'value2 #')
def test_json_encoding_decoding(self):
# test with dicts
command = 'play'
kwargs = dict()
kwargs['dict1'] = dict(key1='value1', key2='value2')
kwargs['dict2'] = dict(key3='value3', key4='value4')
encoded_string = encode_command_string(command, **kwargs)
decoded_command, decoded_dict = decode_command_string(encoded_string)
self.assertEqual('play', decoded_command)
self.assertIn('dict1', decoded_dict)
self.assertIn('dict2', decoded_dict)
self.assertEqual(decoded_dict['dict1']['key1'], 'value1')
self.assertEqual(decoded_dict['dict1']['key2'], 'value2')
self.assertEqual(decoded_dict['dict2']['key3'], 'value3')
self.assertEqual(decoded_dict['dict2']['key4'], 'value4')
# test with list
command = 'play'
kwargs = dict()
kwargs['dict1'] = dict(key1='value1', key2='value2')
kwargs['dict2'] = list()
kwargs['dict2'].append(dict(key3='value3', key4='value4'))
kwargs['dict2'].append(dict(key3='value5', key4='value6'))
encoded_string = encode_command_string(command, **kwargs)
decoded_command, decoded_dict = decode_command_string(encoded_string)
self.assertEqual('play', decoded_command)
self.assertIn('dict1', decoded_dict)
self.assertIn('dict2', decoded_dict)
self.assertEqual(decoded_dict['dict1']['key1'], 'value1')
self.assertEqual(decoded_dict['dict1']['key2'], 'value2')
self.assertEqual(decoded_dict['dict2'][0],
dict(key3='value3', key4='value4'))
self.assertEqual(decoded_dict['dict2'][1],
dict(key3='value5', key4='value6'))
def test_from_show_via_bcp(self):
from mpf.core.bcp.bcp_socket_client import encode_command_string
show_slide_section = dict()
show_slide_section['widgets'] = list()
show_slide_section['widgets'].append(dict(
type='text', text='TEST FROM SHOW'))
player = McSlidePlayer(self.mc)
show_slide_section = player._validate_config_item('slide1', show_slide_section)
bcp_string = encode_command_string('trigger', name='slides_play', context='test_context', priority=1,
settings=show_slide_section)
self.mc.bcp_processor.receive_bcp_message(bcp_string)
self.advance_time()
def send(self, bcp_command, callback=None, rawbytes=None, **kwargs):
"""Sends a BCP command to the connected pinball controller.
Note that if the BCP server is not running, this method will just throw
the BCP away. (It will still call the callback in that case.
Args:
bcp_command: String of the BCP command name.
callback: Optional callback method that will be called when the
command is sent.
**kwargs: Optional additional kwargs will be added to the BCP
command string.
"""
if self.enabled:
if not self.mc.bcp_client_connected:
raise AssertionError("Not connected to MPF.")
self.sending_queue.put(
(bcp.encode_command_string(bcp_command, **kwargs), rawbytes))
if callback:
callback()
def _encode_and_send(self, cmd, **kwargs):
self.client.recv_queue.append(
(encode_command_string("vpcom_bridge", subcommand=cmd, **kwargs) +
'\n').encode())
def _encode_and_send(self, client, cmd, **kwargs):
client.recv_queue.append((encode_command_string(cmd, **kwargs) + '\n').encode())
def send(self, bcp_command, **kwargs):
self.sending_queue.put(bcp.encode_command_string(
bcp_command, **kwargs))
