def test_read_bytes(self):
port = PORT.replace('%DIR%', self.tmpdirname)
sim = SimSerial(port=port, source_file=self.logfile_filename,
use_timestamps=False)
sim_thread = threading.Thread(target=sim.run)
sim_thread.start()
# Give it a moment to get started
time.sleep(0.1)
slice = SliceTransform('1:') # we'll want to strip out timestamp
# Then read from serial port
s = SerialReader(port=port, max_bytes=2)
for data in SAMPLE_MAX_BYTES_2:
record = s.read()
logging.debug('data: %s, read: %s', data, record)
self.assertEqual(data, record)
def test_timeout(self):
port = PORT.replace('%DIR%', self.tmpdirname)
sim = SimSerial(port=port, source_file=self.logfile_filename)
sim_thread = threading.Thread(target=sim.run)
sim_thread.start()
# Give it a moment to get started
time.sleep(0.05)
# Then read from serial port
s = SerialReader(port=port, timeout=0.1)
for line in SAMPLE_TIMEOUT:
record = s.read()
logging.debug('data: %s, read: %s', line, record)
self.assertEqual(line, record, msg='Note: this is a time-sensitive '
'test that can fail non-deterministically. If the '
'test fails, try running from the command line, e.g. '
'as "logger/readers/test_serial_reader.py"')
(database, fields) = database.split(':')
else:
fields = None
readers.append(DatabaseReader(fields=fields,
database=database, host=host,
user=user, password=password))
# SerialReader is a little more complicated than other readers
# because it can take so many parameters. Use the kwargs trick to
# pass them all in.
if new_args.serial:
kwargs = {}
for pair in new_args.serial.split(','):
(key, value) = pair.split('=')
kwargs[key] = value
readers.append(SerialReader(**kwargs))
##########################
# Transforms
if new_args.slice:
transforms.append(SliceTransform(new_args.slice,
all_args.slice_separator))
if new_args.timestamp:
transforms.append(TimestampTransform(time_format=all_args.time_format))
if new_args.prefix:
transforms.append(PrefixTransform(new_args.prefix))
if new_args.extract:
transforms.append(ExtractFieldTransform(new_args.extract))
if new_args.regex_filter:
transforms.append(RegexFilterTransform(new_args.regex_filter))
if new_args.qc_filter:
def _run_read_specialcase(port):
reader = SerialReader(port)
res = reader.read()
logging.info('data: %s', 'read: %s', '♥�♥\x00♥♥', res)
self.assertEqual('♥�♥\x00♥♥', res)
def _run_reader(port):
reader = SerialReader(port)
for line in SAMPLE_DATA.split('\n'):
result = reader.read()
logging.info('data: %s, read: %s', line, result)
self.assertEqual(line, result)
def test_unicode(self):
port = PORT.replace('%DIR%', self.tmpdirname)
sim = SimSerial(port=port, source_file=self.logfile_filename,
use_timestamps=False)
sim_thread = threading.Thread(target=sim.run)
sim_thread.start()
# Give it a moment to get started
time.sleep(0.1)
# For some reason, the test complains unless we actually read
# from the port. This first SerialReader is here just to get
# rid of the error message that pops up from SimSerial if we
# don't use it.
s = SerialReader(port=port)
for line in SAMPLE_DATA.split('\n'):
record = s.read()
# Now we're going to create SerialReaders with stubbed
# self.serial.readline methods so that when they're called,
# we instead get the same bit of bad unicode over and over
# again. We want to test that it performs correctly under
# conditions.
# A dummy serial readline that will feed us bad unicode
def dummy_readline():
return b'\xe2\x99\xa5\x99\xe2\x99\xa5\x00\xe2\x99\xa5\xe2\x99\xa5'
# Create a SerialReader, then replace its serial reader with a stub so
# we can feed it bad records.
s = SerialReader(port=port)
s.serial.readline = dummy_readline
self.assertEqual('♥♥\x00♥♥', s.read())
s = SerialReader(port=port, encoding_errors='replace')
s.serial.readline = dummy_readline
self.assertEqual('♥�♥\x00♥♥', s.read())
s = SerialReader(port=port, encoding_errors='strict')
s.serial.readline = dummy_readline
with self.assertLogs(logging.getLogger(), logging.WARNING):
self.assertEqual(None, s.read())
# Don't decode at all - return raw bytes
s = SerialReader(port=port, encoding=None)
s.serial.readline = dummy_readline
self.assertEqual(dummy_readline(), s.read())
