def _create_port_agent_packet(self, data_item): ts = ntplib.system_to_ntp_time(time.time()) port_agent_packet = PortAgentPacket() port_agent_packet.attach_data(data_item) port_agent_packet.attach_timestamp(ts) port_agent_packet.pack_header() return port_agent_packet
class TestPortAgentPacket(MiUnitTest): # time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime(time.time())) # @staticmethod def ntp_to_system_time(date): """convert a NTP time to system time""" return date - NTP_DELTA @staticmethod def system_to_ntp_time(date): """convert a system time to a NTP time""" return date + NTP_DELTA def setUp(self): self.pap = PortAgentPacket() #self.test_time = time.time() #self.ntp_time = self.system_to_ntp_time(self.test_time) #self.pap.set_timestamp(self.ntp_time) def test_pack_header(self): self.pap.attach_data("Only the length of this matters?") # 32 chars #self.pap.set_timestamp(3564425404.85) self.pap.pack_header() header = self.pap.get_header() self.assertEqual(header, array.array('B', [163, 157, 122, 2, 0, 48, 14, 145, 65, 234, 142, 154, 23, 155, 51, 51])) pass def test_unpack_header(self): self.pap = PortAgentPacket() data = self.pap.unpack_header(array.array('B', [163, 157, 122, 2, 0, 48, 14, 145, 65, 234, 142, 154, 23, 155, 51, 51])) self.assertEqual(self.pap.get_header_type(), 2) self.assertEqual(self.pap.get_header_length(), 32) self.assertEqual(time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime(self.ntp_to_system_time(self.pap.get_timestamp()))), "Thu, 13 Dec 2012 14:10:04 +0000") self.assertEqual(self.pap.get_header_recv_checksum(), 3729) #@TODO Probably should wire in one of these checksums. self.assertEqual(self.pap.get_header_checksum(), None) pass def test_get_time_stamp(self): result = self.pap.get_timestamp() self.assertEqual(self.ntp_time, result) pass def test_pack_unpack_header_timestamp(self): self.pap.attach_data("sweet polly purebread") self.pap.pack_header() header = self.pap.get_header() self.pap.unpack_header(header) result = self.pap.get_timestamp() self.assertEqual(self.ntp_time, result) pass
def send_port_agent_packet(protocol, data): ts = ntplib.system_to_ntp_time(time.time()) port_agent_packet = PortAgentPacket() port_agent_packet.attach_data(data) port_agent_packet.attach_timestamp(ts) port_agent_packet.pack_header() # Push the response into the driver protocol.got_data(port_agent_packet) protocol.got_raw(port_agent_packet) log.debug('Sent port agent packet containing: %r', data)
def test_heat_on_response_with_data(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("HEAT ON command response: %s", VALID_SAMPLE_01) # Create and populate the port agent packet. port_agent_packet = PortAgentPacket() port_agent_packet.attach_data(VALID_SAMPLE_01) port_agent_packet.attach_timestamp(ts) port_agent_packet.pack_header() # Push the response into the driver driver._protocol.got_data(port_agent_packet) log.debug("HEAT ON command response: %s", HEAT_ON_COMMAND_RESPONSE) # Create and populate the port agent packet. port_agent_packet = PortAgentPacket() port_agent_packet.attach_data(HEAT_ON_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) self.assertTrue( driver._protocol._get_response( expected_prompt=TEST_HEAT_ON_DURATION_2))
def _send_port_agent_packet(self, driver, data): """ Send a port agent packet via got_data @param driver Instrument Driver instance @param data data to send """ ts = ntplib.system_to_ntp_time(time.time()) port_agent_packet = PortAgentPacket() port_agent_packet.attach_data(data) port_agent_packet.attach_timestamp(ts) port_agent_packet.pack_header() # Push the response into the driver driver._protocol.got_data(port_agent_packet)
def test_heat_on_response_with_data(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("HEAT ON command response: %s", VALID_SAMPLE_01) # Create and populate the port agent packet. port_agent_packet = PortAgentPacket() port_agent_packet.attach_data(VALID_SAMPLE_01) port_agent_packet.attach_timestamp(ts) port_agent_packet.pack_header() # Push the response into the driver driver._protocol.got_data(port_agent_packet) log.debug("HEAT ON command response: %s", HEAT_ON_COMMAND_RESPONSE) # Create and populate the port agent packet. port_agent_packet = PortAgentPacket() port_agent_packet.attach_data(HEAT_ON_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) self.assertTrue(driver._protocol._get_response(expected_prompt = TEST_HEAT_ON_DURATION_2))
def _send_port_agent_packet(self, driver, data): """ Send the supplied data to the driver in a port agent packet @param driver: instrument driver instance @param data: data to be sent """ ts = ntplib.system_to_ntp_time(time.time()) port_agent_packet = PortAgentPacket() port_agent_packet.attach_data(data) port_agent_packet.attach_timestamp(ts) port_agent_packet.pack_header() # Push the response into the driver driver._protocol.got_data(port_agent_packet)
def _send_port_agent_packet(self, driver, data): """ Send the supplied data to the driver in a port agent packet @param driver: instrument driver instance @param data: data to be sent """ ts = ntplib.system_to_ntp_time(time.time()) port_agent_packet = PortAgentPacket() port_agent_packet.attach_data(data) port_agent_packet.attach_timestamp(ts) port_agent_packet.pack_header() # Push the response into the driver driver._protocol.got_data(port_agent_packet) # sleep briefly, as some state changes happen asynchronously, this should give those # threads time to finish time.sleep(.01)
class PAClientTestPortAgentPacket(MiUnitTest): @staticmethod def ntp_to_system_time(date): """convert a NTP time to system time""" return date - NTP_DELTA @staticmethod def system_to_ntp_time(date): """convert a system time to a NTP time""" return date + NTP_DELTA def setUp(self): self.pap = PortAgentPacket() # self.test_time = time.time() # self.ntp_time = self.system_to_ntp_time(self.test_time) # self.pap.set_timestamp(self.ntp_time) def test_pack_header(self): test_data = "Only the length of this matters?" test_data_length = len(test_data) self.pap.attach_data(test_data) self.pap.pack_header() self.assertEqual(self.pap.get_data_length(), test_data_length) def test_get_length(self): test_length = 100 self.pap.set_data_length(test_length) got_length = self.pap.get_data_length() self.assertEqual(got_length, test_length) def test_checksum(self): """ This tests the checksum algorithm; if somebody changes the algorithm this test should catch it. Had to jump through some hoops to do this; needed to add set_data_length and set_header because we're building our own header here (the one in PortAgentPacket includes the timestamp so the checksum is not consistent). """ test_data = "This tests the checksum algorithm." test_length = len(test_data) self.pap.attach_data(test_data) # Now build a header variable_tuple = (0xa3, 0x9d, 0x7a, self.pap.DATA_FROM_DRIVER, test_length + HEADER_SIZE, 0x0000, 0) self.pap.set_data_length(test_length) header_format = '>BBBBHHd' size = struct.calcsize(header_format) temp_header = ctypes.create_string_buffer(size) struct.pack_into(header_format, temp_header, 0, *variable_tuple) # Now set the header member in PortAgentPacket to the header # we built self.pap.set_header(temp_header.raw) # Now get the checksum and verify it is what we expect it to be. checksum = self.pap.calculate_checksum() self.assertEqual(checksum, 2) def test_unpack_header(self): self.pap = PortAgentPacket() data_length = 32 data = self.pap.unpack_header(array.array('B', [163, 157, 122, 2, 0, data_length + HEADER_SIZE, 14, 145, 65, 234, 142, 154, 23, 155, 51, 51])) got_timestamp = self.pap.get_timestamp() self.assertEqual(self.pap.get_header_type(), self.pap.DATA_FROM_DRIVER) self.assertEqual(self.pap.get_data_length(), data_length) self.assertEqual(got_timestamp, 1105890970.092212) self.assertEqual(self.pap.get_header_recv_checksum(), 3729)
def test_handle_packet(self): """ Test that a default PortAgentPacket creates a DATA_FROM_DRIVER packet, and that the handle_packet method invokes the raw callback """ pa_listener = Listener(None, None, 0, 0, 5, self.myGotData, self.myGotRaw, self.myGotListenerError, self.myGotError) test_data = "This is a great big test" self.resetTestVars() pa_packet = PortAgentPacket() pa_packet.attach_data(test_data) pa_packet.pack_header() pa_packet.verify_checksum() pa_listener.handle_packet(pa_packet) self.assertTrue(self.rawCallbackCalled) ### # Test DATA_FROM_INSTRUMENT; handle_packet should invoke data and raw # callbacks. ### self.resetTestVars() pa_packet = PortAgentPacket(PortAgentPacket.DATA_FROM_INSTRUMENT) pa_packet.attach_data(test_data) pa_packet.pack_header() pa_packet.verify_checksum() pa_listener.handle_packet(pa_packet) self.assertTrue(self.rawCallbackCalled) self.assertTrue(self.dataCallbackCalled) self.assertFalse(self.errorCallbackCalled) self.assertFalse(self.listenerCallbackCalled) ### # Test PORT_AGENT_COMMAND; handle_packet should invoke raw callback. ### self.resetTestVars() pa_packet = PortAgentPacket(PortAgentPacket.PORT_AGENT_COMMAND) pa_packet.attach_data(test_data) pa_packet.pack_header() pa_packet.verify_checksum() pa_listener.handle_packet(pa_packet) self.assertTrue(self.rawCallbackCalled) self.assertFalse(self.dataCallbackCalled) self.assertFalse(self.errorCallbackCalled) self.assertFalse(self.listenerCallbackCalled) ### # Test PORT_AGENT_STATUS; handle_packet should invoke raw callback. ### self.resetTestVars() pa_packet = PortAgentPacket(PortAgentPacket.PORT_AGENT_STATUS) pa_packet.attach_data(test_data) pa_packet.pack_header() pa_packet.verify_checksum() pa_listener.handle_packet(pa_packet) self.assertTrue(self.rawCallbackCalled) self.assertFalse(self.dataCallbackCalled) self.assertFalse(self.errorCallbackCalled) self.assertFalse(self.listenerCallbackCalled) ### # Test PORT_AGENT_FAULT; handle_packet should invoke raw callback. ### self.resetTestVars() pa_packet = PortAgentPacket(PortAgentPacket.PORT_AGENT_FAULT) pa_packet.attach_data(test_data) pa_packet.pack_header() pa_packet.verify_checksum() pa_listener.handle_packet(pa_packet) self.assertTrue(self.rawCallbackCalled) self.assertFalse(self.dataCallbackCalled) self.assertFalse(self.errorCallbackCalled) self.assertFalse(self.listenerCallbackCalled) ### # Test INSTRUMENT_COMMAND; handle_packet should invoke raw callback. ### self.resetTestVars() pa_packet = PortAgentPacket(PortAgentPacket.DIGI_CMD) pa_packet.attach_data(test_data) pa_packet.pack_header() pa_packet.verify_checksum() pa_listener.handle_packet(pa_packet) self.assertTrue(self.rawCallbackCalled) self.assertFalse(self.dataCallbackCalled) self.assertFalse(self.errorCallbackCalled) self.assertFalse(self.listenerCallbackCalled) ### # Test HEARTBEAT; handle_packet should not invoke any callback. ### self.resetTestVars() pa_packet = PortAgentPacket(PortAgentPacket.HEARTBEAT) pa_packet.attach_data(test_data) pa_packet.pack_header() pa_packet.verify_checksum() pa_listener.handle_packet(pa_packet) self.assertFalse(self.rawCallbackCalled) self.assertFalse(self.dataCallbackCalled) self.assertFalse(self.errorCallbackCalled) self.assertFalse(self.listenerCallbackCalled)
class PAClientTestPortAgentPacket(MiUnitTest): @staticmethod def ntp_to_system_time(date): """convert a NTP time to system time""" return date - NTP_DELTA @staticmethod def system_to_ntp_time(date): """convert a system time to a NTP time""" return date + NTP_DELTA def setUp(self): self.pap = PortAgentPacket() # self.test_time = time.time() # self.ntp_time = self.system_to_ntp_time(self.test_time) # self.pap.set_timestamp(self.ntp_time) def test_pack_header(self): test_data = "Only the length of this matters?" test_data_length = len(test_data) self.pap.attach_data(test_data) self.pap.pack_header() self.assertEqual(self.pap.get_data_length(), test_data_length) def test_get_length(self): test_length = 100 self.pap.set_data_length(test_length) got_length = self.pap.get_data_length() self.assertEqual(got_length, test_length) def test_checksum(self): """ This tests the checksum algorithm; if somebody changes the algorithm this test should catch it. Had to jump through some hoops to do this; needed to add set_data_length and set_header because we're building our own header here (the one in PortAgentPacket includes the timestamp so the checksum is not consistent). """ test_data = "This tests the checksum algorithm." test_length = len(test_data) self.pap.attach_data(test_data) # Now build a header variable_tuple = (0xa3, 0x9d, 0x7a, self.pap.DATA_FROM_DRIVER, test_length + HEADER_SIZE, 0x0000, 0) self.pap.set_data_length(test_length) header_format = '>BBBBHHd' size = struct.calcsize(header_format) temp_header = ctypes.create_string_buffer(size) struct.pack_into(header_format, temp_header, 0, *variable_tuple) # Now set the header member in PortAgentPacket to the header # we built self.pap.set_header(temp_header.raw) # Now get the checksum and verify it is what we expect it to be. checksum = self.pap.calculate_checksum() self.assertEqual(checksum, 2) def test_unpack_header(self): self.pap = PortAgentPacket() data_length = 32 data = self.pap.unpack_header( array.array('B', [ 163, 157, 122, 2, 0, data_length + HEADER_SIZE, 14, 145, 65, 234, 142, 154, 23, 155, 51, 51 ])) got_timestamp = self.pap.get_timestamp() self.assertEqual(self.pap.get_header_type(), self.pap.DATA_FROM_DRIVER) self.assertEqual(self.pap.get_data_length(), data_length) self.assertEqual(got_timestamp, 1105890970.092212) self.assertEqual(self.pap.get_header_recv_checksum(), 3729)
class TestUnitDataParticle(MiUnitTestCase): """ Test cases for the DataParticleGenerator class. Functions in this class provide unit tests and provide a tutorial on use of the data particle generator interface. """ class TestDataParticle(DataParticle): """ Simple test DataParticle derivative that returns fixed parsed data values @retval Value list for parased data set [{'value_id': foo, 'value': bar}, ...] """ _data_particle_type = TEST_PARTICLE_TYPE def _build_parsed_values(self): result = [{DataParticleKey.VALUE_ID: "temp", DataParticleKey.VALUE: "23.45"}, {DataParticleKey.VALUE_ID: "cond", DataParticleKey.VALUE: "15.9"}, {DataParticleKey.VALUE_ID: "depth", DataParticleKey.VALUE: "305.16"}] return result class BadDataParticle(DataParticle): """ Define a data particle that doesn't initialize _data_particle_type. Should raise an exception when _data_particle_type isn't initialized """ pass def setUp(self): """ """ #self.start_couchdb() # appease the pyon gods self.sample_port_timestamp = 3555423720.711772 self.sample_driver_timestamp = 3555423721.711772 self.sample_internal_timestamp = 3555423719.711772 self.sample_raw_data = "SATPAR0229,10.01,2206748544,234" self.parsed_test_particle = self.TestDataParticle(self.sample_raw_data, port_timestamp=self.sample_port_timestamp, quality_flag=DataParticleValue.INVALID, preferred_timestamp=DataParticleKey.DRIVER_TIMESTAMP) self.sample_parsed_particle = { DataParticleKey.PKT_FORMAT_ID: DataParticleValue.JSON_DATA, DataParticleKey.PKT_VERSION: TEST_PARTICLE_VERSION, DataParticleKey.STREAM_NAME: TEST_PARTICLE_TYPE, DataParticleKey.PORT_TIMESTAMP: self.sample_port_timestamp, DataParticleKey.DRIVER_TIMESTAMP: self.sample_driver_timestamp, #DataParticleKey.NEW_SEQUENCE: None, DataParticleKey.PREFERRED_TIMESTAMP: DataParticleKey.DRIVER_TIMESTAMP, DataParticleKey.QUALITY_FLAG: DataParticleValue.INVALID, DataParticleKey.VALUES: [ {DataParticleKey.VALUE_ID: "temp", DataParticleKey.VALUE: "23.45"}, {DataParticleKey.VALUE_ID: "cond", DataParticleKey.VALUE: "15.9"}, {DataParticleKey.VALUE_ID: "depth", DataParticleKey.VALUE: "305.16"} ] } self.port_agent_packet = PortAgentPacket() self.port_agent_packet.attach_data(self.sample_raw_data) self.port_agent_packet.pack_header() self.raw_test_particle = RawDataParticle(self.port_agent_packet.get_as_dict(), port_timestamp=self.sample_port_timestamp, internal_timestamp=self.sample_internal_timestamp) self.sample_raw_particle = { DataParticleKey.PKT_FORMAT_ID: DataParticleValue.JSON_DATA, DataParticleKey.PKT_VERSION: TEST_PARTICLE_VERSION, DataParticleKey.STREAM_NAME: CommonDataParticleType.RAW, DataParticleKey.INTERNAL_TIMESTAMP: self.sample_internal_timestamp, DataParticleKey.PORT_TIMESTAMP: self.sample_port_timestamp, DataParticleKey.DRIVER_TIMESTAMP: self.sample_driver_timestamp, #DataParticleKey.NEW_SEQUENCE: None, DataParticleKey.PREFERRED_TIMESTAMP: DataParticleKey.PORT_TIMESTAMP, DataParticleKey.QUALITY_FLAG: "ok", DataParticleKey.VALUES: [ { DataParticleKey.VALUE_ID: "raw", DataParticleKey.VALUE: base64.b64encode(self.sample_raw_data), "binary": True }, { DataParticleKey.VALUE_ID: "length", DataParticleKey.VALUE: int(31)}, { DataParticleKey.VALUE_ID: "type", DataParticleKey.VALUE: int(2)}, { DataParticleKey.VALUE_ID: "checksum", DataParticleKey.VALUE: int(2392)}, ] } def test_new_sequence_flag(self): """ Verify that we can set the new sequence flag """ # Verify we can set the new sequence flag particle = self.TestDataParticle(self.sample_raw_data, port_timestamp=self.sample_port_timestamp, quality_flag=DataParticleValue.INVALID, preferred_timestamp=DataParticleKey.DRIVER_TIMESTAMP, new_sequence=True) dict_result = particle.generate_dict() self.assertFalse(hasattr(dict_result, DataParticleKey.NEW_SEQUENCE)) particle = self.TestDataParticle(self.sample_raw_data, port_timestamp=self.sample_port_timestamp, quality_flag=DataParticleValue.INVALID, preferred_timestamp=DataParticleKey.DRIVER_TIMESTAMP, new_sequence=True) dict_result = particle.generate_dict() self.assertTrue(dict_result[DataParticleKey.NEW_SEQUENCE]) particle = self.TestDataParticle(self.sample_raw_data, port_timestamp=self.sample_port_timestamp, quality_flag=DataParticleValue.INVALID, preferred_timestamp=DataParticleKey.DRIVER_TIMESTAMP, new_sequence=False) dict_result = particle.generate_dict() self.assertFalse(dict_result[DataParticleKey.NEW_SEQUENCE]) with self.assertRaises(TypeError): particle = self.TestDataParticle(self.sample_raw_data, port_timestamp=self.sample_port_timestamp, quality_flag=DataParticleValue.INVALID, preferred_timestamp=DataParticleKey.DRIVER_TIMESTAMP, new_sequence='a') def test_timestamps(self): """ Test bad timestamp configurations """ test_particle = self.TestDataParticle(self.sample_raw_data, preferred_timestamp=DataParticleKey.PORT_TIMESTAMP, internal_timestamp=self.sample_internal_timestamp) # Not raising an exception here because it should be handled # down stream #self.assertRaises(SampleException, test_particle.generate) def test_internal_timestamp(self): """ Test the set_internal_timestamp call """ test_particle = self.TestDataParticle(self.sample_raw_data, preferred_timestamp=DataParticleKey.PORT_TIMESTAMP) fetched_time = test_particle.get_value(DataParticleKey.INTERNAL_TIMESTAMP) self.assertIsNone(fetched_time) test_particle.set_internal_timestamp(self.sample_internal_timestamp) fetched_time = test_particle.get_value(DataParticleKey.INTERNAL_TIMESTAMP) self.assertEquals(self.sample_internal_timestamp, fetched_time) now = time.time() ntptime = ntplib.system_to_ntp_time(now) test_particle.set_internal_timestamp(unix_time=now) fetched_time = test_particle.get_value(DataParticleKey.INTERNAL_TIMESTAMP) self.assertEquals(ntptime, fetched_time) self.assertRaises(InstrumentParameterException, test_particle.set_internal_timestamp) def test_get_set_value(self): """ Test setting values after creation """ test_particle = self.TestDataParticle(self.sample_raw_data, preferred_timestamp=DataParticleKey.PORT_TIMESTAMP, internal_timestamp=self.sample_internal_timestamp) new_time = self.sample_internal_timestamp + 200 test_particle.set_value(DataParticleKey.INTERNAL_TIMESTAMP, new_time) fetched_time = test_particle.get_value(DataParticleKey.INTERNAL_TIMESTAMP) self.assertEquals(new_time, fetched_time) self.assertRaises(ReadOnlyException, test_particle.set_value, DataParticleKey.PKT_VERSION, 2) self.assertRaises(ReadOnlyException, test_particle.set_value, DataParticleKey.INTERNAL_TIMESTAMP, ntplib.system_to_ntp_time(time.time()+(86400*600))) self.assertRaises(NotImplementedException, test_particle.get_value, "bad_key") def test_data_particle_type(self): """ Test that the Data particle will raise an exception if the data particle type is not set """ particle = self.BadDataParticle(self.sample_raw_data, port_timestamp=self.sample_port_timestamp, internal_timestamp=self.sample_internal_timestamp) with self.assertRaises(NotImplementedException): particle.data_particle_type()
class TestUnitDataParticle(MiUnitTestCase): """ Test cases for the DataParticleGenerator class. Functions in this class provide unit tests and provide a tutorial on use of the data particle generator interface. """ class TestDataParticle(DataParticle): """ Simple test DataParticle derivative that returns fixed parsed data values @retval Value list for parased data set [{'value_id': foo, 'value': bar}, ...] """ _data_particle_type = TEST_PARTICLE_TYPE def _build_parsed_values(self): result = [{DataParticleKey.VALUE_ID: "temp", DataParticleKey.VALUE: "23.45"}, {DataParticleKey.VALUE_ID: "cond", DataParticleKey.VALUE: "15.9"}, {DataParticleKey.VALUE_ID: "depth", DataParticleKey.VALUE: "305.16"}] return result class BadDataParticle(DataParticle): """ Define a data particle that doesn't initialize _data_particle_type. Should raise an exception when _data_particle_type isn't initialized """ pass def setUp(self): """ """ #self.start_couchdb() # appease the pyon gods self.sample_port_timestamp = 3555423720.711772 self.sample_driver_timestamp = 3555423721.711772 self.sample_internal_timestamp = 3555423719.711772 self.sample_raw_data = "SATPAR0229,10.01,2206748544,234" self.parsed_test_particle = self.TestDataParticle(self.sample_raw_data, port_timestamp=self.sample_port_timestamp, quality_flag=DataParticleValue.INVALID, preferred_timestamp=DataParticleKey.DRIVER_TIMESTAMP) self.sample_parsed_particle = { DataParticleKey.PKT_FORMAT_ID: DataParticleValue.JSON_DATA, DataParticleKey.PKT_VERSION: TEST_PARTICLE_VERSION, DataParticleKey.STREAM_NAME: TEST_PARTICLE_TYPE, DataParticleKey.PORT_TIMESTAMP: self.sample_port_timestamp, DataParticleKey.DRIVER_TIMESTAMP: self.sample_driver_timestamp, #DataParticleKey.NEW_SEQUENCE: None, DataParticleKey.PREFERRED_TIMESTAMP: DataParticleKey.DRIVER_TIMESTAMP, DataParticleKey.QUALITY_FLAG: DataParticleValue.INVALID, DataParticleKey.VALUES: [ {DataParticleKey.VALUE_ID: "temp", DataParticleKey.VALUE: "23.45"}, {DataParticleKey.VALUE_ID: "cond", DataParticleKey.VALUE: "15.9"}, {DataParticleKey.VALUE_ID: "depth", DataParticleKey.VALUE: "305.16"} ] } self.port_agent_packet = PortAgentPacket() self.port_agent_packet.attach_data(self.sample_raw_data) self.port_agent_packet.pack_header() self.raw_test_particle = RawDataParticle(self.port_agent_packet.get_as_dict(), port_timestamp=self.sample_port_timestamp, internal_timestamp=self.sample_internal_timestamp) self.sample_raw_particle = { DataParticleKey.PKT_FORMAT_ID: DataParticleValue.JSON_DATA, DataParticleKey.PKT_VERSION: TEST_PARTICLE_VERSION, DataParticleKey.STREAM_NAME: CommonDataParticleType.RAW, DataParticleKey.INTERNAL_TIMESTAMP: self.sample_internal_timestamp, DataParticleKey.PORT_TIMESTAMP: self.sample_port_timestamp, DataParticleKey.DRIVER_TIMESTAMP: self.sample_driver_timestamp, #DataParticleKey.NEW_SEQUENCE: None, DataParticleKey.PREFERRED_TIMESTAMP: DataParticleKey.PORT_TIMESTAMP, DataParticleKey.QUALITY_FLAG: "ok", DataParticleKey.VALUES: [ { DataParticleKey.VALUE_ID: "raw", DataParticleKey.VALUE: base64.b64encode(self.sample_raw_data), "binary": True }, { DataParticleKey.VALUE_ID: "length", DataParticleKey.VALUE: int(31)}, { DataParticleKey.VALUE_ID: "type", DataParticleKey.VALUE: int(2)}, { DataParticleKey.VALUE_ID: "checksum", DataParticleKey.VALUE: int(2392)}, ] } def test_parsed_generate(self): """ Test generation of a data particle """ # Create some sample data as a param dict # Submit it to a data particle generator with a timestamp # compare to JSON-ified output # Be sure to check timestamp format as BASE64 and de-encode it. # Sanity check it as well. dict_result = self.parsed_test_particle.generate_dict() parsed_result = self.parsed_test_particle.generate(sorted=True) decoded_parsed = json.loads(parsed_result) self.assertEqual(dict_result, decoded_parsed) driver_time = decoded_parsed["driver_timestamp"] self.sample_parsed_particle["driver_timestamp"] = driver_time # run it through json so unicode and everything lines up standard = json.dumps(self.sample_parsed_particle, sort_keys=True) self.assertEqual(parsed_result, standard) def test_new_sequence_flag(self): """ Verify that we can set the new sequence flag """ # Verify we can set the new sequence flag particle = self.TestDataParticle(self.sample_raw_data, port_timestamp=self.sample_port_timestamp, quality_flag=DataParticleValue.INVALID, preferred_timestamp=DataParticleKey.DRIVER_TIMESTAMP, new_sequence=True) dict_result = particle.generate_dict() self.assertFalse(hasattr(dict_result, DataParticleKey.NEW_SEQUENCE)) particle = self.TestDataParticle(self.sample_raw_data, port_timestamp=self.sample_port_timestamp, quality_flag=DataParticleValue.INVALID, preferred_timestamp=DataParticleKey.DRIVER_TIMESTAMP, new_sequence=True) dict_result = particle.generate_dict() self.assertTrue(dict_result[DataParticleKey.NEW_SEQUENCE]) particle = self.TestDataParticle(self.sample_raw_data, port_timestamp=self.sample_port_timestamp, quality_flag=DataParticleValue.INVALID, preferred_timestamp=DataParticleKey.DRIVER_TIMESTAMP, new_sequence=False) dict_result = particle.generate_dict() self.assertFalse(dict_result[DataParticleKey.NEW_SEQUENCE]) with self.assertRaises(TypeError): particle = self.TestDataParticle(self.sample_raw_data, port_timestamp=self.sample_port_timestamp, quality_flag=DataParticleValue.INVALID, preferred_timestamp=DataParticleKey.DRIVER_TIMESTAMP, new_sequence='a') def test_raw_generate(self): """ Test generation of a raw data particle """ # Create some sample data as a param dict # Submit it to a data particle generator with a timestamp # compare to JSON-ified output # Be sure to check timestamp format as BASE64 and de-encode it. # Sanity check it as well. dict_result = self.raw_test_particle.generate_dict() raw_result = self.raw_test_particle.generate(sorted=True) decoded_raw = json.loads(raw_result) self.assertEqual(dict_result, decoded_raw) # get values that change from instance to instance to maintain them the same across instances checksum = decoded_raw[DataParticleKey.VALUES][3][DataParticleKey.VALUE] driver_time = decoded_raw["driver_timestamp"] # and set.... self.sample_raw_particle["driver_timestamp"] = driver_time self.sample_raw_particle[DataParticleKey.VALUES][3][DataParticleKey.VALUE] = checksum # run it through json so unicode and everything lines up standard = json.dumps(self.sample_raw_particle, sort_keys=True) self.assertEqual(raw_result, standard) def test_timestamps(self): """ Test bad timestamp configurations """ test_particle = self.TestDataParticle(self.sample_raw_data, preferred_timestamp=DataParticleKey.PORT_TIMESTAMP, internal_timestamp=self.sample_internal_timestamp) # Not raising an exception here because it should be handled # down stream #self.assertRaises(SampleException, test_particle.generate) def test_internal_timestamp(self): """ Test the set_internal_timestamp call """ test_particle = self.TestDataParticle(self.sample_raw_data, preferred_timestamp=DataParticleKey.PORT_TIMESTAMP) fetched_time = test_particle.get_value(DataParticleKey.INTERNAL_TIMESTAMP) self.assertIsNone(fetched_time) test_particle.set_internal_timestamp(self.sample_internal_timestamp) fetched_time = test_particle.get_value(DataParticleKey.INTERNAL_TIMESTAMP) self.assertEquals(self.sample_internal_timestamp, fetched_time) now = time.time() ntptime = ntplib.system_to_ntp_time(now) test_particle.set_internal_timestamp(unix_time=now) fetched_time = test_particle.get_value(DataParticleKey.INTERNAL_TIMESTAMP) self.assertEquals(ntptime, fetched_time) self.assertRaises(InstrumentParameterException, test_particle.set_internal_timestamp) def test_get_set_value(self): """ Test setting values after creation """ test_particle = self.TestDataParticle(self.sample_raw_data, preferred_timestamp=DataParticleKey.PORT_TIMESTAMP, internal_timestamp=self.sample_internal_timestamp) new_time = self.sample_internal_timestamp + 200 test_particle.set_value(DataParticleKey.INTERNAL_TIMESTAMP, new_time) fetched_time = test_particle.get_value(DataParticleKey.INTERNAL_TIMESTAMP) self.assertEquals(new_time, fetched_time) self.assertRaises(ReadOnlyException, test_particle.set_value, DataParticleKey.PKT_VERSION, 2) self.assertRaises(ReadOnlyException, test_particle.set_value, DataParticleKey.INTERNAL_TIMESTAMP, ntplib.system_to_ntp_time(time.time()+(86400*600))) self.assertRaises(NotImplementedException, test_particle.get_value, "bad_key") def test_data_particle_type(self): """ Test that the Data particle will raise an exception if the data particle type is not set """ particle = self.BadDataParticle(self.sample_raw_data, port_timestamp=self.sample_port_timestamp, internal_timestamp=self.sample_internal_timestamp) with self.assertRaises(NotImplementedException): particle.data_particle_type()
class TestUnitDataParticle(MiUnitTestCase): """ Test cases for the DataParticleGenerator class. Functions in this class provide unit tests and provide a tutorial on use of the data particle generator interface. """ class TestDataParticle(DataParticle): """ Simple test DataParticle derivative that returns fixed parsed data values @retval Value list for parased data set [{'value_id': foo, 'value': bar}, ...] """ _data_particle_type = TEST_PARTICLE_TYPE def _build_parsed_values(self): result = [{DataParticleKey.VALUE_ID: "temp", DataParticleKey.VALUE: "23.45"}, {DataParticleKey.VALUE_ID: "cond", DataParticleKey.VALUE: "15.9"}, {DataParticleKey.VALUE_ID: "depth", DataParticleKey.VALUE: "305.16"}] return result class BadDataParticle(DataParticle): """ Define a data particle that doesn't initialize _data_particle_type. Should raise an exception when _data_particle_type isn't initialized """ pass def setUp(self): """ """ #self.start_couchdb() # appease the pyon gods self.sample_port_timestamp = 3555423720.711772 self.sample_driver_timestamp = 3555423721.711772 self.sample_internal_timestamp = 3555423719.711772 self.sample_raw_data = "SATPAR0229,10.01,2206748544,234" self.parsed_test_particle = self.TestDataParticle(self.sample_raw_data, port_timestamp=self.sample_port_timestamp, quality_flag=DataParticleValue.INVALID, preferred_timestamp=DataParticleKey.DRIVER_TIMESTAMP) self.sample_parsed_particle = { DataParticleKey.PKT_FORMAT_ID: DataParticleValue.JSON_DATA, DataParticleKey.PKT_VERSION: TEST_PARTICLE_VERSION, DataParticleKey.STREAM_NAME: TEST_PARTICLE_TYPE, DataParticleKey.PORT_TIMESTAMP: self.sample_port_timestamp, DataParticleKey.DRIVER_TIMESTAMP: self.sample_driver_timestamp, DataParticleKey.PREFERRED_TIMESTAMP: DataParticleKey.DRIVER_TIMESTAMP, DataParticleKey.QUALITY_FLAG: DataParticleValue.INVALID, DataParticleKey.VALUES: [ {DataParticleKey.VALUE_ID: "temp", DataParticleKey.VALUE: "23.45"}, {DataParticleKey.VALUE_ID: "cond", DataParticleKey.VALUE: "15.9"}, {DataParticleKey.VALUE_ID: "depth", DataParticleKey.VALUE: "305.16"} ] } self.port_agent_packet = PortAgentPacket() self.port_agent_packet.attach_data(self.sample_raw_data) self.port_agent_packet.pack_header() self.raw_test_particle = RawDataParticle(self.port_agent_packet.get_as_dict(), port_timestamp=self.sample_port_timestamp, internal_timestamp=self.sample_internal_timestamp) self.sample_raw_particle = { DataParticleKey.PKT_FORMAT_ID: DataParticleValue.JSON_DATA, DataParticleKey.PKT_VERSION: TEST_PARTICLE_VERSION, DataParticleKey.STREAM_NAME: CommonDataParticleType.RAW, DataParticleKey.INTERNAL_TIMESTAMP: self.sample_internal_timestamp, DataParticleKey.PORT_TIMESTAMP: self.sample_port_timestamp, DataParticleKey.DRIVER_TIMESTAMP: self.sample_driver_timestamp, DataParticleKey.PREFERRED_TIMESTAMP: DataParticleKey.PORT_TIMESTAMP, DataParticleKey.QUALITY_FLAG: "ok", DataParticleKey.VALUES: [ { DataParticleKey.VALUE_ID: "raw", DataParticleKey.VALUE: base64.b64encode(self.sample_raw_data), "binary": True }, { DataParticleKey.VALUE_ID: "length", DataParticleKey.VALUE: int(31)}, { DataParticleKey.VALUE_ID: "type", DataParticleKey.VALUE: int(2)}, { DataParticleKey.VALUE_ID: "checksum", DataParticleKey.VALUE: int(2392)}, ] } def test_parsed_generate(self): """ Test generation of a data particle """ # Create some sample data as a param dict # Submit it to a data particle generator with a timestamp # compare to JSON-ified output # Be sure to check timestamp format as BASE64 and de-encode it. # Sanity check it as well. dict_result = self.parsed_test_particle.generate_dict() parsed_result = self.parsed_test_particle.generate(sorted=True) decoded_parsed = json.loads(parsed_result) self.assertEqual(dict_result, decoded_parsed) driver_time = decoded_parsed["driver_timestamp"] self.sample_parsed_particle["driver_timestamp"] = driver_time # run it through json so unicode and everything lines up standard = json.dumps(self.sample_parsed_particle, sort_keys=True) self.assertEqual(parsed_result, standard) def test_raw_generate(self): """ Test generation of a raw data particle """ # Create some sample data as a param dict # Submit it to a data particle generator with a timestamp # compare to JSON-ified output # Be sure to check timestamp format as BASE64 and de-encode it. # Sanity check it as well. dict_result = self.raw_test_particle.generate_dict() raw_result = self.raw_test_particle.generate(sorted=True) decoded_raw = json.loads(raw_result) self.assertEqual(dict_result, decoded_raw) # get values that change from instance to instance to maintain them the same across instances checksum = decoded_raw[DataParticleKey.VALUES][3][DataParticleKey.VALUE] driver_time = decoded_raw["driver_timestamp"] # and set.... self.sample_raw_particle["driver_timestamp"] = driver_time self.sample_raw_particle[DataParticleKey.VALUES][3][DataParticleKey.VALUE] = checksum # run it through json so unicode and everything lines up standard = json.dumps(self.sample_raw_particle, sort_keys=True) self.assertEqual(raw_result, standard) def test_timestamps(self): """ Test bad timestamp configurations """ test_particle = self.TestDataParticle(self.sample_raw_data, preferred_timestamp=DataParticleKey.PORT_TIMESTAMP, internal_timestamp=self.sample_internal_timestamp) # Not raising an exception here because it should be handled # down stream #self.assertRaises(SampleException, test_particle.generate) def test_internal_timestamp(self): """ Test the set_internal_timestamp call """ test_particle = self.TestDataParticle(self.sample_raw_data, preferred_timestamp=DataParticleKey.PORT_TIMESTAMP) fetched_time = test_particle.get_value(DataParticleKey.INTERNAL_TIMESTAMP) self.assertIsNone(fetched_time) test_particle.set_internal_timestamp(self.sample_internal_timestamp) fetched_time = test_particle.get_value(DataParticleKey.INTERNAL_TIMESTAMP) self.assertEquals(self.sample_internal_timestamp, fetched_time) now = time.time() ntptime = ntplib.system_to_ntp_time(now) test_particle.set_internal_timestamp(unix_time=now) fetched_time = test_particle.get_value(DataParticleKey.INTERNAL_TIMESTAMP) self.assertEquals(ntptime, fetched_time) self.assertRaises(InstrumentParameterException, test_particle.set_internal_timestamp) def test_get_set_value(self): """ Test setting values after creation """ test_particle = self.TestDataParticle(self.sample_raw_data, preferred_timestamp=DataParticleKey.PORT_TIMESTAMP, internal_timestamp=self.sample_internal_timestamp) new_time = self.sample_internal_timestamp + 200 test_particle.set_value(DataParticleKey.INTERNAL_TIMESTAMP, new_time) fetched_time = test_particle.get_value(DataParticleKey.INTERNAL_TIMESTAMP) self.assertEquals(new_time, fetched_time) self.assertRaises(ReadOnlyException, test_particle.set_value, DataParticleKey.PKT_VERSION, 2) self.assertRaises(ReadOnlyException, test_particle.set_value, DataParticleKey.INTERNAL_TIMESTAMP, ntplib.system_to_ntp_time(time.time()+(86400*600))) self.assertRaises(NotImplementedException, test_particle.get_value, "bad_key") def test_data_particle_type(self): """ Test that the Data particle will raise an exception if the data particle type is not set """ particle = self.BadDataParticle(self.sample_raw_data, port_timestamp=self.sample_port_timestamp, internal_timestamp=self.sample_internal_timestamp) with self.assertRaises(NotImplementedException): particle.data_particle_type()
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)