def setUp(self):
def response_side_effect(*args, **kwargs):
if args[0] == Command.SAMPLE:
mi_logger.debug("Side effecting!")
return "SATPAR0229,10.01,2206748544,234"
else:
return DEFAULT
self.mock_callback = Mock(name='callback')
self.mock_logger = Mock(name='logger')
self.mock_logger_client = Mock(name='logger_client')
self.mock_fsm = Mock(name='fsm')
# self.mock_logger_client.send = Mock()
self.par_proto = SatlanticPARInstrumentProtocol(self.mock_callback)
self.config_params = {'device_addr':'1.1.1.1',
'device_port':1,
'server_addr':'2.2.2.2',
'server_port':2}
self.par_proto._fsm = self.mock_fsm
self.par_proto.configure(self.config_params)
self.par_proto.initialize()
self.par_proto._logger = self.mock_logger
self.par_proto._logger_client = self.mock_logger_client
self.par_proto._get_response = Mock(return_value=('$', None))
# Quick sanity check to make sure the logger got mocked properly
self.assertEquals(self.par_proto._logger, self.mock_logger)
self.assertEquals(self.par_proto._logger_client, self.mock_logger_client)
self.assertEquals(self.par_proto._fsm, self.mock_fsm)
self.mock_logger_client.reset_mock()
class SatlanticParProtocolUnitTest(InstrumentDriverUnitTestCase):
"""
@todo test timeout exceptions while transitioning states and handling commands
"""
def setUp(self):
def response_side_effect(*args, **kwargs):
if args[0] == Command.SAMPLE:
mi_logger.debug("Side effecting!")
return "SATPAR0229,10.01,2206748544,234"
else:
return DEFAULT
self.mock_callback = Mock(name='callback')
self.mock_logger = Mock(name='logger')
self.mock_logger_client = Mock(name='logger_client')
self.mock_fsm = Mock(name='fsm')
# self.mock_logger_client.send = Mock()
self.par_proto = SatlanticPARInstrumentProtocol(self.mock_callback)
self.config_params = {'device_addr':'1.1.1.1',
'device_port':1,
'server_addr':'2.2.2.2',
'server_port':2}
self.par_proto._fsm = self.mock_fsm
self.par_proto.configure(self.config_params)
self.par_proto.initialize()
self.par_proto._logger = self.mock_logger
self.par_proto._logger_client = self.mock_logger_client
self.par_proto._get_response = Mock(return_value=('$', None))
# Quick sanity check to make sure the logger got mocked properly
self.assertEquals(self.par_proto._logger, self.mock_logger)
self.assertEquals(self.par_proto._logger_client, self.mock_logger_client)
self.assertEquals(self.par_proto._fsm, self.mock_fsm)
self.mock_logger_client.reset_mock()
def test_get_param(self):
# try single
result = self.par_proto.get([Parameter.TELBAUD])
self.mock_logger_client.send.assert_called_with("show %s\n" %
Parameter.TELBAUD)
result = self.par_proto.get([Parameter.MAXRATE])
self.mock_logger_client.send.assert_called_with("show %s\n" %
Parameter.MAXRATE)
# try group
result = self.par_proto.get(Parameter.list())
# try empty set
self.mock_logger_client.reset_mock()
result = self.par_proto.get([])
self.assertEquals(result, {})
self.assertEquals(self.mock_logger_client.send.call_count, 0)
# try bad param
self.assertRaises(InstrumentProtocolException, self.par_proto.get, None)
self.assertRaises(InstrumentProtocolException,
self.par_proto.get,['bad_param'])
def test_set_param(self):
#@todo deal with success/fail flag or catch everywhere?
#@todo add save checks?
self.par_proto.set({Parameter.TELBAUD:9600})
self.mock_logger_client.send.assert_called_with("set %s 9600\n" %
Parameter.TELBAUD)
self.mock_logger_client.send.assert_called_with("save")
self.par_proto.set({Parameter.MAXRATE:10})
self.mock_logger_client.send.assert_called_with("set %s 10\n" %
Parameter.MAXRATE)
self.mock_logger_client.send.assert_called_with("save")
# try group
self.mock_logger_client.reset_mock()
self.par_proto.set({Parameter.TELBAUD:4800,Parameter.MAXRATE:9})
self.assertEquals(self.mock_logger_client.send.call_count, 3)
# try empty set
self.mock_logger_client.reset_mock()
result = self.par_proto.set({})
self.assertEquals(self.mock_logger_client.send.call_count, 0)
self.assertEquals(result, {})
# some error cases
self.assertRaises(InstrumentProtocolException, self.par_proto.set, [])
self.assertRaises(InstrumentProtocolException, self.par_proto.set, None)
self.assertRaises(InstrumentProtocolException, self.par_proto.set, ['foo'])
# try bad param
self.assertRaises(InstrumentProtocolException,
self.par_proto.set,{'bad_param':0})
def test_get_config(self):
fetched_config = {}
fetched_config = self.par_proto.get_config()
self.assert_(isinstance(fetched_config, dict))
calls = [call("show %s\n" % Parameter.TELBAUD),
call("show %s\n" % Parameter.MAXRATE)]
self.mock_logger_client.send.assert_has_calls(calls, any_order=True)
self.assertEquals(len(fetched_config), 2)
self.assertTrue(fetched_config.has_key(Parameter.TELBAUD))
self.assertTrue(fetched_config.has_key(Parameter.MAXRATE))
def test_restore_config(self):
self.assertRaises(InstrumentProtocolException,
self.par_proto.restore_config, None)
self.assertRaises(InstrumentProtocolException,
self.par_proto.restore_config, {})
self.assertRaises(InstrumentProtocolException,
self.par_proto.restore_config, {'bad_param':0})
test_config = {Parameter.TELBAUD:19200, Parameter.MAXRATE:2}
restore_result = self.par_proto.restore_config(test_config)
calls = [call("set %s %s\n" % (Parameter.TELBAUD, 19200)),
call("set %s %s\n" % (Parameter.MAXRATE, 2))]
self.mock_logger_client.send.assert_has_calls(calls, any_order=True)
def test_get_single_value(self):
result = self.par_proto.execute_poll()
calls = [call("%s\n" % Command.EXIT),
call(Command.STOP),
call(Command.SAMPLE),
call(Command.AUTOSAMPLE),
call(Command.BREAK)]
self.mock_logger_client.send.assert_has_calls(calls, any_order=False)
def test_breaks(self):
# test kick to autosample, then back
result = self.par_proto.execute_exit()
self.mock_callback.reset_mock()
result = self.par_proto.execute_break()
self.mock_logger_client.send.assert_called_with(Command.BREAK)
self.assertEqual(self.mock_callback.call_count, 1)
# test autosample to poll change
result = self.par_proto.execute_exit()
self.mock_callback.reset_mock()
result = self.par_proto.execute_stop()
self.mock_logger_client.send.assert_called_with(Command.STOP)
self.assertEqual(self.mock_callback.call_count, 1)
result = self.par_proto.execute_autosample()
self.mock_callback.reset_mock()
result = self.par_proto.execute_reset()
self.mock_logger_client.send.assert_called_with(Command.RESET)
self.assertEqual(self.mock_callback.call_count, 1)
self.mock_callback.reset_mock()
result = self.par_proto.execute_break()
self.mock_logger_client.send.assert_called_with(Command.BREAK)
self.assertEqual(self.mock_callback.call_count, 1)
def test_got_data(self):
# Cant trigger easily since the async command/response, so short circut
# the test early.
self.mock_callback.reset_mock()
result = self.par_proto.execute_exit()
self.assertEqual(self.mock_callback.call_count, 1)
self.assert_(result)
self.mock_callback.reset_mock()
result = self.par_proto._got_data("SATPAR0229,10.01,2206748544,234\n")
# check for publish
self.assertEqual(self.mock_callback.call_count, 2)
# check for correct parse
def test_connect_disconnect(self):
pass
def test_get_status(self):
pass
