def use_dummy_serial_port(printer:SerialDevice):
# FIXME
# not great, should be async!!!
def delayed_string(result:Union[str,bytes]):
# print ("delayed string {}".format(time.time()))
time.sleep(random.uniform(0.05,0.5))
# print ("delayed string {}".format(time.time()))
return result
printer._serial_port = "/dev/null"
printer._serial = dummyserial.Serial(port=printer._serial_port,
baudrate=printer._baud_rate,
ds_responses={
'N?[0-9]*(M105).*': lambda : b'ok T:%.2f /190.0 B:%.2f /24.0 @:0 B@:0\nok\n' % (random.uniform(170,195),random.uniform(20,35)),
'N?[0-9]*M115.*': b'FIRMWARE_NAME:DUMMY\nok\n',
'N?[0-9]*M114.*': lambda : b'X:%.2fY:%.2fZ:%.2fE:%.2f Count X: 2.00Y:3.00Z:4.00\nok\n' % (random.uniform(0,200), random.uniform(0,200), random.uniform(0,200), random.uniform(0,200)), # position request
'N?[0-9]*G.*': lambda : delayed_string(b'ok\n'),
'N?[0-9]*M400.*': lambda : delayed_string(b'ok\nok\n'),
'N?[0-9]*M207.*': lambda : delayed_string(b'ok\nok\n'),
'N?[0-9]*M208.*': lambda : delayed_string(b'ok\nok\n'),
'N?[0-9]*M10[0-46-9].*': lambda : delayed_string(b'ok\nok\n'),
"N?[0-9]*(M[0-9]+).*" : lambda : delayed_string(b'ok\nok\n'), # catch all M codes
'^XXX': b'!!\n',
})
if not printer._serial.is_open:
printer._serial.open()
printer.connection_state = ConnectionState.connected
def use_dummy_serial_port(printer: USBSerial):
if printer._serial_port is not "/dev/null" and printer._serial is None:
def delayed_string(result: Union[str, bytes]):
# print ("delayed string {}".format(time.time()))
time.sleep(random.uniform(0.05, 0.5))
# print ("delayed string {}".format(time.time()))
return result
printer._serial_port = "/dev/null"
printer._serial = dummyserial.Serial(
port=printer._serial_port,
baudrate=printer._baud_rate,
ds_responses={
'.*M105.*':
lambda: b'ok T:%.2f /190.0 B:%.2f /24.0 @:0 B@:0\n' %
(random.uniform(170, 195), random.uniform(20, 35)),
'.*M115.*':
b'FIRMWARE_NAME:DUMMY\n',
'.*M114.*':
lambda: b'X:%.2fY:%.2fZ:%.2fE:%.2f Count X: 2.00Y:3.00Z:4.00\n'
% (random.uniform(0, 200), random.uniform(0, 200),
random.uniform(0, 200), random.uniform(0, 200)
), # position request
'.*G.*':
lambda: delayed_string(b'ok\n'),
'.*M400.*':
lambda: delayed_string(b'ok\n'),
#'^N.*': b'ok\n',
'^XXX':
b'!!\n'
})
printer.connection_state = ConnectionState.connected
def test_get_channel_parameters(self):
random_channel = random.randint(0, 13)
random_channel_parameters = '\n'.join([
self.random(6, constants.NUMBERS),
self.random(6, constants.NUMBERS),
self.random(5, constants.NUMBERS),
self.random(1, '01'),
self.random(1, '01')
])
self._logger.debug('random_channel=%s', random_channel)
self._logger.debug('random_channel_parameters=%s',
random_channel_parameters)
self.rsuv3.interface = dummyserial.Serial(
port=self.random_serial_port,
ds_responses={
"CP%s\r\n" % random_channel: random_channel_parameters
})
self._logger.info('rsuv3 interface=%s', self.rsuv3.interface)
channel_parameters = self.rsuv3.get_channel_parameters(random_channel)
self._logger.debug('channel_parameters=%s', channel_parameters)
rcp_serialized = rsuv3.util.cp_serializer(random_channel_parameters,
random_channel)
self.assertEqual(channel_parameters, rcp_serialized)
def test_config_xastir(self):
"""Tests writing Xastir config to KISS TNC."""
ks = kiss.SerialKISS(port=self.random_serial_port,
speed=self.random_baudrate)
ks.interface = dummyserial.Serial(port=self.random_serial_port,
baudrate=self.random_baudrate)
ks._write_handler = ks.interface.write
ks.config_xastir()
def test_set_squelch_level(self):
random_squelch_level = self.random(1, constants.NUMBERS)
self._logger.debug('random_squelch_level=%s', random_squelch_level)
self.rsuv3.interface = dummyserial.Serial(
port=self.random_serial_port,
ds_responses={"SQ%s\r\n" % random_squelch_level: ''})
self._logger.info('rsuv3 interface=%s', self.rsuv3.interface)
squelch_level = self.rsuv3.set_squelch_level(random_squelch_level)
self.assertEqual('', squelch_level)
def test_get_firmware(self):
random_firmware = self.random()
self._logger.debug('random_firmware=%s', random_firmware)
self.rsuv3.interface = dummyserial.Serial(
port=self.random_serial_port,
ds_responses={'FW\r\n': random_firmware})
self._logger.info('rsuv3 interface=%s', self.rsuv3.interface)
firmware = self.rsuv3.get_firmware()
self._logger.debug('firmware=%s', firmware)
self.assertEqual(firmware, {'firmware_version': random_firmware})
def test_get_squelch_level(self):
random_squelch_level = self.random(1, constants.NUMBERS)
self._logger.debug('random_squelch_level=%s', random_squelch_level)
self.rsuv3.interface = dummyserial.Serial(
port=self.random_serial_port,
ds_responses={'SQ?\r\n': 'SQ ' + random_squelch_level})
self._logger.info('rsuv3 interface=%s', self.rsuv3.interface)
squelch_level = self.rsuv3.get_squelch_level()
self.assertEqual({'squelch_level': random_squelch_level},
squelch_level)
def test_dummy_methods(self):
"""Tests writing-to and reading-from a Dummy Serial port (functions)"""
rand_write_len1 = random.randint(0, 1024)
rand_write_str1 = self.random(rand_write_len1).encode()
ds_instance = dummyserial.Serial(
port=self.random_serial_port,
baudrate=self.random_baudrate,
responses={rand_write_str1: dummy_method})
ds_instance.write(rand_write_str1)
read_data = b''
read_data = b''.join([read_data, ds_instance.read(rand_write_len1)])
self.assertEqual(read_data, rand_write_str1)
def test_send_dtmf(self):
dtmf_alpha = constants.NUMBERS + constants.ALPHABET[:3] + '*#'
rand_len = random.randint(1, 28)
random_dtmf = self.random(rand_len, dtmf_alpha)
self._logger.debug('random_dtmf=%s', random_dtmf)
self.rsuv3.interface = dummyserial.Serial(
port=self.random_serial_port,
ds_responses={"DS%s\r\n" % random_dtmf: ''})
self._logger.info('rsuv3 interface=%s', self.rsuv3.interface)
dtmf_result = self.rsuv3.send_dtmf(random_dtmf)
self.assertEqual('', dtmf_result)
def test_repr_port(self):
"""Tests describing a Dummy Serial port."""
rand_write_len1 = random.randint(0, 1024)
rand_write_len2 = random.randint(0, 1024)
rand_write_str1 = self.random(rand_write_len1).encode()
rand_write_str2 = self.random(rand_write_len2).encode()
ds_instance = dummyserial.Serial(
port=self.random_serial_port,
baudrate=self.random_baudrate,
responses={rand_write_str1: rand_write_str2})
self.assertTrue(self.random_serial_port in str(ds_instance))
def _get_serial(self):
if self.port_name == "dummy":
import dummyserial
responses = {"0\n": "T1 = 21, T2 = 40"}
return dummyserial.Serial(port=self.port_name,
baud=9600,
timeout=1,
ds_responses=responses)
else:
import serial
return serial.Serial(self.port_name, 9600, timeout=1)
def test_close(self):
"""Tests closing a Dummy Serial port."""
rand_write_len1 = random.randint(0, 1024)
rand_write_len2 = random.randint(0, 1024)
rand_write_str1 = self.random(rand_write_len1).encode()
rand_write_str2 = self.random(rand_write_len2).encode()
ds_instance = dummyserial.Serial(
port=self.random_serial_port,
baudrate=self.random_baudrate,
responses={rand_write_str1: rand_write_str2})
self.assertTrue(ds_instance._isOpen) # pylint: disable=W0212
self.assertFalse(ds_instance.close())
self.assertFalse(ds_instance._isOpen) # pylint: disable=W0212
def test_get_squelch_state(self):
random_squelch_state = self.random(1, '01')
self._logger.debug('random_squelch_state=%s', random_squelch_state)
self.rsuv3.interface = dummyserial.Serial(
port=self.random_serial_port,
ds_responses={'SO\r\n': 'SO: ' + random_squelch_state})
self._logger.info('rsuv3 interface=%s', self.rsuv3.interface)
if random_squelch_state == '0':
rss = 'closed'
elif random_squelch_state == '1':
rss = 'open'
squelch_state = self.rsuv3.get_squelch_state()
self.assertEqual({'squelch_state': rss}, squelch_state)
def test_write_closed_port(self):
"""Tests writing-to a closed Dummy Serial port."""
rand_write_len1 = random.randint(0, 1024)
rand_write_len2 = random.randint(0, 1024)
rand_write_str1 = self.random(rand_write_len1).encode()
rand_write_str2 = self.random(rand_write_len2).encode()
ds_instance = dummyserial.Serial(
port=self.random_serial_port,
baudrate=self.random_baudrate,
responses={rand_write_str1: rand_write_str2})
self.assertTrue(ds_instance._isOpen) # pylint: disable=W0212
ds_instance.close()
self.assertFalse(ds_instance._isOpen) # pylint: disable=W0212
with self.assertRaises(SerialException):
ds_instance.write(rand_write_str1)
self.assertFalse(ds_instance._isOpen) # pylint: disable=W0212
def test_write_and_read_no_data_present(self): # pylint: disable=C0103
"""Tests writing and reading with an unspecified response."""
rand_write_len1 = random.randint(256, 1024)
rand_read_len2 = random.randint(
1, 16) # give it some order of magnitudes less
rand_write_str1 = self.random(rand_write_len1)
ds_instance = dummyserial.Serial(port=self.random_serial_port,
baudrate=self.random_baudrate)
ds_instance.write(rand_write_str1)
while 1:
ds_instance.read(rand_read_len2) # discard this data
if not ds_instance.inWaiting():
empty_data = ds_instance.read(rand_read_len2)
break
self.assertEqual(dummyserial.constants.NO_DATA_PRESENT, empty_data)
def test_write(self):
ks = kiss.SerialKISS(port=self.random_serial_port, speed='9600')
ks.interface = dummyserial.Serial(port=self.random_serial_port)
ks._write_handler = ks.interface.write
frame = aprs.Frame()
frame.source = aprs.Callsign(self.random(6))
frame.destination = aprs.Callsign(self.random(6))
frame.path = [
aprs.Callsign(self.random(6)),
aprs.Callsign(self.random(6))
]
frame.text = ' '.join([self.random(), 'test_write', self.random()])
self._logger.debug('frame="%s"', frame)
frame_encoded = frame.encode_kiss()
self._logger.debug('frame_encoded="%s"', frame_encoded)
ks.write(frame_encoded)
def test_write_and_read_no_data_present(self): # pylint: disable=C0103
"""Tests writing and reading with an unspecified response."""
rand_write_len1 = random.randint(0, 1024)
rand_write_len2 = random.randint(0, 1024)
rand_write_str1 = self.random(rand_write_len1).encode()
ds_instance = dummyserial.Serial(port=self.random_serial_port,
baudrate=self.random_baudrate)
ds_instance.write(rand_write_str1)
read_data = b''
while 1:
read_data = b''.join(
[read_data, ds_instance.read(rand_write_len2)])
waiting_data = ds_instance.outWaiting()
if not waiting_data:
break
read_data = read_data.decode("utf-8")
self.assertEqual(dummyserial.constants.NO_DATA_PRESENT, read_data)
def test_write_and_read(self):
"""Tests writing-to and reading-from a Dummy Serial port (just strings)"""
rand_write_len1 = random.randint(0, 1024)
rand_write_len2 = random.randint(0, 1024)
rand_write_str1 = self.random(rand_write_len1).encode()
rand_write_str2 = self.random(rand_write_len2).encode()
ds_instance = dummyserial.Serial(
port=self.random_serial_port,
baudrate=self.random_baudrate,
responses={rand_write_str1: rand_write_str2})
ds_instance.write(rand_write_str1)
read_data = b''
while 1:
read_data = b''.join(
[read_data, ds_instance.read(rand_write_len2)])
waiting_data = ds_instance.inWaiting()
if not waiting_data:
break
self.assertEqual(read_data, rand_write_str2)
def use_dummy_serial_port(printer: USBPrinter):
printer._serial_port = "/dev/null"
printer._serial = dummyserial.Serial(
port=printer._serial_port,
baudrate=printer._baud_rate,
ds_responses={
'.*M105.*':
lambda: b'ok T:%.2f /190.0 B:%.2f /24.0 @:0 B@:0\n' %
(random.uniform(170, 195), random.uniform(20, 35)),
'.*M115.*':
b'FIRMWARE_NAME:DUMMY\n',
'.*M114.*':
lambda: b'X:%.2fY:%.2fZ:%.2fE:%.2f Count X: 2.00Y:3.00Z:4.00\n' %
(random.uniform(0, 200), random.uniform(0, 200),
random.uniform(0, 200), random.uniform(0, 200)
), # position request
'.*G.*':
b'ok\n',
#'^N.*': b'ok\n',
'^XXX':
b'!!\n'
})
printer.setConnectionState(ConnectionState.connected)
def test_write_and_read(self):
"""Tests writing-to and reading-from a Dummy Serial port."""
frame = aprs.Frame()
frame.source = aprs.Callsign(self.random(6))
frame.destination = aprs.Callsign(self.random(6))
frame.path = [
aprs.Callsign(self.random(6)),
aprs.Callsign(self.random(6))
]
frame.text = ' '.join(
[self.random(), 'test_write_and_read',
self.random()])
self._logger.debug('frame="%s"', frame)
frame_encoded = frame.encode_kiss()
self._logger.debug('frame_encoded="%s"', frame_encoded)
frame_escaped = kiss.escape_special_codes(frame_encoded)
self._logger.debug('frame_escaped="%s"', frame_escaped)
frame_kiss = ''.join(
[kiss.FEND, kiss.DATA_FRAME, frame_escaped, kiss.FEND])
self._logger.debug('frame_kiss="%s"', frame_kiss)
ks = kiss.SerialKISS(port=self.random_serial_port,
speed=self.random_baudrate)
ks.interface = dummyserial.Serial(
port=self.random_serial_port,
baudrate=self.random_baudrate,
ds_responses={frame_encoded: frame_kiss})
ks._write_handler = ks.interface.write
ks.write(frame_encoded)
read_data = ks._read_handler(len(frame_kiss))
