kopia lustrzana https://github.com/glidernet/python-ogn-client
refactoring: use assert instead of unittest function
Konstantin Gründger
rodzic
d724c3ee5e
commit
a6c320c444
|
|
@ -9,15 +9,15 @@ from ogn.client.settings import APRS_APP_NAME, APRS_APP_VER, APRS_KEEPALIVE_TIME
|
|||
class AprsClientTest(unittest.TestCase):
|
||||
def test_create_aprs_login(self):
|
||||
basic_login = create_aprs_login('klaus', -1, 'myApp', '0.1')
|
||||
self.assertEqual('user klaus pass -1 vers myApp 0.1\n', basic_login)
|
||||
assert 'user klaus pass -1 vers myApp 0.1\n' == basic_login
|
||||
|
||||
login_with_filter = create_aprs_login('klaus', -1, 'myApp', '0.1', 'r/48.0/11.0/100')
|
||||
self.assertEqual('user klaus pass -1 vers myApp 0.1 filter r/48.0/11.0/100\n', login_with_filter)
|
||||
assert 'user klaus pass -1 vers myApp 0.1 filter r/48.0/11.0/100\n' == login_with_filter
|
||||
|
||||
def test_initialisation(self):
|
||||
client = AprsClient(aprs_user='testuser', aprs_filter='')
|
||||
self.assertEqual(client.aprs_user, 'testuser')
|
||||
self.assertEqual(client.aprs_filter, '')
|
||||
assert client.aprs_user == 'testuser'
|
||||
assert client.aprs_filter == ''
|
||||
|
||||
@mock.patch('ogn.client.client.socket')
|
||||
def test_connect_full_feed(self, mock_socket):
|
||||
|
|
@ -42,7 +42,7 @@ class AprsClientTest(unittest.TestCase):
|
|||
client.disconnect()
|
||||
client.sock.shutdown.assert_called_once_with(0)
|
||||
client.sock.close.assert_called_once_with()
|
||||
self.assertTrue(client._kill)
|
||||
assert client._kill is True
|
||||
|
||||
@mock.patch('ogn.client.client.socket')
|
||||
def test_run(self, mock_socket):
|
||||
|
|
@ -112,14 +112,14 @@ class AprsClientTest(unittest.TestCase):
|
|||
client.run(callback=mock_callback, autoreconnect=True)
|
||||
|
||||
# After .disconnect(), client._kill should be True
|
||||
self.assertTrue(client._kill)
|
||||
self.assertEqual(mock_callback.call_count, 1)
|
||||
assert client._kill is True
|
||||
assert mock_callback.call_count == 1
|
||||
|
||||
# After we reconnect, .run() should be able to run again
|
||||
mock_callback.reset_mock()
|
||||
client.connect()
|
||||
client.run(callback=mock_callback, autoreconnect=True)
|
||||
self.assertEqual(mock_callback.call_count, 1)
|
||||
assert mock_callback.call_count == 1
|
||||
|
||||
@unittest.skip("Too much invalid APRS data on the live feed")
|
||||
def test_50_live_messages(self):
|
||||
|
|
@ -148,4 +148,3 @@ class AprsClientTest(unittest.TestCase):
|
|||
pass
|
||||
finally:
|
||||
client.disconnect()
|
||||
self.assertTrue(True)
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ class TestStringMethods(unittest.TestCase):
|
|||
message = parse(line, datetime(2015, 4, 10, 17, 0))
|
||||
self.assertFalse(message is None)
|
||||
if message['aprs_type'] == 'position' or message['aprs_type'] == 'status':
|
||||
self.assertEqual(message['beacon_type'], beacon_type)
|
||||
assert message['beacon_type'] == beacon_type
|
||||
except NotImplementedError as e:
|
||||
print(e)
|
||||
|
||||
|
|
@ -68,8 +68,8 @@ class TestStringMethods(unittest.TestCase):
|
|||
|
||||
def test_generic_beacons(self):
|
||||
message = parse("EPZR>WTFDSTCALL,TCPIP*,qAC,GLIDERN1:>093456h this is a comment")
|
||||
self.assertEqual(message['beacon_type'], 'unknown')
|
||||
self.assertEqual(message['comment'], "this is a comment")
|
||||
assert message['beacon_type'] == 'unknown'
|
||||
assert message['comment'] == "this is a comment"
|
||||
|
||||
def test_fail_parse_aprs_none(self):
|
||||
with self.assertRaises(TypeError):
|
||||
|
|
@ -87,11 +87,11 @@ class TestStringMethods(unittest.TestCase):
|
|||
# receiver beacons from chile have a APRS position message with a pure user comment
|
||||
message = parse("VITACURA1>APRS,TCPIP*,qAC,GLIDERN4:/201146h3322.79SI07034.80W&/A=002329 Vitacura Municipal Aerodrome, Club de Planeadores Vitacura")
|
||||
|
||||
self.assertEqual(message['user_comment'], "Vitacura Municipal Aerodrome, Club de Planeadores Vitacura")
|
||||
assert message['user_comment'] == "Vitacura Municipal Aerodrome, Club de Planeadores Vitacura"
|
||||
|
||||
message_with_id = parse("ALFALFAL>APRS,TCPIP*,qAC,GLIDERN4:/221830h3330.40SI07007.88W&/A=008659 Alfalfal Hidroelectric Plant, Club de Planeadores Vitacurs")
|
||||
|
||||
self.assertEqual(message_with_id['user_comment'], "Alfalfal Hidroelectric Plant, Club de Planeadores Vitacurs")
|
||||
assert message_with_id['user_comment'] == "Alfalfal Hidroelectric Plant, Club de Planeadores Vitacurs"
|
||||
|
||||
@mock.patch('ogn.parser.parse_module.createTimestamp')
|
||||
def test_default_reference_date(self, createTimestamp_mock):
|
||||
|
|
@ -111,8 +111,8 @@ class TestStringMethods(unittest.TestCase):
|
|||
valid_aprs_string = "FLRDDA5BA>APRS,qAS,LFMX:/160829h4415.41N/00600.03E'342/049/A=005524 id0ADDA5BA -454fpm -1.1rot 8.8dB 0e +51.2kHz gps4x5"
|
||||
message = parse(valid_aprs_string)
|
||||
|
||||
self.assertEqual(message['name'], 'FLRDDA5BA')
|
||||
self.assertEqual(message['address'], 'DDA5BA')
|
||||
assert message['name'] == 'FLRDDA5BA'
|
||||
assert message['address'] == 'DDA5BA'
|
||||
|
||||
def test_bad_naviter_format(self):
|
||||
with self.assertRaises(OgnParseError):
|
||||
|
|
@ -121,11 +121,11 @@ class TestStringMethods(unittest.TestCase):
|
|||
def test_no_receiver(self):
|
||||
result = parse("EDFW>OGNSDR:/102713h4949.02NI00953.88E&/A=000984")
|
||||
|
||||
self.assertEqual(result['aprs_type'], 'position')
|
||||
self.assertEqual(result['beacon_type'], 'receiver')
|
||||
self.assertEqual(result['name'], 'EDFW')
|
||||
self.assertEqual(result['dstcall'], 'OGNSDR')
|
||||
self.assertEqual(result['receiver_name'], None)
|
||||
assert result['aprs_type'] == 'position'
|
||||
assert result['beacon_type'] == 'receiver'
|
||||
assert result['name'] == 'EDFW'
|
||||
assert result['dstcall'] == 'OGNSDR'
|
||||
assert result['receiver_name'] is None
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -15,26 +15,26 @@ class TestStringMethods(unittest.TestCase):
|
|||
def test_basic(self):
|
||||
message = parse_aprs("FLRDDA5BA>APRS,qAS,LFMX:/160829h4415.41N/00600.03E'342/049/A=005524 this is a comment")
|
||||
|
||||
self.assertEqual(message['aprs_type'], 'position')
|
||||
self.assertEqual(message['name'], "FLRDDA5BA")
|
||||
self.assertEqual(message['dstcall'], "APRS")
|
||||
self.assertEqual(message['receiver_name'], "LFMX")
|
||||
self.assertEqual(message['timestamp'].strftime('%H:%M:%S'), "16:08:29")
|
||||
assert message['aprs_type'] == 'position'
|
||||
assert message['name'] == "FLRDDA5BA"
|
||||
assert message['dstcall'] == "APRS"
|
||||
assert message['receiver_name'] == "LFMX"
|
||||
assert message['timestamp'].strftime('%H:%M:%S') == "16:08:29"
|
||||
self.assertAlmostEqual(message['latitude'], 44.25683, 5)
|
||||
self.assertEqual(message['symboltable'], '/')
|
||||
assert message['symboltable'] == '/'
|
||||
self.assertAlmostEqual(message['longitude'], 6.0005, 5)
|
||||
self.assertEqual(message['symbolcode'], '\'')
|
||||
self.assertEqual(message['track'], 342)
|
||||
self.assertEqual(message['ground_speed'], 49 * KNOTS_TO_MS / KPH_TO_MS)
|
||||
assert message['symbolcode'] == '\''
|
||||
assert message['track'] == 342
|
||||
assert message['ground_speed'] == 49 * KNOTS_TO_MS / KPH_TO_MS
|
||||
self.assertAlmostEqual(message['altitude'], 5524 * FEETS_TO_METER, 5)
|
||||
self.assertEqual(message['comment'], "this is a comment")
|
||||
assert message['comment'] == "this is a comment"
|
||||
|
||||
def test_v024(self):
|
||||
# higher precision datum format introduced
|
||||
raw_message = "FLRDDA5BA>APRS,qAS,LFMX:/160829h4415.41N/00600.03E'342/049/A=005524 !W26! id21400EA9 -2454fpm +0.9rot 19.5dB 0e -6.6kHz gps1x1 s6.02 h44 rDF0C56"
|
||||
message = parse_aprs(raw_message)
|
||||
|
||||
self.assertEqual(message['aprs_type'], 'position')
|
||||
assert message['aprs_type'] == 'position'
|
||||
self.assertAlmostEqual(message['latitude'] - 44.2568 - 1 / 30000, 2 / 1000 / 60, 10)
|
||||
self.assertAlmostEqual(message['longitude'] - 6.0005, 6 / 1000 / 60, 10)
|
||||
|
||||
|
|
@ -43,70 +43,70 @@ class TestStringMethods(unittest.TestCase):
|
|||
raw_message = "EPZR>APRS,TCPIP*,qAC,GLIDERN1:>093456h this is a comment"
|
||||
message = parse_aprs(raw_message)
|
||||
|
||||
self.assertEqual(message['aprs_type'], 'status')
|
||||
self.assertEqual(message['name'], "EPZR")
|
||||
self.assertEqual(message['receiver_name'], "GLIDERN1")
|
||||
self.assertEqual(message['timestamp'].strftime('%H:%M:%S'), "09:34:56")
|
||||
self.assertEqual(message['comment'], "this is a comment")
|
||||
assert message['aprs_type'] == 'status'
|
||||
assert message['name'] == "EPZR"
|
||||
assert message['receiver_name'] == "GLIDERN1"
|
||||
assert message['timestamp'].strftime('%H:%M:%S') == "09:34:56"
|
||||
assert message['comment'] == "this is a comment"
|
||||
|
||||
def test_v026(self):
|
||||
# from 0.2.6 the ogn comment of a receiver beacon is just optional
|
||||
raw_message = "Ulrichamn>APRS,TCPIP*,qAC,GLIDERN1:/085616h5747.30NI01324.77E&/A=001322"
|
||||
message = parse_aprs(raw_message)
|
||||
|
||||
self.assertEqual(message['aprs_type'], 'position')
|
||||
self.assertEqual(message['comment'], '')
|
||||
assert message['aprs_type'] == 'position'
|
||||
assert message['comment'] == ''
|
||||
|
||||
def test_v026_relay(self):
|
||||
# beacons can be relayed
|
||||
raw_message = "FLRFFFFFF>OGNAVI,NAV07220E*,qAS,NAVITER:/092002h1000.00S/01000.00W'000/000/A=003281 !W00! id2820FFFFFF +300fpm +1.7rot"
|
||||
message = parse_aprs(raw_message)
|
||||
|
||||
self.assertEqual(message['aprs_type'], 'position')
|
||||
self.assertEqual(message['relay'], "NAV07220E")
|
||||
assert message['aprs_type'] == 'position'
|
||||
assert message['relay'] == "NAV07220E"
|
||||
|
||||
def test_v027_ddhhmm(self):
|
||||
# beacons can have hhmmss or ddhhmm timestamp
|
||||
raw_message = "ICA4B0678>APRS,qAS,LSZF:/301046z4729.50N/00812.89E'227/091/A=002854 !W01! id054B0678 +040fpm +0.0rot 19.0dB 0e +1.5kHz gps1x1"
|
||||
message = parse_aprs(raw_message)
|
||||
|
||||
self.assertEqual(message['aprs_type'], 'position')
|
||||
self.assertEqual(message['timestamp'].strftime('%d %H:%M'), "30 10:46")
|
||||
assert message['aprs_type'] == 'position'
|
||||
assert message['timestamp'].strftime('%d %H:%M') == "30 10:46"
|
||||
|
||||
def test_v028_fanet_position_weather(self):
|
||||
# with v0.2.8 fanet devices can report weather data
|
||||
raw_message = 'FNTFC9002>OGNFNT,qAS,LSXI2:/163051h4640.33N/00752.21E_187/004g007t075h78b63620 29.0dB -8.0kHz'
|
||||
message = parse_aprs(raw_message)
|
||||
|
||||
self.assertEqual(message['aprs_type'], 'position_weather')
|
||||
self.assertEqual(message['wind_direction'], 187)
|
||||
self.assertEqual(message['wind_speed'], 4 * KNOTS_TO_MS / KPH_TO_MS)
|
||||
self.assertEqual(message['wind_speed_peak'], 7 * KNOTS_TO_MS / KPH_TO_MS)
|
||||
self.assertEqual(message['temperature'], fahrenheit_to_celsius(75))
|
||||
self.assertEqual(message['humidity'], 78 * 0.01)
|
||||
self.assertEqual(message['barometric_pressure'], 63620)
|
||||
assert message['aprs_type'] == 'position_weather'
|
||||
assert message['wind_direction'] == 187
|
||||
assert message['wind_speed'] == 4 * KNOTS_TO_MS / KPH_TO_MS
|
||||
assert message['wind_speed_peak'] == 7 * KNOTS_TO_MS / KPH_TO_MS
|
||||
assert message['temperature'] == fahrenheit_to_celsius(75)
|
||||
assert message['humidity'] == 78 * 0.01
|
||||
assert message['barometric_pressure'] == 63620
|
||||
|
||||
self.assertEqual(message['comment'], '29.0dB -8.0kHz')
|
||||
assert message['comment'] == '29.0dB -8.0kHz'
|
||||
|
||||
def test_GXAirCom_fanet_position_weather_rainfall(self):
|
||||
raw_message = 'FNT08F298>OGNFNT,qAS,DREIFBERG:/082654h4804.90N/00845.74E_273/005g008t057r123p234h90b10264 0.0dB'
|
||||
message = parse_aprs(raw_message)
|
||||
|
||||
self.assertEqual(message['aprs_type'], 'position_weather')
|
||||
self.assertEqual(message['rainfall_1h'], 123 / 100 * INCH_TO_MM)
|
||||
self.assertEqual(message['rainfall_24h'], 234 / 100 * INCH_TO_MM)
|
||||
assert message['aprs_type'] == 'position_weather'
|
||||
assert message['rainfall_1h'] == 123 / 100 * INCH_TO_MM
|
||||
assert message['rainfall_24h'] == 234 / 100 * INCH_TO_MM
|
||||
|
||||
def test_v028_fanet_position_weather_empty(self):
|
||||
raw_message = 'FNT010115>OGNFNT,qAS,DB7MJ:/065738h4727.72N/01012.83E_.../...g...t... 27.8dB -13.8kHz'
|
||||
message = parse_aprs(raw_message)
|
||||
|
||||
self.assertEqual(message['aprs_type'], 'position_weather')
|
||||
self.assertIsNone(message['wind_direction'])
|
||||
self.assertIsNone(message['wind_speed'])
|
||||
self.assertIsNone(message['wind_speed_peak'])
|
||||
self.assertIsNone(message['temperature'])
|
||||
self.assertIsNone(message['humidity'])
|
||||
self.assertIsNone(message['barometric_pressure'])
|
||||
assert message['aprs_type'] == 'position_weather'
|
||||
assert message['wind_direction'] is None
|
||||
assert message['wind_speed'] is None
|
||||
assert message['wind_speed_peak'] is None
|
||||
assert message['temperature'] is None
|
||||
assert message['humidity'] is None
|
||||
assert message['barometric_pressure'] is None
|
||||
|
||||
def test_negative_altitude(self):
|
||||
# some devices can report negative altitudes
|
||||
|
|
@ -120,7 +120,7 @@ class TestStringMethods(unittest.TestCase):
|
|||
raw_message = "FLRDDEEF1>OGCAPT,qAS,CAPTURS:/065511h4837.63N/00233.79E'000/000"
|
||||
message = parse_aprs(raw_message)
|
||||
|
||||
self.assertEqual(message['altitude'], None)
|
||||
assert message['altitude'] is None
|
||||
|
||||
def test_invalid_coordinates(self):
|
||||
# sometimes the coordinates leave their valid range: -90<=latitude<=90 or -180<=longitude<=180
|
||||
|
|
@ -145,19 +145,19 @@ class TestStringMethods(unittest.TestCase):
|
|||
raw_message = "# bad configured ogn receiver"
|
||||
message = parse_aprs(raw_message)
|
||||
|
||||
self.assertEqual(message['comment'], raw_message)
|
||||
self.assertEqual(message['aprs_type'], 'comment')
|
||||
assert message['comment'] == raw_message
|
||||
assert message['aprs_type'] == 'comment'
|
||||
|
||||
def test_server_comment(self):
|
||||
raw_message = "# aprsc 2.1.4-g408ed49 17 Mar 2018 09:30:36 GMT GLIDERN1 37.187.40.234:10152"
|
||||
message = parse_aprs(raw_message)
|
||||
|
||||
self.assertEqual(message['version'], '2.1.4-g408ed49')
|
||||
self.assertEqual(message['timestamp'], datetime(2018, 3, 17, 9, 30, 36))
|
||||
self.assertEqual(message['server'], 'GLIDERN1')
|
||||
self.assertEqual(message['ip_address'], '37.187.40.234')
|
||||
self.assertEqual(message['port'], '10152')
|
||||
self.assertEqual(message['aprs_type'], 'server')
|
||||
assert message['version'] == '2.1.4-g408ed49'
|
||||
assert message['timestamp'] == datetime(2018, 3, 17, 9, 30, 36)
|
||||
assert message['server'] == 'GLIDERN1'
|
||||
assert message['ip_address'] == '37.187.40.234'
|
||||
assert message['port'] == '10152'
|
||||
assert message['aprs_type'] == 'server'
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -8,24 +8,24 @@ class TestStringMethods(unittest.TestCase):
|
|||
def test_position_comment(self):
|
||||
message = FanetParser().parse_position("id1E1103CE -02fpm")
|
||||
|
||||
self.assertEqual(message['address_type'], 2)
|
||||
self.assertEqual(message['aircraft_type'], 7)
|
||||
assert message['address_type'] == 2
|
||||
assert message['aircraft_type'] == 7
|
||||
self.assertFalse(message['stealth'])
|
||||
self.assertEqual(message['address'], "1103CE")
|
||||
assert message['address'] == "1103CE"
|
||||
self.assertAlmostEqual(message['climb_rate'], -2 * FPM_TO_MS, 0.1)
|
||||
|
||||
def test_pseudo_status_comment(self):
|
||||
message = FanetParser().parse_position("")
|
||||
|
||||
self.assertEqual(message, {})
|
||||
assert message == {}
|
||||
|
||||
def test_v028_status(self):
|
||||
message = FanetParser().parse_status('Name="Juerg Zweifel" 15.0dB -17.1kHz 1e')
|
||||
|
||||
self.assertEqual(message['fanet_name'], "Juerg Zweifel")
|
||||
self.assertEqual(message['signal_quality'], 15.0)
|
||||
self.assertEqual(message['frequency_offset'], -17.1)
|
||||
self.assertEqual(message['error_count'], 1)
|
||||
assert message['fanet_name'] == "Juerg Zweifel"
|
||||
assert message['signal_quality'] == 15.0
|
||||
assert message['frequency_offset'] == -17.1
|
||||
assert message['error_count'] == 1
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -8,27 +8,27 @@ class TestStringMethods(unittest.TestCase):
|
|||
def test_position_comment(self):
|
||||
message = FlarmParser().parse_position("id21A8CBA8 -039fpm +0.1rot 3.5dB 2e -8.7kHz gps1x2 s6.09 h43 rDF0267")
|
||||
|
||||
self.assertEqual(message['address_type'], 1)
|
||||
self.assertEqual(message['aircraft_type'], 8)
|
||||
assert message['address_type'] == 1
|
||||
assert message['aircraft_type'] == 8
|
||||
self.assertFalse(message['stealth'])
|
||||
self.assertFalse(message['no-tracking'])
|
||||
self.assertEqual(message['address'], "A8CBA8")
|
||||
assert message['address'] == "A8CBA8"
|
||||
self.assertAlmostEqual(message['climb_rate'], -39 * FPM_TO_MS, 2)
|
||||
self.assertEqual(message['turn_rate'], 0.1 * HPM_TO_DEGS)
|
||||
self.assertEqual(message['signal_quality'], 3.5)
|
||||
self.assertEqual(message['error_count'], 2)
|
||||
self.assertEqual(message['frequency_offset'], -8.7)
|
||||
self.assertEqual(message['gps_quality'], {'horizontal': 1, 'vertical': 2})
|
||||
self.assertEqual(message['software_version'], 6.09)
|
||||
self.assertEqual(message['hardware_version'], 67)
|
||||
self.assertEqual(message['real_address'], "DF0267")
|
||||
assert message['turn_rate'] == 0.1 * HPM_TO_DEGS
|
||||
assert message['signal_quality'] == 3.5
|
||||
assert message['error_count'] == 2
|
||||
assert message['frequency_offset'] == -8.7
|
||||
assert message['gps_quality'] == {'horizontal': 1, 'vertical': 2}
|
||||
assert message['software_version'] == 6.09
|
||||
assert message['hardware_version'] == 67
|
||||
assert message['real_address'] == "DF0267"
|
||||
|
||||
def test_position_comment_relevant_keys_only(self):
|
||||
# return only keys where we got informations
|
||||
message = FlarmParser().parse_position("id21A8CBA8")
|
||||
|
||||
self.assertIsNotNone(message)
|
||||
self.assertEqual(sorted(message.keys()), sorted(['address_type', 'aircraft_type', 'stealth', 'address', 'no-tracking']))
|
||||
assert sorted(message.keys()) == sorted(['address_type', 'aircraft_type', 'stealth', 'address', 'no-tracking'])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -6,10 +6,10 @@ from ogn.parser.aprs_comment.generic_parser import GenericParser
|
|||
class TestStringMethods(unittest.TestCase):
|
||||
def test_position_comment(self):
|
||||
message = GenericParser().parse_position("id0123456789 weather is good, climbing with 123fpm")
|
||||
self.assertTrue('comment' in message)
|
||||
assert 'comment' in message
|
||||
|
||||
message = GenericParser().parse_status("id0123456789 weather is good, climbing with 123fpm")
|
||||
self.assertTrue('comment' in message)
|
||||
assert 'comment' in message
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -5,16 +5,16 @@ from ogn.parser.aprs_comment.inreach_parser import InreachParser
|
|||
class TestStringMethods(unittest.TestCase):
|
||||
def test_position_comment(self):
|
||||
message = InreachParser().parse_position("id300434060496190 inReac True")
|
||||
self.assertEqual(message['address'], "300434060496190")
|
||||
self.assertEqual(message['model'], 'inReac')
|
||||
self.assertEqual(message['status'], True)
|
||||
self.assertEqual(message['pilot_name'], None)
|
||||
assert message['address'] == "300434060496190"
|
||||
assert message['model'] == 'inReac'
|
||||
assert message['status'] is True
|
||||
assert message['pilot_name'] is None
|
||||
|
||||
message = InreachParser().parse_position("id300434060496190 inReac True Jim Bob")
|
||||
self.assertEqual(message['address'], "300434060496190")
|
||||
self.assertEqual(message['model'], 'inReac')
|
||||
self.assertEqual(message['status'], True)
|
||||
self.assertEqual(message['pilot_name'], "Jim Bob")
|
||||
assert message['address'] == "300434060496190"
|
||||
assert message['model'] == 'inReac'
|
||||
assert message['status'] is True
|
||||
assert message['pilot_name'] == "Jim Bob"
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -8,9 +8,9 @@ class TestStringMethods(unittest.TestCase):
|
|||
def test_position_comment(self):
|
||||
message = LT24Parser().parse_position("id25387 +123fpm GPS")
|
||||
|
||||
self.assertEqual(message['lt24_id'], "25387")
|
||||
assert message['lt24_id'] == "25387"
|
||||
self.assertAlmostEqual(message['climb_rate'], 123 * FPM_TO_MS, 2)
|
||||
self.assertEqual(message['source'], 'GPS')
|
||||
assert message['source'] == 'GPS'
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -7,18 +7,18 @@ class TestStringMethods(unittest.TestCase):
|
|||
def test_position_comment(self):
|
||||
message = MicrotrakParser().parse_position("id21A8CBA8")
|
||||
|
||||
self.assertEqual(message['address_type'], 1)
|
||||
self.assertEqual(message['aircraft_type'], 8)
|
||||
assert message['address_type'] == 1
|
||||
assert message['aircraft_type'] == 8
|
||||
self.assertFalse(message['stealth'])
|
||||
self.assertFalse(message['no-tracking'])
|
||||
self.assertEqual(message['address'], "A8CBA8")
|
||||
assert message['address'] == "A8CBA8"
|
||||
|
||||
def test_position_comment_relevant_keys_only(self):
|
||||
# return only keys where we got informations
|
||||
message = MicrotrakParser().parse_position("id21A8CBA8")
|
||||
|
||||
self.assertIsNotNone(message)
|
||||
self.assertEqual(sorted(message.keys()), sorted(['address_type', 'aircraft_type', 'stealth', 'address', 'no-tracking']))
|
||||
assert sorted(message.keys()) == sorted(['address_type', 'aircraft_type', 'stealth', 'address', 'no-tracking'])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -15,15 +15,15 @@ class TestStringMethods(unittest.TestCase):
|
|||
# bits 6-11: address type (namespace is extended from 2 to 6 bits to avoid collisions with other tracking providers)
|
||||
# bits 12-15: reserved for use at a later time
|
||||
# bits 16-39: device id (24-bit device identifier, same as in APRS header)
|
||||
self.assertEqual(message['stealth'], False)
|
||||
self.assertEqual(message['do_not_track'], False)
|
||||
self.assertEqual(message['aircraft_type'], 1)
|
||||
self.assertEqual(message['address_type'], 4)
|
||||
self.assertEqual(message['reserved'], 0)
|
||||
self.assertEqual(message['address'], "042121")
|
||||
assert message['stealth'] is False
|
||||
assert message['do_not_track'] is False
|
||||
assert message['aircraft_type'] == 1
|
||||
assert message['address_type'] == 4
|
||||
assert message['reserved'] == 0
|
||||
assert message['address'] == "042121"
|
||||
|
||||
self.assertAlmostEqual(message['climb_rate'], 123 * FPM_TO_MS, 2)
|
||||
self.assertEqual(message['turn_rate'], 0.5 * HPM_TO_DEGS)
|
||||
assert message['turn_rate'] == 0.5 * HPM_TO_DEGS
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -6,57 +6,57 @@ from ogn.parser.aprs_comment.ogn_parser import OgnParser
|
|||
|
||||
class TestStringMethods(unittest.TestCase):
|
||||
def test_invalid_token(self):
|
||||
self.assertEqual(OgnParser().parse_aircraft_beacon("notAValidToken"), None)
|
||||
assert OgnParser().parse_aircraft_beacon("notAValidToken") is None
|
||||
|
||||
def test_basic(self):
|
||||
message = OgnParser().parse_aircraft_beacon("id0ADDA5BA -454fpm -1.1rot 8.8dB 0e +51.2kHz gps4x5 hear1084 hearB597 hearB598")
|
||||
|
||||
self.assertEqual(message['address_type'], 2)
|
||||
self.assertEqual(message['aircraft_type'], 2)
|
||||
assert message['address_type'] == 2
|
||||
assert message['aircraft_type'] == 2
|
||||
self.assertFalse(message['stealth'])
|
||||
self.assertFalse(message['no-tracking'])
|
||||
self.assertEqual(message['address'], "DDA5BA")
|
||||
assert message['address'] == "DDA5BA"
|
||||
self.assertAlmostEqual(message['climb_rate'], -454 * FPM_TO_MS, 2)
|
||||
self.assertEqual(message['turn_rate'], -1.1 * HPM_TO_DEGS)
|
||||
self.assertEqual(message['signal_quality'], 8.8)
|
||||
self.assertEqual(message['error_count'], 0)
|
||||
self.assertEqual(message['frequency_offset'], 51.2)
|
||||
self.assertEqual(message['gps_quality'], {'horizontal': 4, 'vertical': 5})
|
||||
self.assertEqual(len(message['proximity']), 3)
|
||||
self.assertEqual(message['proximity'][0], '1084')
|
||||
self.assertEqual(message['proximity'][1], 'B597')
|
||||
self.assertEqual(message['proximity'][2], 'B598')
|
||||
assert message['turn_rate'] == -1.1 * HPM_TO_DEGS
|
||||
assert message['signal_quality'] == 8.8
|
||||
assert message['error_count'] == 0
|
||||
assert message['frequency_offset'] == 51.2
|
||||
assert message['gps_quality'] == {'horizontal': 4, 'vertical': 5}
|
||||
assert len(message['proximity']) == 3
|
||||
assert message['proximity'][0] == '1084'
|
||||
assert message['proximity'][1] == 'B597'
|
||||
assert message['proximity'][2] == 'B598'
|
||||
|
||||
def test_no_tracking(self):
|
||||
message = OgnParser().parse_aircraft_beacon("id0ADD1234 -454fpm -1.1rot 8.8dB 0e +51.2kHz gps4x5 hear1084 hearB597 hearB598")
|
||||
self.assertFalse(message['no-tracking'])
|
||||
|
||||
message = OgnParser().parse_aircraft_beacon("id4ADD1234 -454fpm -1.1rot 8.8dB 0e +51.2kHz gps4x5 hear1084 hearB597 hearB598")
|
||||
self.assertTrue(message['no-tracking'])
|
||||
assert message['no-tracking'] is True
|
||||
|
||||
def test_stealth(self):
|
||||
message = OgnParser().parse_aircraft_beacon("id0ADD1234 -454fpm -1.1rot 8.8dB 0e +51.2kHz gps4x5 hear1084 hearB597 hearB598")
|
||||
self.assertFalse(message['stealth'])
|
||||
assert message['stealth'] is False
|
||||
|
||||
message = OgnParser().parse_aircraft_beacon("id8ADD1234 -454fpm -1.1rot 8.8dB 0e +51.2kHz gps4x5 hear1084 hearB597 hearB598")
|
||||
self.assertTrue(message['stealth'])
|
||||
assert message['stealth'] is True
|
||||
|
||||
def test_v024(self):
|
||||
message = OgnParser().parse_aircraft_beacon("id21400EA9 -2454fpm +0.9rot 19.5dB 0e -6.6kHz gps1x1 s6.02 h0A rDF0C56")
|
||||
|
||||
self.assertEqual(message['software_version'], 6.02)
|
||||
self.assertEqual(message['hardware_version'], 10)
|
||||
self.assertEqual(message['real_address'], "DF0C56")
|
||||
assert message['software_version'] == 6.02
|
||||
assert message['hardware_version'] == 10
|
||||
assert message['real_address'] == "DF0C56"
|
||||
|
||||
def test_v024_ogn_tracker(self):
|
||||
message = OgnParser().parse_aircraft_beacon("id07353800 +020fpm -14.0rot FL004.43 38.5dB 0e -2.9kHz")
|
||||
|
||||
self.assertEqual(message['flightlevel'], 4.43)
|
||||
assert message['flightlevel'] == 4.43
|
||||
|
||||
def test_v025(self):
|
||||
message = OgnParser().parse_aircraft_beacon("id06DDE28D +535fpm +3.8rot 11.5dB 0e -1.0kHz gps2x3 s6.01 h0C +7.4dBm")
|
||||
|
||||
self.assertEqual(message['signal_power'], 7.4)
|
||||
assert message['signal_power'] == 7.4
|
||||
|
||||
def test_v026(self):
|
||||
# from 0.2.6 it is sufficent we have only the ID, climb and turn rate or just the ID
|
||||
|
|
@ -71,7 +71,7 @@ class TestStringMethods(unittest.TestCase):
|
|||
message = OgnParser().parse_aircraft_beacon("id093D0930")
|
||||
|
||||
self.assertIsNotNone(message)
|
||||
self.assertEqual(sorted(message.keys()), sorted(['address_type', 'aircraft_type', 'stealth', 'address', 'no-tracking']))
|
||||
assert sorted(message.keys()) == sorted(['address_type', 'aircraft_type', 'stealth', 'address', 'no-tracking'])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -5,53 +5,53 @@ from ogn.parser.aprs_comment.ogn_parser import OgnParser
|
|||
|
||||
class TestStringMethods(unittest.TestCase):
|
||||
def test_fail_validation(self):
|
||||
self.assertEqual(OgnParser().parse_receiver_beacon("notAValidToken"), None)
|
||||
assert OgnParser().parse_receiver_beacon("notAValidToken") is None
|
||||
|
||||
def test_v021(self):
|
||||
message = OgnParser().parse_receiver_beacon("v0.2.1 CPU:0.8 RAM:25.6/458.9MB NTP:0.1ms/+2.3ppm +51.9C RF:+26-1.4ppm/-0.25dB")
|
||||
|
||||
self.assertEqual(message['version'], "0.2.1")
|
||||
self.assertEqual(message['cpu_load'], 0.8)
|
||||
self.assertEqual(message['free_ram'], 25.6)
|
||||
self.assertEqual(message['total_ram'], 458.9)
|
||||
self.assertEqual(message['ntp_error'], 0.1)
|
||||
self.assertEqual(message['rt_crystal_correction'], 2.3)
|
||||
self.assertEqual(message['cpu_temp'], 51.9)
|
||||
assert message['version'] == "0.2.1"
|
||||
assert message['cpu_load'] == 0.8
|
||||
assert message['free_ram'] == 25.6
|
||||
assert message['total_ram'] == 458.9
|
||||
assert message['ntp_error'] == 0.1
|
||||
assert message['rt_crystal_correction'] == 2.3
|
||||
assert message['cpu_temp'] == 51.9
|
||||
|
||||
self.assertEqual(message['rec_crystal_correction'], 26)
|
||||
self.assertEqual(message['rec_crystal_correction_fine'], -1.4)
|
||||
self.assertEqual(message['rec_input_noise'], -0.25)
|
||||
assert message['rec_crystal_correction'] == 26
|
||||
assert message['rec_crystal_correction_fine'] == -1.4
|
||||
assert message['rec_input_noise'] == -0.25
|
||||
|
||||
def test_v022(self):
|
||||
message = OgnParser().parse_receiver_beacon("v0.2.2.x86 CPU:0.5 RAM:669.9/887.7MB NTP:1.0ms/+6.2ppm +52.0C RF:+0.06dB")
|
||||
self.assertEqual(message['platform'], 'x86')
|
||||
assert message['platform'] == 'x86'
|
||||
|
||||
def test_v025(self):
|
||||
message = OgnParser().parse_receiver_beacon("v0.2.5.RPI-GPU CPU:0.8 RAM:287.3/458.7MB NTP:1.0ms/-6.4ppm 5.016V 0.534A +51.9C RF:+55+0.4ppm/-0.67dB/+10.8dB@10km[57282]")
|
||||
self.assertEqual(message['voltage'], 5.016)
|
||||
self.assertEqual(message['amperage'], 0.534)
|
||||
self.assertEqual(message['senders_signal'], 10.8)
|
||||
self.assertEqual(message['senders_messages'], 57282)
|
||||
assert message['voltage'] == 5.016
|
||||
assert message['amperage'] == 0.534
|
||||
assert message['senders_signal'] == 10.8
|
||||
assert message['senders_messages'] == 57282
|
||||
|
||||
message = OgnParser().parse_receiver_beacon("v0.2.5.ARM CPU:0.4 RAM:638.0/970.5MB NTP:0.2ms/-1.1ppm +65.5C 14/16Acfts[1h] RF:+45+0.0ppm/+3.88dB/+24.0dB@10km[143717]/+26.7dB@10km[68/135]")
|
||||
self.assertEqual(message['senders_visible'], 14)
|
||||
self.assertEqual(message['senders_total'], 16)
|
||||
self.assertEqual(message['senders_signal'], 24.0)
|
||||
self.assertEqual(message['senders_messages'], 143717)
|
||||
self.assertEqual(message['good_senders_signal'], 26.7)
|
||||
self.assertEqual(message['good_senders'], 68)
|
||||
self.assertEqual(message['good_and_bad_senders'], 135)
|
||||
assert message['senders_visible'] == 14
|
||||
assert message['senders_total'] == 16
|
||||
assert message['senders_signal'] == 24.0
|
||||
assert message['senders_messages'] == 143717
|
||||
assert message['good_senders_signal'] == 26.7
|
||||
assert message['good_senders'] == 68
|
||||
assert message['good_and_bad_senders'] == 135
|
||||
|
||||
def test_v028(self):
|
||||
message = OgnParser().parse_receiver_beacon("v0.2.8.RPI-GPU CPU:0.3 RAM:744.5/968.2MB NTP:3.6ms/+2.0ppm +68.2C 3/3Acfts[1h] Lat:1.6s RF:-8+67.8ppm/+10.33dB/+1.3dB@10km[30998]/+10.4dB@10km[3/5]")
|
||||
self.assertEqual(message['latency'], 1.6)
|
||||
assert message['latency'] == 1.6
|
||||
|
||||
def test_relevant_keys_only(self):
|
||||
# return only keys where we got informations
|
||||
message = OgnParser().parse_receiver_beacon("v0.2.5.ARM CPU:0.4 RAM:638.0/970.5MB NTP:0.2ms/-1.1ppm")
|
||||
|
||||
self.assertIsNotNone(message)
|
||||
self.assertEqual(sorted(message.keys()), sorted(['version', 'platform', 'cpu_load', 'free_ram', 'total_ram', 'ntp_error', 'rt_crystal_correction']))
|
||||
assert sorted(message.keys()) == sorted(['version', 'platform', 'cpu_load', 'free_ram', 'total_ram', 'ntp_error', 'rt_crystal_correction'])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ class TestStringMethods(unittest.TestCase):
|
|||
def test_position_comment(self):
|
||||
message = ReceiverParser().parse_position("Antenna: chinese, on a pylon, 20 meter above ground")
|
||||
|
||||
self.assertEqual(message['user_comment'], "Antenna: chinese, on a pylon, 20 meter above ground")
|
||||
assert message['user_comment'] == "Antenna: chinese, on a pylon, 20 meter above ground"
|
||||
|
||||
def test_position_comment_empty(self):
|
||||
message = ReceiverParser().parse_position("")
|
||||
|
|
@ -17,24 +17,24 @@ class TestStringMethods(unittest.TestCase):
|
|||
def test_status_comment(self):
|
||||
message = ReceiverParser().parse_status("v0.2.7.RPI-GPU CPU:0.7 RAM:770.2/968.2MB NTP:1.8ms/-3.3ppm +55.7C 7/8Acfts[1h] RF:+54-1.1ppm/-0.16dB/+7.1dB@10km[19481]/+16.8dB@10km[7/13]")
|
||||
|
||||
self.assertEqual(message['version'], "0.2.7")
|
||||
self.assertEqual(message['platform'], 'RPI-GPU')
|
||||
self.assertEqual(message['cpu_load'], 0.7)
|
||||
self.assertEqual(message['free_ram'], 770.2)
|
||||
self.assertEqual(message['total_ram'], 968.2)
|
||||
self.assertEqual(message['ntp_error'], 1.8)
|
||||
self.assertEqual(message['rt_crystal_correction'], -3.3)
|
||||
self.assertEqual(message['cpu_temp'], 55.7)
|
||||
self.assertEqual(message['senders_visible'], 7)
|
||||
self.assertEqual(message['senders_total'], 8)
|
||||
self.assertEqual(message['rec_crystal_correction'], 54)
|
||||
self.assertEqual(message['rec_crystal_correction_fine'], -1.1)
|
||||
self.assertEqual(message['rec_input_noise'], -0.16)
|
||||
self.assertEqual(message['senders_signal'], 7.1)
|
||||
self.assertEqual(message['senders_messages'], 19481)
|
||||
self.assertEqual(message['good_senders_signal'], 16.8)
|
||||
self.assertEqual(message['good_senders'], 7)
|
||||
self.assertEqual(message['good_and_bad_senders'], 13)
|
||||
assert message['version'] == "0.2.7"
|
||||
assert message['platform'] == 'RPI-GPU'
|
||||
assert message['cpu_load'] == 0.7
|
||||
assert message['free_ram'] == 770.2
|
||||
assert message['total_ram'] == 968.2
|
||||
assert message['ntp_error'] == 1.8
|
||||
assert message['rt_crystal_correction'] == -3.3
|
||||
assert message['cpu_temp'] == 55.7
|
||||
assert message['senders_visible'] == 7
|
||||
assert message['senders_total'] == 8
|
||||
assert message['rec_crystal_correction'] == 54
|
||||
assert message['rec_crystal_correction_fine'] == -1.1
|
||||
assert message['rec_input_noise'] == -0.16
|
||||
assert message['senders_signal'] == 7.1
|
||||
assert message['senders_messages'] == 19481
|
||||
assert message['good_senders_signal'] == 16.8
|
||||
assert message['good_senders'] == 7
|
||||
assert message['good_and_bad_senders'] == 13
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -8,12 +8,12 @@ class TestStringMethods(unittest.TestCase):
|
|||
def test_position_comment(self):
|
||||
# "SKY3E5906>OGNSKY,qAS,SafeSky:/072555h5103.47N/00524.81E'065/031/A=001250 !W05! id1C3E5906 +010fpm gps6x1"
|
||||
message = SafeskyParser().parse_position("id1C3E5906 +010fpm gps6x1")
|
||||
self.assertEqual(message['address'], '3E5906')
|
||||
self.assertEqual(message['address_type'], 0)
|
||||
self.assertEqual(message['aircraft_type'], 7)
|
||||
assert message['address'] == '3E5906'
|
||||
assert message['address_type'] == 0
|
||||
assert message['aircraft_type'] == 7
|
||||
self.assertFalse(message['stealth'])
|
||||
self.assertAlmostEqual(message['climb_rate'], 10 * FPM_TO_MS, 2)
|
||||
self.assertEqual(message['gps_quality'], {'horizontal': 6, 'vertical': 1})
|
||||
assert message['gps_quality'] == {'horizontal': 6, 'vertical': 1}
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ class TestStringMethods(unittest.TestCase):
|
|||
def test_position_comment(self):
|
||||
message = SkylinesParser().parse_position("id2816 -015fpm")
|
||||
|
||||
self.assertEqual(message['skylines_id'], "2816")
|
||||
assert message['skylines_id'] == "2816"
|
||||
self.assertAlmostEqual(message['climb_rate'], -15 * FPM_TO_MS, 2)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -7,10 +7,10 @@ class TestStringMethods(unittest.TestCase):
|
|||
def test_position_comment(self):
|
||||
message = SpiderParser().parse_position("id300234060668560 +30dB K23W 3D")
|
||||
|
||||
self.assertEqual(message['spider_id'], "300234060668560")
|
||||
self.assertEqual(message['signal_power'], 30)
|
||||
self.assertEqual(message['spider_registration'], "K23W")
|
||||
self.assertEqual(message['gps_quality'], "3D")
|
||||
assert message['spider_id'] == "300234060668560"
|
||||
assert message['signal_power'] == 30
|
||||
assert message['spider_registration'] == "K23W"
|
||||
assert message['gps_quality'] == "3D"
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -7,9 +7,9 @@ class TestStringMethods(unittest.TestCase):
|
|||
def test_position_comment(self):
|
||||
message = SpotParser().parse_position("id0-2860357 SPOT3 GOOD")
|
||||
|
||||
self.assertEqual(message['spot_id'], "0-2860357")
|
||||
self.assertEqual(message['model'], 'SPOT3')
|
||||
self.assertEqual(message['status'], "GOOD")
|
||||
assert message['spot_id'] == "0-2860357"
|
||||
assert message['model'] == 'SPOT3'
|
||||
assert message['status'] == "GOOD"
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -20,33 +20,33 @@ class TestStringMethods(unittest.TestCase):
|
|||
|
||||
message = parse('0.181sec:868.394MHz: 1:2:DDA411 103010: [ +50.86800, +12.15279]deg 988m +0.1m/s 25.7m/s 085.4deg -3.5deg/sec 5 03x04m 01f_-12.61kHz 5.8/15.5dB/2 10e 30.9km 099.5deg +1.1deg + ? R B8949')
|
||||
|
||||
self.assertEqual(message['pps_offset'], 0.181)
|
||||
self.assertEqual(message['frequency'], 868.394)
|
||||
self.assertEqual(message['aircraft_type'], 1)
|
||||
self.assertEqual(message['address_type'], 2)
|
||||
self.assertEqual(message['address'], 'DDA411')
|
||||
self.assertEqual(message['timestamp'], datetime(2015, 1, 1, 10, 30, 10))
|
||||
self.assertEqual(message['latitude'], 50.868)
|
||||
self.assertEqual(message['longitude'], 12.15279)
|
||||
self.assertEqual(message['altitude'], 988)
|
||||
self.assertEqual(message['climb_rate'], 0.1)
|
||||
self.assertEqual(message['ground_speed'], 25.7)
|
||||
self.assertEqual(message['track'], 85.4)
|
||||
self.assertEqual(message['turn_rate'], -3.5)
|
||||
self.assertEqual(message['magic_number'], 5) # the '5' is a magic number... 1 if ground_speed is 0.0m/s an 3 or 5 if airborne. Do you have an idea what it is?
|
||||
self.assertEqual(message['gps_status'], '03x04')
|
||||
self.assertEqual(message['channel'], 1)
|
||||
self.assertEqual(message['flarm_timeslot'], True)
|
||||
self.assertEqual(message['ogn_timeslot'], False)
|
||||
self.assertEqual(message['frequency_offset'], -12.61)
|
||||
self.assertEqual(message['decode_quality'], 5.8)
|
||||
self.assertEqual(message['signal_quality'], 15.5)
|
||||
self.assertEqual(message['demodulator_type'], 2)
|
||||
self.assertEqual(message['error_count'], 10)
|
||||
self.assertEqual(message['distance'], 30.9)
|
||||
self.assertEqual(message['bearing'], 99.5)
|
||||
self.assertEqual(message['phi'], 1.1)
|
||||
self.assertEqual(message['multichannel'], True)
|
||||
assert message['pps_offset'] == 0.181
|
||||
assert message['frequency'] == 868.394
|
||||
assert message['aircraft_type'] == 1
|
||||
assert message['address_type'] == 2
|
||||
assert message['address'] == 'DDA411'
|
||||
assert message['timestamp'] == datetime(2015, 1, 1, 10, 30, 10)
|
||||
assert message['latitude'] == 50.868
|
||||
assert message['longitude'] == 12.15279
|
||||
assert message['altitude'] == 988
|
||||
assert message['climb_rate'] == 0.1
|
||||
assert message['ground_speed'] == 25.7
|
||||
assert message['track'] == 85.4
|
||||
assert message['turn_rate'] == -3.5
|
||||
assert message['magic_number'] == 5 # the '5' is a magic number... 1 if ground_speed is 0.0m/s an 3 or 5 if airborne. Do you have an idea what it is?
|
||||
assert message['gps_status'] == '03x04'
|
||||
assert message['channel'] == 1
|
||||
assert message['flarm_timeslot'] is True
|
||||
assert message['ogn_timeslot'] is False
|
||||
assert message['frequency_offset'] == -12.61
|
||||
assert message['decode_quality'] == 5.8
|
||||
assert message['signal_quality'] == 15.5
|
||||
assert message['demodulator_type'] == 2
|
||||
assert message['error_count'] == 10
|
||||
assert message['distance'] == 30.9
|
||||
assert message['bearing'] == 99.5
|
||||
assert message['phi'] == 1.1
|
||||
assert message['multichannel'] is True
|
||||
|
||||
def test_telnet_parse_corrupt(self):
|
||||
message = parse('0.397sec:868.407MHz: sA:1:784024 205656: [ +5.71003, +20.48951]deg 34012m +14.5m/s 109.7m/s 118.5deg +21.0deg/sec 0 27x40m 01_o +7.03kHz 17.2/27.0dB/2 12e 4719.5km 271.1deg -8.5deg ? R B34067')
|
||||
|
|
|
|||
|
|
@ -8,39 +8,39 @@ class TestStringMethods(unittest.TestCase):
|
|||
def test_position_comment(self):
|
||||
message = TrackerParser().parse_position("id072FD00F -058fpm +1.1rot FL003.12 32.8dB 0e -0.8kHz gps3x5 +12.7dBm")
|
||||
|
||||
self.assertEqual(message['address_type'], 3)
|
||||
self.assertEqual(message['aircraft_type'], 1)
|
||||
assert message['address_type'] == 3
|
||||
assert message['aircraft_type'] == 1
|
||||
self.assertFalse(message['stealth'])
|
||||
self.assertEqual(message['address'], "2FD00F")
|
||||
assert message['address'] == "2FD00F"
|
||||
self.assertAlmostEqual(message['climb_rate'], -58 * FPM_TO_MS, 2)
|
||||
self.assertEqual(message['turn_rate'], 1.1 * HPM_TO_DEGS)
|
||||
self.assertEqual(message['flightlevel'], 3.12)
|
||||
self.assertEqual(message['signal_quality'], 32.8)
|
||||
self.assertEqual(message['error_count'], 0)
|
||||
self.assertEqual(message['frequency_offset'], -0.8)
|
||||
self.assertEqual(message['gps_quality'], {'horizontal': 3, 'vertical': 5})
|
||||
self.assertEqual(message['signal_power'], 12.7)
|
||||
assert message['turn_rate'] == 1.1 * HPM_TO_DEGS
|
||||
assert message['flightlevel'] == 3.12
|
||||
assert message['signal_quality'] == 32.8
|
||||
assert message['error_count'] == 0
|
||||
assert message['frequency_offset'] == -0.8
|
||||
assert message['gps_quality'] == {'horizontal': 3, 'vertical': 5}
|
||||
assert message['signal_power'] == 12.7
|
||||
|
||||
def test_status_comment(self):
|
||||
message = TrackerParser().parse_status("h00 v00 9sat/1 164m 1002.6hPa +20.2degC 0% 3.34V 14/-110.5dBm 1/min")
|
||||
|
||||
self.assertEqual(message['hardware_version'], 0)
|
||||
self.assertEqual(message['software_version'], 0)
|
||||
self.assertEqual(message['gps_satellites'], 9)
|
||||
self.assertEqual(message['gps_quality'], 1)
|
||||
self.assertEqual(message['gps_altitude'], 164)
|
||||
self.assertEqual(message['pressure'], 1002.6)
|
||||
self.assertEqual(message['temperature'], 20.2)
|
||||
self.assertEqual(message['humidity'], 0)
|
||||
self.assertEqual(message['voltage'], 3.34)
|
||||
self.assertEqual(message['transmitter_power'], 14)
|
||||
self.assertEqual(message['noise_level'], -110.5)
|
||||
self.assertEqual(message['relays'], 1)
|
||||
assert message['hardware_version'] == 0
|
||||
assert message['software_version'] == 0
|
||||
assert message['gps_satellites'] == 9
|
||||
assert message['gps_quality'] == 1
|
||||
assert message['gps_altitude'] == 164
|
||||
assert message['pressure'] == 1002.6
|
||||
assert message['temperature'] == 20.2
|
||||
assert message['humidity'] == 0
|
||||
assert message['voltage'] == 3.34
|
||||
assert message['transmitter_power'] == 14
|
||||
assert message['noise_level'] == -110.5
|
||||
assert message['relays'] == 1
|
||||
|
||||
def test_status_comment_comment(self):
|
||||
message = TrackerParser().parse_status("Pilot=Pawel Hard=DIY/STM32")
|
||||
|
||||
self.assertEqual(message['comment'], "Pilot=Pawel Hard=DIY/STM32")
|
||||
assert message['comment'] == "Pilot=Pawel Hard=DIY/STM32"
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ class TestStringMethods(unittest.TestCase):
|
|||
def proceed_test_data(self, test_data={}):
|
||||
for test in test_data:
|
||||
timestamp = createTimestamp(test[0], reference_timestamp=test[1])
|
||||
self.assertEqual(timestamp, test[2])
|
||||
assert timestamp == test[2]
|
||||
|
||||
def test_createTimestamp_hhmmss(self):
|
||||
test_data = [
|
||||
|
|
|
|||
Ładowanie…
Reference in New Issue