def test_stop_autosample(self):
mock_port_agent = Mock(spec=PortAgentClient)
driver = InstrumentDriver(self._got_data_event_callback)
# Put the driver into test mode
driver.set_test_mode(True)
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.UNCONFIGURED)
# Now configure the driver with the mock_port_agent, verifying
# that the driver transitions to that state
config = {'mock_port_agent' : mock_port_agent}
driver.configure(config = config)
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.DISCONNECTED)
# Invoke the connect method of the driver: should connect to mock
# port agent. Verify that the connection FSM transitions to CONNECTED,
# (which means that the FSM should now be reporting the ProtocolState).
driver.connect()
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverProtocolState.UNKNOWN)
# Force the instrument into a known state
self.assert_force_state(driver, DriverProtocolState.AUTOSAMPLE)
result = driver._protocol._handler_autosample_stop_autosample()
ts = ntplib.system_to_ntp_time(time.time())
def test_connect(self):
"""
Verify sample data passed through the got data method produces the correct data particles
"""
"""
Create a mock port agent
"""
mock_port_agent = Mock(spec=PortAgentClient)
"""
Instantiate the driver class directly (no driver client, no driver
client, no zmq driver process, no driver process; just own the driver)
"""
driver = InstrumentDriver(self._got_data_event_callback)
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.UNCONFIGURED)
"""
Now configure the driver with the mock_port_agent, verifying
that the driver transitions to the DISCONNECTED state
"""
config = {'mock_port_agent' : mock_port_agent}
driver.configure(config = config)
#self.assert_initialize_driver(driver)
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.DISCONNECTED)
# Invoke the connect method of the driver: should connect to mock
# port agent. Verify that the connection FSM UNKNOWN.
driver.connect()
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverProtocolState.UNKNOWN)
def test_get_response_set_time_response(self):
mock_port_agent = Mock(spec=PortAgentClient)
driver = InstrumentDriver(self._got_data_event_callback)
# Put the driver into test mode
driver.set_test_mode(True)
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.UNCONFIGURED)
# Now configure the driver with the mock_port_agent, verifying
# that the driver transitions to that state
config = {'mock_port_agent' : mock_port_agent}
driver.configure(config = config)
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.DISCONNECTED)
# Invoke the connect method of the driver: should connect to mock
# port agent. Verify that the connection FSM transitions to CONNECTED,
# (which means that the FSM should now be reporting the ProtocolState).
driver.connect()
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverProtocolState.UNKNOWN)
ts = ntplib.system_to_ntp_time(time.time())
# DHE: need to return the status as a string; so, right now we check
# the command response to the dump commands (which is totally bogus
# because it just echos exactly what we send, even if it's wrong)
# but we really want to return the status as a string. Might have to
# expose the two commands to run separately instead of one combined
# acquire_status
driver._protocol._got_chunk(SET_TIME_RESPONSE, ts)
response = driver._protocol._get_response(timeout = 0, expected_prompt = 'Test')
# Force the instrument into command mode
self.assert_force_state(driver, DriverProtocolState.AUTOSAMPLE)
ts = ntplib.system_to_ntp_time(time.time())
driver._protocol._got_chunk(SET_TIME_RESPONSE, ts)
response = driver._protocol._get_response(timeout = 0, expected_prompt = 'Test')
def test_dump_settings_response(self):
"""
"""
mock_port_agent = Mock(spec=PortAgentClient)
driver = InstrumentDriver(self._got_data_event_callback)
driver.set_test_mode(True)
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.UNCONFIGURED)
# Now configure the driver with the mock_port_agent, verifying
# that the driver transitions to that state
config = {'mock_port_agent' : mock_port_agent}
driver.configure(config = config)
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.DISCONNECTED)
# Invoke the connect method of the driver: should connect to mock
# port agent. Verify that the connection FSM transitions to CONNECTED,
# (which means that the FSM should now be reporting the ProtocolState).
driver.connect()
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverProtocolState.UNKNOWN)
# Force the instrument into a known state
self.assert_force_state(driver, DriverProtocolState.COMMAND)
ts = ntplib.system_to_ntp_time(time.time())
log.debug("DUMP_SETTINGS command response: %s", DUMP_COMMAND_RESPONSE)
# Create and populate the port agent packet.
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data(DUMP_COMMAND_RESPONSE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
# Push the response into the driver
driver._protocol.got_data(port_agent_packet)
response = driver._protocol._get_response(expected_prompt =
NANO_DUMP_SETTINGS)
self.assertTrue(isinstance(response[1], NANOCommandResponse))
def test_status_01_handler(self):
mock_port_agent = Mock(spec=PortAgentClient)
driver = InstrumentDriver(self._got_data_event_callback)
def my_send(data):
my_response = DUMP_STATUS
log.debug("my_send: data: %s, my_response: %s", data, my_response)
driver._protocol._promptbuf += my_response
return len(DUMP_STATUS)
mock_port_agent.send.side_effect = my_send
# Put the driver into test mode
driver.set_test_mode(True)
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.UNCONFIGURED)
# Now configure the driver with the mock_port_agent, verifying
# that the driver transitions to that state
config = {'mock_port_agent' : mock_port_agent}
driver.configure(config = config)
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.DISCONNECTED)
# Invoke the connect method of the driver: should connect to mock
# port agent. Verify that the connection FSM transitions to CONNECTED,
# (which means that the FSM should now be reporting the ProtocolState).
driver.connect()
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverProtocolState.UNKNOWN)
# Force the instrument into a known state
self.assert_force_state(driver, DriverProtocolState.AUTOSAMPLE)
result = driver._protocol._handler_command_autosample_dump01(timeout = 0)
def test_status_01(self):
"""
"""
mock_port_agent = Mock(spec=PortAgentClient)
driver = InstrumentDriver(self._got_data_event_callback)
driver.set_test_mode(True)
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.UNCONFIGURED)
# Now configure the driver with the mock_port_agent, verifying
# that the driver transitions to that state
config = {'mock_port_agent' : mock_port_agent}
driver.configure(config = config)
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.DISCONNECTED)
# Invoke the connect method of the driver: should connect to mock
# port agent. Verify that the connection FSM transitions to CONNECTED,
# (which means that the FSM should now be reporting the ProtocolState).
driver.connect()
current_state = driver.get_resource_state()
self.assertEqual(current_state, DriverProtocolState.UNKNOWN)
# Force the instrument into a known state
self.assert_force_state(driver, DriverProtocolState.COMMAND)
ts = ntplib.system_to_ntp_time(time.time())
log.debug("DUMP_STATUS: %s", DUMP_STATUS)
# Create and populate the port agent packet.
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data(DUMP_STATUS)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("HEAT,2013/06/19 23:04:37,-001,0000,0026" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("LILY,2013/06/19 23:04:38, -49.455, 34.009,193.91, 26.02,11.96,N9655" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,V,2013/06/19 23:04:38.000,13.987223,25.126694121" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("LILY,2013/06/19 23:04:39, -49.483, 33.959,193.85, 26.03,11.96,N9655" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,V,2013/06/19 23:04:39.000,13.987191,25.126709409" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("LILY,2013/06/19 23:04:40, -49.355, 33.956,193.79, 26.02,11.96,N9655" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,V,2013/06/19 23:04:40.000,13.987253,25.126725854" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("HEAT,2013/06/19 23:04:40,-001,0000,0026" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,2013/06/19 21:46:54,*APPLIED GEOMECHANICS Model MD900-T Firmware V5.2 SN-N3616 ID01" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,V,2013/06/19 21:46:54.000,13.990480,25.027793612" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
#driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,2013/06/19 21:46:54,*01: Vbias= 0.0000 0.0000 0.0000 0.0000" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,2013/06/19 21:46:54,*01: Vgain= 0.0000 0.0000 0.0000 0.0000" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,2013/06/19 21:46:54,*01: Vmin: -2.50 -2.50 2.50 2.50" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,2013/06/19 21:46:54,*01: Vmax: 2.50 2.50 2.50 2.50" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,2013/06/19 21:46:54,*01: a0= 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,2013/06/19 21:46:54,*01: a1= 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,2013/06/19 21:46:54,*01: a2= 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,2013/06/19 21:46:54,*01: a3= 0.00000 0.00000 0.00000 0.00000 0.00000 0.00000" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,2013/06/19 21:46:55,*01: Tcoef 0: Ks= 0 Kz= 0 Tcal= 0" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,2013/06/19 21:46:55,*01: Tcoef 1: Ks= 0 Kz= 0 Tcal= 0" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,2013/06/19 21:46:55,*01: N_SAMP= 460 Xzero= 0.00 Yzero= 0.00" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,2013/06/19 21:46:55,*01: TR-PASH-OFF E99-ON SO-NMEA-SIM XY-EP 9600 baud FV- " + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
port_agent_packet = PortAgentPacket()
port_agent_packet.attach_data("NANO,2013/06/19 22:04:55,*9900XY-DUMP-SETTINGS" + NEWLINE)
port_agent_packet.attach_timestamp(ts)
port_agent_packet.pack_header()
driver._protocol.got_data(port_agent_packet)
