def test_non_data_exception(self):
"""
Test that we get a sample exception from non data being found in the file
"""
self.stream_handle = open(os.path.join(RESOURCE_PATH, 'noise.mopak.log'))
self.parser = MopakOStcParser(self.config, self.start_state, self.stream_handle,
'20140120_140004.mopak.log',
self.state_callback, self.pub_callback,
self.except_callback)
# next get accel records
result = self.parser.get_records(5)
self.assertEqual(result, [self.particle_a_accel,
self.particle_b_accel,
self.particle_c_accel,
self.particle_d_accel,
self.particle_e_accel])
self.assertEqual(self.parser._state[StateKey.POSITION], 218)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 218)
self.assertEqual(self.publish_callback_value[0], self.particle_a_accel)
self.assertEqual(self.publish_callback_value[1], self.particle_b_accel)
self.assertEqual(self.publish_callback_value[2], self.particle_c_accel)
self.assertEqual(self.publish_callback_value[3], self.particle_d_accel)
self.assertEqual(self.publish_callback_value[4], self.particle_e_accel)
self.assertEqual(self.file_ingested_value, True)
self.assert_(isinstance(self.exception_callback_value, SampleException))
def test_get_many(self):
"""
Read test data and pull out multiple data particles at one time.
Assert that the results are those we expected.
"""
self.stream_handle = open(os.path.join(RESOURCE_PATH,
'first.mopak.log'))
self.parser = MopakOStcParser(self.config, self.start_state, self.stream_handle,
'20140120_140004.mopak.log',
self.state_callback, self.pub_callback,
self.except_callback)
# next get accel records
result = self.parser.get_records(5)
self.assertEqual(result, [self.particle_a_accel,
self.particle_b_accel,
self.particle_c_accel,
self.particle_d_accel,
self.particle_e_accel])
self.assertEqual(self.parser._state[StateKey.POSITION], 215)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 215)
self.assertEqual(self.publish_callback_value[0], self.particle_a_accel)
self.assertEqual(self.publish_callback_value[1], self.particle_b_accel)
self.assertEqual(self.publish_callback_value[2], self.particle_c_accel)
self.assertEqual(self.publish_callback_value[3], self.particle_d_accel)
self.assertEqual(self.publish_callback_value[4], self.particle_e_accel)
self.assertEqual(self.file_ingested_value, True)
self.assertEqual(self.exception_callback_value, None)
def test_set_state_rate(self):
"""
Test changing to a new state after initializing the parser and
reading data, as if new data has been found and the state has
changed
"""
new_state = {StateKey.POSITION:117}
self.stream_handle = open(os.path.join(RESOURCE_PATH,
'first_rate.mopak.log'))
self.parser = MopakOStcParser(self.config, self.start_state, self.stream_handle,
'20140313_191853.3dmgx3.log',
self.state_callback, self.pub_callback,
self.except_callback)
result = self.parser.get_records(1)
self.assert_result(result, 43, self.particle_a1_accel, False)
# set the new state, the essentially skips b accel, a rate
self.parser.set_state(new_state)
result = self.parser.get_records(1)
self.assert_result(result, 148, self.particle_b_rate, False)
result = self.parser.get_records(1)
self.assert_result(result, 179, self.particle_c_rate, False)
result = self.parser.get_records(1)
self.assert_result(result, 210, self.particle_d_rate, True)
self.assertEqual(self.exception_callback_value, None)
def test_simple_rate(self):
"""
Read test data and pull out data particles one at a time.
Assert that the results are those we expected.
"""
self.stream_handle = open(os.path.join(RESOURCE_PATH,
'first_rate.mopak.log'))
self.parser = MopakOStcParser(self.config, self.start_state, self.stream_handle,
'20140313_191853.mopak.log',
self.state_callback, self.pub_callback,
self.except_callback)
# next get accel and rate records
result = self.parser.get_records(1)
self.assert_result(result, 43, self.particle_a1_accel, False)
result = self.parser.get_records(1)
self.assert_result(result, 86, self.particle_b1_accel, False)
result = self.parser.get_records(1)
self.assert_result(result, 117, self.particle_a_rate, False)
result = self.parser.get_records(1)
self.assert_result(result, 148, self.particle_b_rate, False)
result = self.parser.get_records(1)
self.assert_result(result, 179, self.particle_c_rate, False)
result = self.parser.get_records(1)
self.assert_result(result, 210, self.particle_d_rate, True)
# no data left, dont move the position
result = self.parser.get_records(1)
self.assertEqual(result, [])
self.assertEqual(self.parser._state[StateKey.POSITION], 210)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 210)
self.assert_(isinstance(self.publish_callback_value, list))
self.assertEqual(self.publish_callback_value[0], self.particle_d_rate)
self.assertEqual(self.exception_callback_value, None)
def test_long_stream(self):
"""
Test a long (normal length file)
"""
self.stream_handle = open(os.path.join(RESOURCE_PATH,
'20140120_140004.mopak.log'))
self.parser = MopakOStcParser(self.config, self.start_state, self.stream_handle,
'20140120_140004.mopak.log', self.state_callback,
self.pub_callback, self.except_callback)
result = self.parser.get_records(11964)
self.assertEqual(result[0], self.particle_a_accel)
self.assertEqual(result[-1], self.particle_last_accel)
self.assertEqual(self.parser._state[StateKey.POSITION], 514452)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 514452)
self.assertEqual(self.publish_callback_value[-1], self.particle_last_accel)
self.assertEqual(self.exception_callback_value, None)
def test_mid_state_start(self):
"""
Test starting the parser in a state in the middle of processing
"""
new_state = {StateKey.POSITION:86}
self.stream_handle = open(os.path.join(RESOURCE_PATH,
'first.mopak.log'))
self.parser = MopakOStcParser(self.config, new_state, self.stream_handle,
'20140120_140004.mopak.log', self.state_callback, self.pub_callback,
self.except_callback)
result = self.parser.get_records(1)
self.assert_result(result, 129, self.particle_c_accel, False)
result = self.parser.get_records(1)
self.assert_result(result, 172, self.particle_d_accel, False)
result = self.parser.get_records(1)
self.assert_result(result, 215, self.particle_e_accel, True)
self.assertEqual(self.exception_callback_value, None)
def test_long_stream_rate(self):
"""
Test a long (normal length file) with accel and rate particles
"""
self.stream_handle = open(os.path.join(RESOURCE_PATH,
'20140313_191853.3dmgx3.log'))
self.parser = MopakOStcParser(self.config, self.start_state, self.stream_handle,
'20140313_191853.3dmgx3.log',
self.state_callback, self.pub_callback,
self.except_callback)
result = self.parser.get_records(148)
self.assertEqual(result[0], self.particle_a11_accel)
self.assertEqual(result[-1], self.particle_last_rate)
self.assertEqual(self.parser._state[StateKey.POSITION], 5560)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 5560)
self.assertEqual(self.publish_callback_value[-1], self.particle_last_rate)
self.assertEqual(self.exception_callback_value, None)
class MopakOStcParserUnitTestCase(ParserUnitTestCase):
"""
MopakOStc Parser unit test suite
"""
def state_callback(self, state, file_ingested, file_name):
""" Call back method to watch what comes in via the position callback """
self.state_callback_value = state
self.file_ingested_value = file_ingested
def pub_callback(self, pub):
""" Call back method to watch what comes in via the publish callback """
self.publish_callback_value = pub
def except_callback(self, exception):
"""
Callback method to watch what comes in via the exception callback
"""
self.exception_callback_value = exception
def setUp(self):
ParserUnitTestCase.setUp(self)
self.config = {
DataSetDriverConfigKeys.PARTICLE_MODULE: 'mi.dataset.parser.mopak_o_stc',
DataSetDriverConfigKeys.PARTICLE_CLASS: ['MopakOStcAccelParserDataParticle',
'MopakOStcRateParserDataParticle']
}
self.start_state = {StateKey.POSITION: 0}
# using the same file, and hence the same start time, so just convert the start time here
file_datetime = datetime.strptime('20140120_140004', "%Y%m%d_%H%M%S")
local_seconds = time.mktime(file_datetime.timetuple())
start_time_utc = local_seconds - time.timezone
# Define test data particles and their associated timestamps which will be
# compared with returned results
self.timestamp1 = self.timer_to_timestamp(b'\x00\x00\x82\xb0', start_time_utc)
self.particle_a_accel = MopakOStcAccelParserDataParticle(b"\xcb\xbd\xe6\xac<\xbd\xd9\nA\xbf\x83\xa4" \
"+;\xaf\xb4\x01\xbd\xf2o\xd4\xbd\xfe\x9d'>P\xfd\xfc>t\xd5\xc4>\xed\x10\xb2\x00\x00\x82\xb0\x16I",
internal_timestamp=self.timestamp1)
self.timestamp2 = self.timer_to_timestamp(b'\x00\x00\x9b\x1a', start_time_utc)
self.particle_b_accel = MopakOStcAccelParserDataParticle(b"\xcb\xbe\x17Q\x8e\xbd\xc7_\x8a\xbf\x85\xc3" \
"e\xbc\xebN\x18\xbd\x9a\x86P\xbd\xf4\xe4\xd4>T38>s\xc8\xb9>\xea\xce\xd0\x00\x00\x9b\x1a\x15\xa5",
internal_timestamp=self.timestamp2)
self.timestamp3 = self.timer_to_timestamp(b'\x00\x00\xb3\x84', start_time_utc)
self.particle_c_accel = MopakOStcAccelParserDataParticle(b"\xcb\xbe1\xeak\xbd\xae?\x8a\xbf\x86\x18" \
"\x8a\xbd~\xde\xf0\xbc\xb2\x1d\xec\xbd\xd7\xe4\x04>U\xbcW>p\xf3U>\xeaOh\x00\x00\xb3\x84\x15\xd8",
internal_timestamp=self.timestamp3)
self.timestamp4 = self.timer_to_timestamp(b'\x00\x00\xcb\xee', start_time_utc)
self.particle_d_accel = MopakOStcAccelParserDataParticle(b"\xcb\xbe8\xed\xf0\xbd\xa7\x98'\xbf\x88" \
"\x0e\xca\xbd\xeegZ<\xf63\xdc\xbd\xe6b\x8d>U\xa5U>l6p>\xe9\xfc\x8d\x00\x00\xcb\xee\x16e",
internal_timestamp=self.timestamp4)
self.timestamp5 = self.timer_to_timestamp(b'\x00\x00\xe4X', start_time_utc)
self.particle_e_accel = MopakOStcAccelParserDataParticle(b"\xcb\xbe9t\xb5\xbd\x89\xd1\x16\xbf\x87" \
"\r\x14\xbe\r\xca\x9d=\xa9\x85+\xbd\xf3\x1c\xcb>R9\x1b>f\xcen>\xead\xb4\x00\x00\xe4X\x13\x1e",
internal_timestamp=self.timestamp5)
self.timestamp6 = self.timer_to_timestamp(b'\x04ud\x1e', start_time_utc)
self.particle_last_accel = MopakOStcAccelParserDataParticle(b"\xcb=\xfd\xb6?=0\x84\xf6\xbf\x82\xff" \
"\xed>\x07$\x16\xbe\xaf\xf3\xb9=\x93\xb5\xad\xbd\x97\xcb8\xbeo\x0bI>\xf4_K\x04ud\x1e\x14\x87",
internal_timestamp=self.timestamp6)
# got a second file with rate particles in it after writing tests, so adding new tests but leaving
# the old, resulting in many test particles
# after this is for a new file with rate in it
# using the same file, and hence the same start time, so just convert the start time here
file_datetime = datetime.strptime('20140313_191853', "%Y%m%d_%H%M%S")
local_seconds = time.mktime(file_datetime.timetuple())
start_time_utc = local_seconds - time.timezone
# first in larger file
self.timestampa11 = self.timer_to_timestamp(b'\x00\xae\x18\xb2', start_time_utc)
self.particle_a11_accel = MopakOStcAccelParserDataParticle(b"\xcb?(\xf4\x85?.\xf6k>\x9dq\x91\xba7r" \
"\x9b\xba\xca\x19T:\xff\xbc[\xbe\xfb\xd3\xdf\xbd\xc6\x0b\xbb\xbe\x7f\xa8T\x00\xae\x18\xb2\x15\xfa",
internal_timestamp=self.timestampa11)
# first in first_rate file
self.timestampa1 = self.timer_to_timestamp(b'\x00\xb5\xa1h', start_time_utc)
self.particle_a1_accel = MopakOStcAccelParserDataParticle(b"\xcb?(\xd3d?/\x0bd>\x9dxr\xba$eZ\xbbl" \
"\xaa\xea:\xed\xe7\xa6\xbe\xfb\xe1J\xbd\xc6\xfa\x90\xbe\x7f\xcc2\x00\xb5\xa1h\x16\x01",
internal_timestamp=self.timestampa1)
self.timestampb1 = self.timer_to_timestamp(b'\x00\xb5\xb9\xd2', start_time_utc)
self.particle_b1_accel = MopakOStcAccelParserDataParticle(b"\xcb?))$?/(\x9b>\x9e\x15w\xb9\x92\xc0" \
"\x16\xbah\xb6\x0e:\xe5\x97\xf3\xbe\xfc\x044\xbd\xc6\xf5\x1b\xbe\x80ym\x00\xb5\xb9\xd2\x13\xb2",
internal_timestamp=self.timestampb1)
self.timestamp1r = self.timer_to_timestamp(b'\x00\xd0\xe7\xd4', start_time_utc)
self.particle_a_rate = MopakOStcRateParserDataParticle(b"\xcf\xbf\xffNJ?:\x90\x8b@\x1e\xde\xa8\xba" \
"\tU\xe8\xbb\x07Z\xf2:\xb8\xa9\xc7\x00\xd0\xe7\xd4\x0f\x98", internal_timestamp=self.timestamp1r)
self.timestamp2r = self.timer_to_timestamp(b'\x00\xd1\x00>', start_time_utc)
self.particle_b_rate = MopakOStcRateParserDataParticle(b"\xcf\xbf\xffD\xa1?:\x92\x85@\x1e\xde\xcc:\xa3" \
"6\xf1\xba\xf7I@;\xc4\x05\x85\x00\xd1\x00>\r\xe0", internal_timestamp=self.timestamp2r)
self.timestamp3r = self.timer_to_timestamp(b'\x00\xd1\x18\xa8', start_time_utc)
self.particle_c_rate = MopakOStcRateParserDataParticle(b"\xcf\xbf\xffC\xcb?:\x8dL@\x1e\xdf6\xb9\xf5" \
"\xb1:\xb9\xdf\x06\n;\x05\\a\x00\xd1\x18\xa8\r/", internal_timestamp=self.timestamp3r)
# last in first_rate file
self.timestamp4r = self.timer_to_timestamp(b'\x00\xd11\x12', start_time_utc)
self.particle_d_rate = MopakOStcRateParserDataParticle(b"\xcf\xbf\xffF/?:\x8a\x1d@\x1e\xe0.\xba\xd3" \
"9*\xba\x80\x1c{:?-\xe9\x00\xd11\x12\x0b\xf2", internal_timestamp=self.timestamp4r)
# last in larger file
self.timestamp8r = self.timer_to_timestamp(b'\x00\xd73(', start_time_utc)
self.particle_last_rate = MopakOStcRateParserDataParticle(b"\xcf\xbf\xffK ?:r\xd4@\x1e\xf4\xf09\xa7\x91" \
"\xb0\xb9\x9b\x82\x85;$\x1f\xc7\x00\xd73(\r\xec", internal_timestamp=self.timestamp8r)
# uncomment the following to generate particles in yml format for driver testing results files
#self.particle_to_yml(self.particle_a1_accel)
#self.particle_to_yml(self.particle_b1_accel)
#self.particle_to_yml(self.particle_a_rate)
#self.particle_to_yml(self.particle_b_rate)
#self.particle_to_yml(self.particle_c_rate)
#self.particle_to_yml(self.particle_d_rate)
self.file_ingested_value = None
self.state_callback_value = None
self.publish_callback_value = None
self.exception_callback_value = None
def timer_to_timestamp(self, timer, start_time_utc):
"""
convert a timer value to a ntp formatted timestamp
"""
fields = struct.unpack('>I', timer)
# first divide timer by 62500 to go from counts to seconds
offset_secs = float(int(fields[0]))/62500.0
# add in the utc start time
time_secs = float(start_time_utc) + offset_secs
# convert to ntp64
return float(ntplib.system_to_ntp_time(time_secs))
def particle_to_yml(self, particle):
"""
This is added as a testing helper, not actually as part of the parser tests. Since the same particles
will be used for the driver test it is helpful to write them to .yml in the same form they need in the
results.yml files here.
"""
particle_dict = particle.generate_dict()
# open write append, if you want to start from scratch manually delete this file
fid = open('particle.yml', 'a')
fid.write(' - _index: 0\n')
fid.write(' internal_timestamp: %f\n' % particle_dict.get('internal_timestamp'))
fid.write(' particle_object: %s\n' % particle.__class__.__name__)
fid.write(' particle_type: %s\n' % particle_dict.get('stream_name'))
for val in particle_dict.get('values'):
if isinstance(val.get('value'), float):
fid.write(' %s: %16.20f\n' % (val.get('value_id'), val.get('value')))
else:
fid.write(' %s: %s\n' % (val.get('value_id'), val.get('value')))
fid.close()
def assert_result(self, result, position, particle, ingested):
self.assertEqual(result, [particle])
self.assertEqual(self.file_ingested_value, ingested)
self.assertEqual(self.parser._state[StateKey.POSITION], position)
self.assertEqual(self.state_callback_value[StateKey.POSITION], position)
self.assert_(isinstance(self.publish_callback_value, list))
self.assertEqual(self.publish_callback_value[0], particle)
def test_simple(self):
"""
Read test data and pull out data particles one at a time.
Assert that the results are those we expected.
"""
self.stream_handle = open(os.path.join(RESOURCE_PATH,
'first.mopak.log'))
self.parser = MopakOStcParser(self.config, self.start_state, self.stream_handle,
'20140120_140004.mopak.log',
self.state_callback, self.pub_callback,
self.except_callback)
# next get acceleration records
result = self.parser.get_records(1)
self.assert_result(result, 43, self.particle_a_accel, False)
result = self.parser.get_records(1)
self.assert_result(result, 86, self.particle_b_accel, False)
result = self.parser.get_records(1)
self.assert_result(result, 129, self.particle_c_accel, False)
result = self.parser.get_records(1)
self.assert_result(result, 172, self.particle_d_accel, False)
result = self.parser.get_records(1)
self.assert_result(result, 215, self.particle_e_accel, True)
# no data left, dont move the position
result = self.parser.get_records(1)
self.assertEqual(result, [])
self.assertEqual(self.parser._state[StateKey.POSITION], 215)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 215)
self.assert_(isinstance(self.publish_callback_value, list))
self.assertEqual(self.publish_callback_value[0], self.particle_e_accel)
self.assertEqual(self.exception_callback_value, None)
def test_simple_rate(self):
"""
Read test data and pull out data particles one at a time.
Assert that the results are those we expected.
"""
self.stream_handle = open(os.path.join(RESOURCE_PATH,
'first_rate.mopak.log'))
self.parser = MopakOStcParser(self.config, self.start_state, self.stream_handle,
'20140313_191853.mopak.log',
self.state_callback, self.pub_callback,
self.except_callback)
# next get accel and rate records
result = self.parser.get_records(1)
self.assert_result(result, 43, self.particle_a1_accel, False)
result = self.parser.get_records(1)
self.assert_result(result, 86, self.particle_b1_accel, False)
result = self.parser.get_records(1)
self.assert_result(result, 117, self.particle_a_rate, False)
result = self.parser.get_records(1)
self.assert_result(result, 148, self.particle_b_rate, False)
result = self.parser.get_records(1)
self.assert_result(result, 179, self.particle_c_rate, False)
result = self.parser.get_records(1)
self.assert_result(result, 210, self.particle_d_rate, True)
# no data left, dont move the position
result = self.parser.get_records(1)
self.assertEqual(result, [])
self.assertEqual(self.parser._state[StateKey.POSITION], 210)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 210)
self.assert_(isinstance(self.publish_callback_value, list))
self.assertEqual(self.publish_callback_value[0], self.particle_d_rate)
self.assertEqual(self.exception_callback_value, None)
def test_get_many(self):
"""
Read test data and pull out multiple data particles at one time.
Assert that the results are those we expected.
"""
self.stream_handle = open(os.path.join(RESOURCE_PATH,
'first.mopak.log'))
self.parser = MopakOStcParser(self.config, self.start_state, self.stream_handle,
'20140120_140004.mopak.log',
self.state_callback, self.pub_callback,
self.except_callback)
# next get accel records
result = self.parser.get_records(5)
self.assertEqual(result, [self.particle_a_accel,
self.particle_b_accel,
self.particle_c_accel,
self.particle_d_accel,
self.particle_e_accel])
self.assertEqual(self.parser._state[StateKey.POSITION], 215)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 215)
self.assertEqual(self.publish_callback_value[0], self.particle_a_accel)
self.assertEqual(self.publish_callback_value[1], self.particle_b_accel)
self.assertEqual(self.publish_callback_value[2], self.particle_c_accel)
self.assertEqual(self.publish_callback_value[3], self.particle_d_accel)
self.assertEqual(self.publish_callback_value[4], self.particle_e_accel)
self.assertEqual(self.file_ingested_value, True)
self.assertEqual(self.exception_callback_value, None)
def test_long_stream(self):
"""
Test a long (normal length file)
"""
self.stream_handle = open(os.path.join(RESOURCE_PATH,
'20140120_140004.mopak.log'))
self.parser = MopakOStcParser(self.config, self.start_state, self.stream_handle,
'20140120_140004.mopak.log', self.state_callback,
self.pub_callback, self.except_callback)
result = self.parser.get_records(11964)
self.assertEqual(result[0], self.particle_a_accel)
self.assertEqual(result[-1], self.particle_last_accel)
self.assertEqual(self.parser._state[StateKey.POSITION], 514452)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 514452)
self.assertEqual(self.publish_callback_value[-1], self.particle_last_accel)
self.assertEqual(self.exception_callback_value, None)
def test_long_stream_rate(self):
"""
Test a long (normal length file) with accel and rate particles
"""
self.stream_handle = open(os.path.join(RESOURCE_PATH,
'20140313_191853.3dmgx3.log'))
self.parser = MopakOStcParser(self.config, self.start_state, self.stream_handle,
'20140313_191853.3dmgx3.log',
self.state_callback, self.pub_callback,
self.except_callback)
result = self.parser.get_records(148)
self.assertEqual(result[0], self.particle_a11_accel)
self.assertEqual(result[-1], self.particle_last_rate)
self.assertEqual(self.parser._state[StateKey.POSITION], 5560)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 5560)
self.assertEqual(self.publish_callback_value[-1], self.particle_last_rate)
self.assertEqual(self.exception_callback_value, None)
def test_mid_state_start(self):
"""
Test starting the parser in a state in the middle of processing
"""
new_state = {StateKey.POSITION:86}
self.stream_handle = open(os.path.join(RESOURCE_PATH,
'first.mopak.log'))
self.parser = MopakOStcParser(self.config, new_state, self.stream_handle,
'20140120_140004.mopak.log', self.state_callback, self.pub_callback,
self.except_callback)
result = self.parser.get_records(1)
self.assert_result(result, 129, self.particle_c_accel, False)
result = self.parser.get_records(1)
self.assert_result(result, 172, self.particle_d_accel, False)
result = self.parser.get_records(1)
self.assert_result(result, 215, self.particle_e_accel, True)
self.assertEqual(self.exception_callback_value, None)
def test_set_state(self):
"""
Test changing to a new state after initializing the parser and
reading data, as if new data has been found and the state has
changed
"""
new_state = {StateKey.POSITION:129}
self.stream_handle = open(os.path.join(RESOURCE_PATH,
'first.mopak.log'))
self.parser = MopakOStcParser(self.config, self.start_state, self.stream_handle,
'20140120_140004.mopak.log',
self.state_callback, self.pub_callback,
self.except_callback)
result = self.parser.get_records(1)
self.assert_result(result, 43, self.particle_a_accel, False)
# set the new state, the essentially skips b and c
self.parser.set_state(new_state)
result = self.parser.get_records(1)
self.assert_result(result, 172, self.particle_d_accel, False)
result = self.parser.get_records(1)
self.assert_result(result, 215, self.particle_e_accel, True)
self.assertEqual(self.exception_callback_value, None)
def test_set_state_rate(self):
"""
Test changing to a new state after initializing the parser and
reading data, as if new data has been found and the state has
changed
"""
new_state = {StateKey.POSITION:117}
self.stream_handle = open(os.path.join(RESOURCE_PATH,
'first_rate.mopak.log'))
self.parser = MopakOStcParser(self.config, self.start_state, self.stream_handle,
'20140313_191853.3dmgx3.log',
self.state_callback, self.pub_callback,
self.except_callback)
result = self.parser.get_records(1)
self.assert_result(result, 43, self.particle_a1_accel, False)
# set the new state, the essentially skips b accel, a rate
self.parser.set_state(new_state)
result = self.parser.get_records(1)
self.assert_result(result, 148, self.particle_b_rate, False)
result = self.parser.get_records(1)
self.assert_result(result, 179, self.particle_c_rate, False)
result = self.parser.get_records(1)
self.assert_result(result, 210, self.particle_d_rate, True)
self.assertEqual(self.exception_callback_value, None)
def test_non_data_exception(self):
"""
Test that we get a sample exception from non data being found in the file
"""
self.stream_handle = open(os.path.join(RESOURCE_PATH, 'noise.mopak.log'))
self.parser = MopakOStcParser(self.config, self.start_state, self.stream_handle,
'20140120_140004.mopak.log',
self.state_callback, self.pub_callback,
self.except_callback)
# next get accel records
result = self.parser.get_records(5)
self.assertEqual(result, [self.particle_a_accel,
self.particle_b_accel,
self.particle_c_accel,
self.particle_d_accel,
self.particle_e_accel])
self.assertEqual(self.parser._state[StateKey.POSITION], 218)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 218)
self.assertEqual(self.publish_callback_value[0], self.particle_a_accel)
self.assertEqual(self.publish_callback_value[1], self.particle_b_accel)
self.assertEqual(self.publish_callback_value[2], self.particle_c_accel)
self.assertEqual(self.publish_callback_value[3], self.particle_d_accel)
self.assertEqual(self.publish_callback_value[4], self.particle_e_accel)
self.assertEqual(self.file_ingested_value, True)
self.assert_(isinstance(self.exception_callback_value, SampleException))
