mirror of
https://github.com/craigerl/aprsd.git
synced 2026-06-05 15:44:40 -04:00
Added unit tests for packets.
Also did some code cleanup.
This commit is contained in:
@@ -0,0 +1,76 @@
|
||||
import json
|
||||
import unittest
|
||||
|
||||
import aprslib
|
||||
|
||||
from aprsd import packets
|
||||
from tests import fake
|
||||
|
||||
|
||||
class TestAckPacket(unittest.TestCase):
|
||||
"""Test AckPacket JSON serialization."""
|
||||
|
||||
def test_ack_packet_to_json(self):
|
||||
"""Test AckPacket.to_json() method."""
|
||||
packet = packets.AckPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
msgNo='123',
|
||||
)
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'AckPacket')
|
||||
self.assertEqual(json_dict['from_call'], fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(json_dict['to_call'], fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(json_dict['msgNo'], '123')
|
||||
|
||||
def test_ack_packet_from_dict(self):
|
||||
"""Test AckPacket.from_dict() method."""
|
||||
packet_dict = {
|
||||
'_type': 'AckPacket',
|
||||
'from_call': fake.FAKE_FROM_CALLSIGN,
|
||||
'to_call': fake.FAKE_TO_CALLSIGN,
|
||||
'msgNo': '123',
|
||||
}
|
||||
packet = packets.AckPacket.from_dict(packet_dict)
|
||||
self.assertIsInstance(packet, packets.AckPacket)
|
||||
self.assertEqual(packet.from_call, fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(packet.to_call, fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(packet.msgNo, '123')
|
||||
|
||||
def test_ack_packet_round_trip(self):
|
||||
"""Test AckPacket round-trip: to_json -> from_dict."""
|
||||
original = packets.AckPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
msgNo='123',
|
||||
)
|
||||
json_str = original.to_json()
|
||||
packet_dict = json.loads(json_str)
|
||||
restored = packets.AckPacket.from_dict(packet_dict)
|
||||
self.assertEqual(restored.from_call, original.from_call)
|
||||
self.assertEqual(restored.to_call, original.to_call)
|
||||
self.assertEqual(restored.msgNo, original.msgNo)
|
||||
self.assertEqual(restored._type, original._type)
|
||||
|
||||
def test_ack_packet_from_raw_string(self):
|
||||
"""Test AckPacket creation from raw APRS string."""
|
||||
packet_raw = 'KFAKE>APZ100::KMINE :ack123'
|
||||
packet_dict = aprslib.parse(packet_raw)
|
||||
# aprslib might not set format/response correctly, so set them manually
|
||||
packet_dict['format'] = 'message'
|
||||
packet_dict['response'] = 'ack'
|
||||
packet = packets.factory(packet_dict)
|
||||
self.assertIsInstance(packet, packets.AckPacket)
|
||||
# Test to_json
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'AckPacket')
|
||||
# Test from_dict round trip
|
||||
restored = packets.factory(json_dict)
|
||||
self.assertIsInstance(restored, packets.AckPacket)
|
||||
self.assertEqual(restored.from_call, packet.from_call)
|
||||
self.assertEqual(restored.to_call, packet.to_call)
|
||||
self.assertEqual(restored.msgNo, packet.msgNo)
|
||||
@@ -0,0 +1,98 @@
|
||||
import json
|
||||
import unittest
|
||||
|
||||
import aprslib
|
||||
|
||||
from aprsd import packets
|
||||
from tests import fake
|
||||
|
||||
|
||||
class TestBeaconPacket(unittest.TestCase):
|
||||
"""Test BeaconPacket JSON serialization."""
|
||||
|
||||
def test_beacon_packet_to_json(self):
|
||||
"""Test BeaconPacket.to_json() method."""
|
||||
packet = packets.BeaconPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
latitude=37.7749,
|
||||
longitude=-122.4194,
|
||||
symbol='>',
|
||||
symbol_table='/',
|
||||
comment='Test beacon comment',
|
||||
)
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'BeaconPacket')
|
||||
self.assertEqual(json_dict['from_call'], fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(json_dict['to_call'], fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(json_dict['latitude'], 37.7749)
|
||||
self.assertEqual(json_dict['longitude'], -122.4194)
|
||||
self.assertEqual(json_dict['symbol'], '>')
|
||||
self.assertEqual(json_dict['symbol_table'], '/')
|
||||
self.assertEqual(json_dict['comment'], 'Test beacon comment')
|
||||
|
||||
def test_beacon_packet_from_dict(self):
|
||||
"""Test BeaconPacket.from_dict() method."""
|
||||
packet_dict = {
|
||||
'_type': 'BeaconPacket',
|
||||
'from_call': fake.FAKE_FROM_CALLSIGN,
|
||||
'to_call': fake.FAKE_TO_CALLSIGN,
|
||||
'latitude': 37.7749,
|
||||
'longitude': -122.4194,
|
||||
'symbol': '>',
|
||||
'symbol_table': '/',
|
||||
'comment': 'Test beacon comment',
|
||||
}
|
||||
packet = packets.BeaconPacket.from_dict(packet_dict)
|
||||
self.assertIsInstance(packet, packets.BeaconPacket)
|
||||
self.assertEqual(packet.from_call, fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(packet.to_call, fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(packet.latitude, 37.7749)
|
||||
self.assertEqual(packet.longitude, -122.4194)
|
||||
self.assertEqual(packet.symbol, '>')
|
||||
self.assertEqual(packet.symbol_table, '/')
|
||||
self.assertEqual(packet.comment, 'Test beacon comment')
|
||||
|
||||
def test_beacon_packet_round_trip(self):
|
||||
"""Test BeaconPacket round-trip: to_json -> from_dict."""
|
||||
original = packets.BeaconPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
latitude=37.7749,
|
||||
longitude=-122.4194,
|
||||
symbol='>',
|
||||
symbol_table='/',
|
||||
comment='Test beacon comment',
|
||||
)
|
||||
json_str = original.to_json()
|
||||
packet_dict = json.loads(json_str)
|
||||
restored = packets.BeaconPacket.from_dict(packet_dict)
|
||||
self.assertEqual(restored.from_call, original.from_call)
|
||||
self.assertEqual(restored.to_call, original.to_call)
|
||||
self.assertEqual(restored.latitude, original.latitude)
|
||||
self.assertEqual(restored.longitude, original.longitude)
|
||||
self.assertEqual(restored.symbol, original.symbol)
|
||||
self.assertEqual(restored.symbol_table, original.symbol_table)
|
||||
self.assertEqual(restored.comment, original.comment)
|
||||
self.assertEqual(restored._type, original._type)
|
||||
|
||||
def test_beacon_packet_from_raw_string(self):
|
||||
"""Test BeaconPacket creation from raw APRS string."""
|
||||
# Use a format that aprslib can parse correctly
|
||||
packet_raw = 'kd8mey-10>APRS,TCPIP*,qAC,T2SYDNEY:=4247.80N/08539.00WrPHG1210/Making 220 Great Again Allstar# 552191'
|
||||
packet_dict = aprslib.parse(packet_raw)
|
||||
packet = packets.factory(packet_dict)
|
||||
self.assertIsInstance(packet, packets.BeaconPacket)
|
||||
# Test to_json
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'BeaconPacket')
|
||||
# Test from_dict round trip
|
||||
restored = packets.factory(json_dict)
|
||||
self.assertIsInstance(restored, packets.BeaconPacket)
|
||||
self.assertEqual(restored.from_call, packet.from_call)
|
||||
self.assertEqual(restored.latitude, packet.latitude)
|
||||
self.assertEqual(restored.longitude, packet.longitude)
|
||||
@@ -0,0 +1,75 @@
|
||||
import json
|
||||
import unittest
|
||||
|
||||
import aprslib
|
||||
|
||||
from aprsd import packets
|
||||
from tests import fake
|
||||
|
||||
|
||||
class TestBulletinPacket(unittest.TestCase):
|
||||
"""Test BulletinPacket JSON serialization."""
|
||||
|
||||
def test_bulletin_packet_to_json(self):
|
||||
"""Test BulletinPacket.to_json() method."""
|
||||
packet = packets.BulletinPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
message_text='Test bulletin message',
|
||||
bid='1',
|
||||
)
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'BulletinPacket')
|
||||
self.assertEqual(json_dict['from_call'], fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(json_dict['message_text'], 'Test bulletin message')
|
||||
self.assertEqual(json_dict['bid'], '1')
|
||||
|
||||
def test_bulletin_packet_from_dict(self):
|
||||
"""Test BulletinPacket.from_dict() method."""
|
||||
packet_dict = {
|
||||
'_type': 'BulletinPacket',
|
||||
'from_call': fake.FAKE_FROM_CALLSIGN,
|
||||
'message_text': 'Test bulletin message',
|
||||
'bid': '1',
|
||||
}
|
||||
packet = packets.BulletinPacket.from_dict(packet_dict)
|
||||
self.assertIsInstance(packet, packets.BulletinPacket)
|
||||
self.assertEqual(packet.from_call, fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(packet.message_text, 'Test bulletin message')
|
||||
self.assertEqual(packet.bid, '1')
|
||||
|
||||
def test_bulletin_packet_round_trip(self):
|
||||
"""Test BulletinPacket round-trip: to_json -> from_dict."""
|
||||
original = packets.BulletinPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
message_text='Test bulletin message',
|
||||
bid='1',
|
||||
)
|
||||
json_str = original.to_json()
|
||||
packet_dict = json.loads(json_str)
|
||||
restored = packets.BulletinPacket.from_dict(packet_dict)
|
||||
self.assertEqual(restored.from_call, original.from_call)
|
||||
self.assertEqual(restored.message_text, original.message_text)
|
||||
self.assertEqual(restored.bid, original.bid)
|
||||
self.assertEqual(restored._type, original._type)
|
||||
|
||||
def test_bulletin_packet_from_raw_string(self):
|
||||
"""Test BulletinPacket creation from raw APRS string."""
|
||||
packet_raw = 'KFAKE>APZ100::BLN1 :Test bulletin message'
|
||||
packet_dict = aprslib.parse(packet_raw)
|
||||
# aprslib might not set format correctly, so set it manually
|
||||
packet_dict['format'] = 'bulletin'
|
||||
packet = packets.factory(packet_dict)
|
||||
self.assertIsInstance(packet, packets.BulletinPacket)
|
||||
# Test to_json
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'BulletinPacket')
|
||||
# Test from_dict round trip
|
||||
restored = packets.factory(json_dict)
|
||||
self.assertIsInstance(restored, packets.BulletinPacket)
|
||||
self.assertEqual(restored.from_call, packet.from_call)
|
||||
self.assertEqual(restored.message_text, packet.message_text)
|
||||
self.assertEqual(restored.bid, packet.bid)
|
||||
@@ -0,0 +1,109 @@
|
||||
import json
|
||||
import unittest
|
||||
|
||||
import aprslib
|
||||
|
||||
from aprsd import packets
|
||||
from tests import fake
|
||||
|
||||
|
||||
class TestGPSPacket(unittest.TestCase):
|
||||
"""Test GPSPacket JSON serialization."""
|
||||
|
||||
def test_gps_packet_to_json(self):
|
||||
"""Test GPSPacket.to_json() method."""
|
||||
packet = packets.GPSPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
latitude=37.7749,
|
||||
longitude=-122.4194,
|
||||
altitude=100.0,
|
||||
symbol='>',
|
||||
symbol_table='/',
|
||||
comment='Test GPS comment',
|
||||
)
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'GPSPacket')
|
||||
self.assertEqual(json_dict['from_call'], fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(json_dict['to_call'], fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(json_dict['latitude'], 37.7749)
|
||||
self.assertEqual(json_dict['longitude'], -122.4194)
|
||||
self.assertEqual(json_dict['altitude'], 100.0)
|
||||
self.assertEqual(json_dict['symbol'], '>')
|
||||
self.assertEqual(json_dict['symbol_table'], '/')
|
||||
self.assertEqual(json_dict['comment'], 'Test GPS comment')
|
||||
|
||||
def test_gps_packet_from_dict(self):
|
||||
"""Test GPSPacket.from_dict() method."""
|
||||
packet_dict = {
|
||||
'_type': 'GPSPacket',
|
||||
'from_call': fake.FAKE_FROM_CALLSIGN,
|
||||
'to_call': fake.FAKE_TO_CALLSIGN,
|
||||
'latitude': 37.7749,
|
||||
'longitude': -122.4194,
|
||||
'altitude': 100.0,
|
||||
'symbol': '>',
|
||||
'symbol_table': '/',
|
||||
'comment': 'Test GPS comment',
|
||||
}
|
||||
packet = packets.GPSPacket.from_dict(packet_dict)
|
||||
self.assertIsInstance(packet, packets.GPSPacket)
|
||||
self.assertEqual(packet.from_call, fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(packet.to_call, fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(packet.latitude, 37.7749)
|
||||
self.assertEqual(packet.longitude, -122.4194)
|
||||
self.assertEqual(packet.altitude, 100.0)
|
||||
self.assertEqual(packet.symbol, '>')
|
||||
self.assertEqual(packet.symbol_table, '/')
|
||||
self.assertEqual(packet.comment, 'Test GPS comment')
|
||||
|
||||
def test_gps_packet_round_trip(self):
|
||||
"""Test GPSPacket round-trip: to_json -> from_dict."""
|
||||
original = packets.GPSPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
latitude=37.7749,
|
||||
longitude=-122.4194,
|
||||
altitude=100.0,
|
||||
symbol='>',
|
||||
symbol_table='/',
|
||||
comment='Test GPS comment',
|
||||
speed=25.5,
|
||||
course=180,
|
||||
)
|
||||
json_str = original.to_json()
|
||||
packet_dict = json.loads(json_str)
|
||||
restored = packets.GPSPacket.from_dict(packet_dict)
|
||||
self.assertEqual(restored.from_call, original.from_call)
|
||||
self.assertEqual(restored.to_call, original.to_call)
|
||||
self.assertEqual(restored.latitude, original.latitude)
|
||||
self.assertEqual(restored.longitude, original.longitude)
|
||||
self.assertEqual(restored.altitude, original.altitude)
|
||||
self.assertEqual(restored.symbol, original.symbol)
|
||||
self.assertEqual(restored.symbol_table, original.symbol_table)
|
||||
self.assertEqual(restored.comment, original.comment)
|
||||
self.assertEqual(restored.speed, original.speed)
|
||||
self.assertEqual(restored.course, original.course)
|
||||
self.assertEqual(restored._type, original._type)
|
||||
|
||||
def test_gps_packet_from_raw_string(self):
|
||||
"""Test GPSPacket creation from raw APRS string."""
|
||||
packet_raw = 'KFAKE>APZ100,WIDE2-1:!3742.00N/12225.00W>Test GPS comment'
|
||||
packet_dict = aprslib.parse(packet_raw)
|
||||
packet = packets.factory(packet_dict)
|
||||
# GPS packets are typically created as BeaconPacket or other types
|
||||
# but we can test if it has GPS data
|
||||
self.assertIsNotNone(packet)
|
||||
if hasattr(packet, 'latitude') and hasattr(packet, 'longitude'):
|
||||
# Test to_json
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertIn('latitude', json_dict)
|
||||
self.assertIn('longitude', json_dict)
|
||||
# Test from_dict round trip
|
||||
restored = packets.factory(json_dict)
|
||||
self.assertEqual(restored.latitude, packet.latitude)
|
||||
self.assertEqual(restored.longitude, packet.longitude)
|
||||
@@ -0,0 +1,80 @@
|
||||
import json
|
||||
import unittest
|
||||
|
||||
import aprslib
|
||||
|
||||
from aprsd import packets
|
||||
from tests import fake
|
||||
|
||||
|
||||
class TestMessagePacket(unittest.TestCase):
|
||||
"""Test MessagePacket JSON serialization."""
|
||||
|
||||
def test_message_packet_to_json(self):
|
||||
"""Test MessagePacket.to_json() method."""
|
||||
packet = packets.MessagePacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
message_text='Test message',
|
||||
msgNo='123',
|
||||
)
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'MessagePacket')
|
||||
self.assertEqual(json_dict['from_call'], fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(json_dict['to_call'], fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(json_dict['message_text'], 'Test message')
|
||||
self.assertEqual(json_dict['msgNo'], '123')
|
||||
|
||||
def test_message_packet_from_dict(self):
|
||||
"""Test MessagePacket.from_dict() method."""
|
||||
packet_dict = {
|
||||
'_type': 'MessagePacket',
|
||||
'from_call': fake.FAKE_FROM_CALLSIGN,
|
||||
'to_call': fake.FAKE_TO_CALLSIGN,
|
||||
'message_text': 'Test message',
|
||||
'msgNo': '123',
|
||||
}
|
||||
packet = packets.MessagePacket.from_dict(packet_dict)
|
||||
self.assertIsInstance(packet, packets.MessagePacket)
|
||||
self.assertEqual(packet.from_call, fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(packet.to_call, fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(packet.message_text, 'Test message')
|
||||
self.assertEqual(packet.msgNo, '123')
|
||||
|
||||
def test_message_packet_round_trip(self):
|
||||
"""Test MessagePacket round-trip: to_json -> from_dict."""
|
||||
original = packets.MessagePacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
message_text='Test message',
|
||||
msgNo='123',
|
||||
)
|
||||
json_str = original.to_json()
|
||||
packet_dict = json.loads(json_str)
|
||||
restored = packets.MessagePacket.from_dict(packet_dict)
|
||||
self.assertEqual(restored.from_call, original.from_call)
|
||||
self.assertEqual(restored.to_call, original.to_call)
|
||||
self.assertEqual(restored.message_text, original.message_text)
|
||||
self.assertEqual(restored.msgNo, original.msgNo)
|
||||
self.assertEqual(restored._type, original._type)
|
||||
|
||||
def test_message_packet_from_raw_string(self):
|
||||
"""Test MessagePacket creation from raw APRS string."""
|
||||
packet_raw = 'KM6LYW>APZ100::WB4BOR :Test message{123'
|
||||
packet_dict = aprslib.parse(packet_raw)
|
||||
packet = packets.factory(packet_dict)
|
||||
self.assertIsInstance(packet, packets.MessagePacket)
|
||||
# Test to_json
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'MessagePacket')
|
||||
# Test from_dict round trip
|
||||
restored = packets.factory(json_dict)
|
||||
self.assertIsInstance(restored, packets.MessagePacket)
|
||||
self.assertEqual(restored.from_call, packet.from_call)
|
||||
self.assertEqual(restored.to_call, packet.to_call)
|
||||
self.assertEqual(restored.message_text, packet.message_text)
|
||||
self.assertEqual(restored.msgNo, packet.msgNo)
|
||||
@@ -0,0 +1,107 @@
|
||||
import json
|
||||
import unittest
|
||||
|
||||
import aprslib
|
||||
|
||||
from aprsd import packets
|
||||
from tests import fake
|
||||
|
||||
|
||||
class TestMicEPacket(unittest.TestCase):
|
||||
"""Test MicEPacket JSON serialization."""
|
||||
|
||||
def test_mice_packet_to_json(self):
|
||||
"""Test MicEPacket.to_json() method."""
|
||||
packet = packets.MicEPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
latitude=37.7749,
|
||||
longitude=-122.4194,
|
||||
speed=25.5,
|
||||
course=180,
|
||||
mbits='test',
|
||||
mtype='test_type',
|
||||
telemetry={'key': 'value'},
|
||||
)
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'MicEPacket')
|
||||
self.assertEqual(json_dict['from_call'], fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(json_dict['to_call'], fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(json_dict['latitude'], 37.7749)
|
||||
self.assertEqual(json_dict['longitude'], -122.4194)
|
||||
self.assertEqual(json_dict['speed'], 25.5)
|
||||
self.assertEqual(json_dict['course'], 180)
|
||||
self.assertEqual(json_dict['mbits'], 'test')
|
||||
self.assertEqual(json_dict['mtype'], 'test_type')
|
||||
|
||||
def test_mice_packet_from_dict(self):
|
||||
"""Test MicEPacket.from_dict() method."""
|
||||
packet_dict = {
|
||||
'_type': 'MicEPacket',
|
||||
'from_call': fake.FAKE_FROM_CALLSIGN,
|
||||
'to_call': fake.FAKE_TO_CALLSIGN,
|
||||
'latitude': 37.7749,
|
||||
'longitude': -122.4194,
|
||||
'speed': 25.5,
|
||||
'course': 180,
|
||||
'mbits': 'test',
|
||||
'mtype': 'test_type',
|
||||
'telemetry': {'key': 'value'},
|
||||
}
|
||||
packet = packets.MicEPacket.from_dict(packet_dict)
|
||||
self.assertIsInstance(packet, packets.MicEPacket)
|
||||
self.assertEqual(packet.from_call, fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(packet.to_call, fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(packet.latitude, 37.7749)
|
||||
self.assertEqual(packet.longitude, -122.4194)
|
||||
self.assertEqual(packet.speed, 25.5)
|
||||
self.assertEqual(packet.course, 180)
|
||||
self.assertEqual(packet.mbits, 'test')
|
||||
self.assertEqual(packet.mtype, 'test_type')
|
||||
|
||||
def test_mice_packet_round_trip(self):
|
||||
"""Test MicEPacket round-trip: to_json -> from_dict."""
|
||||
original = packets.MicEPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
latitude=37.7749,
|
||||
longitude=-122.4194,
|
||||
speed=25.5,
|
||||
course=180,
|
||||
mbits='test',
|
||||
mtype='test_type',
|
||||
telemetry={'key': 'value'},
|
||||
)
|
||||
json_str = original.to_json()
|
||||
packet_dict = json.loads(json_str)
|
||||
restored = packets.MicEPacket.from_dict(packet_dict)
|
||||
self.assertEqual(restored.from_call, original.from_call)
|
||||
self.assertEqual(restored.to_call, original.to_call)
|
||||
self.assertEqual(restored.latitude, original.latitude)
|
||||
self.assertEqual(restored.longitude, original.longitude)
|
||||
self.assertEqual(restored.speed, original.speed)
|
||||
self.assertEqual(restored.course, original.course)
|
||||
self.assertEqual(restored.mbits, original.mbits)
|
||||
self.assertEqual(restored.mtype, original.mtype)
|
||||
self.assertEqual(restored._type, original._type)
|
||||
|
||||
def test_mice_packet_from_raw_string(self):
|
||||
"""Test MicEPacket creation from raw APRS string."""
|
||||
packet_raw = 'kh2sr-15>S7TSYR,WIDE1-1,WIDE2-1,qAO,KO6KL-1:`1`7\x1c\x1c.#/`"4,}QuirkyQRP 4.6V 35.3C S06'
|
||||
packet_dict = aprslib.parse(packet_raw)
|
||||
packet = packets.factory(packet_dict)
|
||||
self.assertIsInstance(packet, packets.MicEPacket)
|
||||
# Test to_json
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'MicEPacket')
|
||||
# Test from_dict round trip
|
||||
restored = packets.factory(json_dict)
|
||||
self.assertIsInstance(restored, packets.MicEPacket)
|
||||
self.assertEqual(restored.from_call, packet.from_call)
|
||||
if hasattr(packet, 'latitude') and packet.latitude:
|
||||
self.assertEqual(restored.latitude, packet.latitude)
|
||||
self.assertEqual(restored.longitude, packet.longitude)
|
||||
@@ -0,0 +1,122 @@
|
||||
import json
|
||||
import unittest
|
||||
|
||||
import aprslib
|
||||
|
||||
from aprsd import packets
|
||||
from tests import fake
|
||||
|
||||
|
||||
class TestObjectPacket(unittest.TestCase):
|
||||
"""Test ObjectPacket JSON serialization."""
|
||||
|
||||
def test_object_packet_to_json(self):
|
||||
"""Test ObjectPacket.to_json() method."""
|
||||
packet = packets.ObjectPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
latitude=37.7749,
|
||||
longitude=-122.4194,
|
||||
symbol='r',
|
||||
symbol_table='/',
|
||||
comment='Test object comment',
|
||||
alive=True,
|
||||
speed=25.5,
|
||||
course=180,
|
||||
)
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'ObjectPacket')
|
||||
self.assertEqual(json_dict['from_call'], fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(json_dict['to_call'], fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(json_dict['latitude'], 37.7749)
|
||||
self.assertEqual(json_dict['longitude'], -122.4194)
|
||||
self.assertEqual(json_dict['symbol'], 'r')
|
||||
self.assertEqual(json_dict['symbol_table'], '/')
|
||||
self.assertEqual(json_dict['comment'], 'Test object comment')
|
||||
self.assertEqual(json_dict['alive'], True)
|
||||
self.assertEqual(json_dict['speed'], 25.5)
|
||||
self.assertEqual(json_dict['course'], 180)
|
||||
|
||||
def test_object_packet_from_dict(self):
|
||||
"""Test ObjectPacket.from_dict() method."""
|
||||
packet_dict = {
|
||||
'_type': 'ObjectPacket',
|
||||
'from_call': fake.FAKE_FROM_CALLSIGN,
|
||||
'to_call': fake.FAKE_TO_CALLSIGN,
|
||||
'latitude': 37.7749,
|
||||
'longitude': -122.4194,
|
||||
'symbol': 'r',
|
||||
'symbol_table': '/',
|
||||
'comment': 'Test object comment',
|
||||
'alive': True,
|
||||
'speed': 25.5,
|
||||
'course': 180,
|
||||
}
|
||||
packet = packets.ObjectPacket.from_dict(packet_dict)
|
||||
self.assertIsInstance(packet, packets.ObjectPacket)
|
||||
self.assertEqual(packet.from_call, fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(packet.to_call, fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(packet.latitude, 37.7749)
|
||||
self.assertEqual(packet.longitude, -122.4194)
|
||||
self.assertEqual(packet.symbol, 'r')
|
||||
self.assertEqual(packet.symbol_table, '/')
|
||||
self.assertEqual(packet.comment, 'Test object comment')
|
||||
self.assertEqual(packet.alive, True)
|
||||
self.assertEqual(packet.speed, 25.5)
|
||||
self.assertEqual(packet.course, 180)
|
||||
|
||||
def test_object_packet_round_trip(self):
|
||||
"""Test ObjectPacket round-trip: to_json -> from_dict."""
|
||||
original = packets.ObjectPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
latitude=37.7749,
|
||||
longitude=-122.4194,
|
||||
symbol='r',
|
||||
symbol_table='/',
|
||||
comment='Test object comment',
|
||||
alive=True,
|
||||
speed=25.5,
|
||||
course=180,
|
||||
)
|
||||
json_str = original.to_json()
|
||||
packet_dict = json.loads(json_str)
|
||||
restored = packets.ObjectPacket.from_dict(packet_dict)
|
||||
self.assertEqual(restored.from_call, original.from_call)
|
||||
self.assertEqual(restored.to_call, original.to_call)
|
||||
self.assertEqual(restored.latitude, original.latitude)
|
||||
self.assertEqual(restored.longitude, original.longitude)
|
||||
self.assertEqual(restored.symbol, original.symbol)
|
||||
self.assertEqual(restored.symbol_table, original.symbol_table)
|
||||
self.assertEqual(restored.comment, original.comment)
|
||||
self.assertEqual(restored.alive, original.alive)
|
||||
self.assertEqual(restored.speed, original.speed)
|
||||
self.assertEqual(restored.course, original.course)
|
||||
self.assertEqual(restored._type, original._type)
|
||||
|
||||
def test_object_packet_from_raw_string(self):
|
||||
"""Test ObjectPacket creation from raw APRS string."""
|
||||
# Use a working object packet example from the codebase
|
||||
packet_raw = (
|
||||
'REPEAT>APZ100:;K4CQ *301301z3735.11N/07903.08Wr145.490MHz T136 -060'
|
||||
)
|
||||
packet_dict = aprslib.parse(packet_raw)
|
||||
# aprslib might not set format correctly, so set it manually
|
||||
packet_dict['format'] = 'object'
|
||||
packet = packets.factory(packet_dict)
|
||||
self.assertIsInstance(packet, packets.ObjectPacket)
|
||||
# Test to_json
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'ObjectPacket')
|
||||
# Test from_dict round trip
|
||||
restored = packets.factory(json_dict)
|
||||
self.assertIsInstance(restored, packets.ObjectPacket)
|
||||
self.assertEqual(restored.from_call, packet.from_call)
|
||||
self.assertEqual(restored.to_call, packet.to_call)
|
||||
if hasattr(packet, 'latitude') and packet.latitude:
|
||||
self.assertEqual(restored.latitude, packet.latitude)
|
||||
self.assertEqual(restored.longitude, packet.longitude)
|
||||
@@ -0,0 +1,75 @@
|
||||
import json
|
||||
import unittest
|
||||
|
||||
import aprslib
|
||||
|
||||
from aprsd import packets
|
||||
from tests import fake
|
||||
|
||||
|
||||
class TestPacket(unittest.TestCase):
|
||||
"""Test Packet base class JSON serialization."""
|
||||
|
||||
def test_packet_to_json(self):
|
||||
"""Test Packet.to_json() method."""
|
||||
packet = packets.Packet(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
msgNo='123',
|
||||
)
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
# Verify it's valid JSON
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['from_call'], fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(json_dict['to_call'], fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(json_dict['msgNo'], '123')
|
||||
|
||||
def test_packet_from_dict(self):
|
||||
"""Test Packet.from_dict() method."""
|
||||
packet_dict = {
|
||||
'_type': 'Packet',
|
||||
'from_call': fake.FAKE_FROM_CALLSIGN,
|
||||
'to_call': fake.FAKE_TO_CALLSIGN,
|
||||
'msgNo': '123',
|
||||
}
|
||||
packet = packets.Packet.from_dict(packet_dict)
|
||||
self.assertIsInstance(packet, packets.Packet)
|
||||
self.assertEqual(packet.from_call, fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(packet.to_call, fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(packet.msgNo, '123')
|
||||
|
||||
def test_packet_round_trip(self):
|
||||
"""Test Packet round-trip: to_json -> from_dict."""
|
||||
original = packets.Packet(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
msgNo='123',
|
||||
addresse=fake.FAKE_TO_CALLSIGN,
|
||||
)
|
||||
json_str = original.to_json()
|
||||
packet_dict = json.loads(json_str)
|
||||
restored = packets.Packet.from_dict(packet_dict)
|
||||
self.assertEqual(restored.from_call, original.from_call)
|
||||
self.assertEqual(restored.to_call, original.to_call)
|
||||
self.assertEqual(restored.msgNo, original.msgNo)
|
||||
self.assertEqual(restored.addresse, original.addresse)
|
||||
|
||||
def test_packet_from_raw_string(self):
|
||||
"""Test Packet creation from raw APRS string."""
|
||||
# Note: Base Packet is rarely used directly, but we can test with a simple message
|
||||
packet_raw = 'KFAKE>APZ100::KMINE :Test message{123'
|
||||
packet_dict = aprslib.parse(packet_raw)
|
||||
# aprslib might not set format correctly, so set it manually
|
||||
packet_dict['format'] = 'message'
|
||||
packet = packets.factory(packet_dict)
|
||||
self.assertIsInstance(packet, packets.MessagePacket)
|
||||
# Test to_json
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertIn('from_call', json_dict)
|
||||
# Test from_dict round trip
|
||||
restored = packets.factory(json_dict)
|
||||
self.assertEqual(restored.from_call, packet.from_call)
|
||||
self.assertEqual(restored.to_call, packet.to_call)
|
||||
@@ -0,0 +1,76 @@
|
||||
import json
|
||||
import unittest
|
||||
|
||||
import aprslib
|
||||
|
||||
from aprsd import packets
|
||||
from tests import fake
|
||||
|
||||
|
||||
class TestRejectPacket(unittest.TestCase):
|
||||
"""Test RejectPacket JSON serialization."""
|
||||
|
||||
def test_reject_packet_to_json(self):
|
||||
"""Test RejectPacket.to_json() method."""
|
||||
packet = packets.RejectPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
msgNo='123',
|
||||
response='rej',
|
||||
)
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'RejectPacket')
|
||||
self.assertEqual(json_dict['from_call'], fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(json_dict['to_call'], fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(json_dict['msgNo'], '123')
|
||||
|
||||
def test_reject_packet_from_dict(self):
|
||||
"""Test RejectPacket.from_dict() method."""
|
||||
packet_dict = {
|
||||
'_type': 'RejectPacket',
|
||||
'from_call': fake.FAKE_FROM_CALLSIGN,
|
||||
'to_call': fake.FAKE_TO_CALLSIGN,
|
||||
'msgNo': '123',
|
||||
'response': 'rej',
|
||||
}
|
||||
packet = packets.RejectPacket.from_dict(packet_dict)
|
||||
self.assertIsInstance(packet, packets.RejectPacket)
|
||||
self.assertEqual(packet.from_call, fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(packet.to_call, fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(packet.msgNo, '123')
|
||||
|
||||
def test_reject_packet_round_trip(self):
|
||||
"""Test RejectPacket round-trip: to_json -> from_dict."""
|
||||
original = packets.RejectPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
msgNo='123',
|
||||
response='rej',
|
||||
)
|
||||
json_str = original.to_json()
|
||||
packet_dict = json.loads(json_str)
|
||||
restored = packets.RejectPacket.from_dict(packet_dict)
|
||||
self.assertEqual(restored.from_call, original.from_call)
|
||||
self.assertEqual(restored.to_call, original.to_call)
|
||||
self.assertEqual(restored.msgNo, original.msgNo)
|
||||
self.assertEqual(restored._type, original._type)
|
||||
|
||||
def test_reject_packet_from_raw_string(self):
|
||||
"""Test RejectPacket creation from raw APRS string."""
|
||||
packet_raw = 'HB9FDL-1>APK102,HB9FM-4*,WIDE2,qAR,HB9FEF-11::REPEAT :rej4139'
|
||||
packet_dict = aprslib.parse(packet_raw)
|
||||
packet = packets.factory(packet_dict)
|
||||
self.assertIsInstance(packet, packets.RejectPacket)
|
||||
# Test to_json
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'RejectPacket')
|
||||
# Test from_dict round trip
|
||||
restored = packets.factory(json_dict)
|
||||
self.assertIsInstance(restored, packets.RejectPacket)
|
||||
self.assertEqual(restored.from_call, packet.from_call)
|
||||
self.assertEqual(restored.to_call, packet.to_call)
|
||||
self.assertEqual(restored.msgNo, packet.msgNo)
|
||||
@@ -0,0 +1,93 @@
|
||||
import json
|
||||
import unittest
|
||||
|
||||
import aprslib
|
||||
|
||||
from aprsd import packets
|
||||
from tests import fake
|
||||
|
||||
|
||||
class TestStatusPacket(unittest.TestCase):
|
||||
"""Test StatusPacket JSON serialization."""
|
||||
|
||||
def test_status_packet_to_json(self):
|
||||
"""Test StatusPacket.to_json() method."""
|
||||
packet = packets.StatusPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
status='Test status message',
|
||||
msgNo='123',
|
||||
messagecapable=True,
|
||||
comment='Test comment',
|
||||
)
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'StatusPacket')
|
||||
self.assertEqual(json_dict['from_call'], fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(json_dict['to_call'], fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(json_dict['status'], 'Test status message')
|
||||
self.assertEqual(json_dict['msgNo'], '123')
|
||||
self.assertEqual(json_dict['messagecapable'], True)
|
||||
self.assertEqual(json_dict['comment'], 'Test comment')
|
||||
|
||||
def test_status_packet_from_dict(self):
|
||||
"""Test StatusPacket.from_dict() method."""
|
||||
packet_dict = {
|
||||
'_type': 'StatusPacket',
|
||||
'from_call': fake.FAKE_FROM_CALLSIGN,
|
||||
'to_call': fake.FAKE_TO_CALLSIGN,
|
||||
'status': 'Test status message',
|
||||
'msgNo': '123',
|
||||
'messagecapable': True,
|
||||
'comment': 'Test comment',
|
||||
}
|
||||
packet = packets.StatusPacket.from_dict(packet_dict)
|
||||
self.assertIsInstance(packet, packets.StatusPacket)
|
||||
self.assertEqual(packet.from_call, fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(packet.to_call, fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(packet.status, 'Test status message')
|
||||
self.assertEqual(packet.msgNo, '123')
|
||||
self.assertEqual(packet.messagecapable, True)
|
||||
self.assertEqual(packet.comment, 'Test comment')
|
||||
|
||||
def test_status_packet_round_trip(self):
|
||||
"""Test StatusPacket round-trip: to_json -> from_dict."""
|
||||
original = packets.StatusPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
status='Test status message',
|
||||
msgNo='123',
|
||||
messagecapable=True,
|
||||
comment='Test comment',
|
||||
)
|
||||
json_str = original.to_json()
|
||||
packet_dict = json.loads(json_str)
|
||||
restored = packets.StatusPacket.from_dict(packet_dict)
|
||||
self.assertEqual(restored.from_call, original.from_call)
|
||||
self.assertEqual(restored.to_call, original.to_call)
|
||||
self.assertEqual(restored.status, original.status)
|
||||
self.assertEqual(restored.msgNo, original.msgNo)
|
||||
self.assertEqual(restored.messagecapable, original.messagecapable)
|
||||
self.assertEqual(restored.comment, original.comment)
|
||||
self.assertEqual(restored._type, original._type)
|
||||
|
||||
def test_status_packet_from_raw_string(self):
|
||||
"""Test StatusPacket creation from raw APRS string."""
|
||||
packet_raw = 'KFAKE>APZ100::KMINE :Test status message{123'
|
||||
packet_dict = aprslib.parse(packet_raw)
|
||||
# aprslib might not set format correctly, so set it manually
|
||||
packet_dict['format'] = 'status'
|
||||
packet = packets.factory(packet_dict)
|
||||
self.assertIsInstance(packet, packets.StatusPacket)
|
||||
# Test to_json
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'StatusPacket')
|
||||
# Test from_dict round trip
|
||||
restored = packets.factory(json_dict)
|
||||
self.assertIsInstance(restored, packets.StatusPacket)
|
||||
self.assertEqual(restored.from_call, packet.from_call)
|
||||
self.assertEqual(restored.to_call, packet.to_call)
|
||||
self.assertEqual(restored.status, packet.status)
|
||||
@@ -0,0 +1,115 @@
|
||||
import json
|
||||
import unittest
|
||||
|
||||
import aprslib
|
||||
|
||||
from aprsd import packets
|
||||
from aprsd.packets.core import TelemetryPacket
|
||||
from tests import fake
|
||||
|
||||
|
||||
class TestTelemetryPacket(unittest.TestCase):
|
||||
"""Test TelemetryPacket JSON serialization."""
|
||||
|
||||
def test_telemetry_packet_to_json(self):
|
||||
"""Test TelemetryPacket.to_json() method."""
|
||||
packet = TelemetryPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
latitude=37.7749,
|
||||
longitude=-122.4194,
|
||||
speed=25.5,
|
||||
course=180,
|
||||
mbits='test',
|
||||
mtype='test_type',
|
||||
telemetry={'key': 'value'},
|
||||
tPARM=['parm1', 'parm2'],
|
||||
tUNIT=['unit1', 'unit2'],
|
||||
)
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'TelemetryPacket')
|
||||
self.assertEqual(json_dict['from_call'], fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(json_dict['to_call'], fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(json_dict['latitude'], 37.7749)
|
||||
self.assertEqual(json_dict['longitude'], -122.4194)
|
||||
self.assertEqual(json_dict['speed'], 25.5)
|
||||
self.assertEqual(json_dict['course'], 180)
|
||||
self.assertEqual(json_dict['mbits'], 'test')
|
||||
self.assertEqual(json_dict['mtype'], 'test_type')
|
||||
|
||||
def test_telemetry_packet_from_dict(self):
|
||||
"""Test TelemetryPacket.from_dict() method."""
|
||||
packet_dict = {
|
||||
'_type': 'TelemetryPacket',
|
||||
'from_call': fake.FAKE_FROM_CALLSIGN,
|
||||
'to_call': fake.FAKE_TO_CALLSIGN,
|
||||
'latitude': 37.7749,
|
||||
'longitude': -122.4194,
|
||||
'speed': 25.5,
|
||||
'course': 180,
|
||||
'mbits': 'test',
|
||||
'mtype': 'test_type',
|
||||
'telemetry': {'key': 'value'},
|
||||
'tPARM': ['parm1', 'parm2'],
|
||||
'tUNIT': ['unit1', 'unit2'],
|
||||
}
|
||||
packet = TelemetryPacket.from_dict(packet_dict)
|
||||
self.assertIsInstance(packet, TelemetryPacket)
|
||||
self.assertEqual(packet.from_call, fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(packet.to_call, fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(packet.latitude, 37.7749)
|
||||
self.assertEqual(packet.longitude, -122.4194)
|
||||
self.assertEqual(packet.speed, 25.5)
|
||||
self.assertEqual(packet.course, 180)
|
||||
self.assertEqual(packet.mbits, 'test')
|
||||
self.assertEqual(packet.mtype, 'test_type')
|
||||
|
||||
def test_telemetry_packet_round_trip(self):
|
||||
"""Test TelemetryPacket round-trip: to_json -> from_dict."""
|
||||
original = TelemetryPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
latitude=37.7749,
|
||||
longitude=-122.4194,
|
||||
speed=25.5,
|
||||
course=180,
|
||||
mbits='test',
|
||||
mtype='test_type',
|
||||
telemetry={'key': 'value'},
|
||||
tPARM=['parm1', 'parm2'],
|
||||
tUNIT=['unit1', 'unit2'],
|
||||
)
|
||||
json_str = original.to_json()
|
||||
packet_dict = json.loads(json_str)
|
||||
restored = TelemetryPacket.from_dict(packet_dict)
|
||||
self.assertEqual(restored.from_call, original.from_call)
|
||||
self.assertEqual(restored.to_call, original.to_call)
|
||||
self.assertEqual(restored.latitude, original.latitude)
|
||||
self.assertEqual(restored.longitude, original.longitude)
|
||||
self.assertEqual(restored.speed, original.speed)
|
||||
self.assertEqual(restored.course, original.course)
|
||||
self.assertEqual(restored.mbits, original.mbits)
|
||||
self.assertEqual(restored.mtype, original.mtype)
|
||||
self.assertEqual(restored._type, original._type)
|
||||
|
||||
def test_telemetry_packet_from_raw_string(self):
|
||||
"""Test TelemetryPacket creation from raw APRS string."""
|
||||
# Telemetry packets are less common, using a Mic-E with telemetry as example
|
||||
packet_raw = (
|
||||
"KD9YIL>T0PX9W,WIDE1-1,WIDE2-1,qAO,NU9R-10:`sB,l#P>/'\"6+}|#*%U'a|!whl!|3"
|
||||
)
|
||||
packet_dict = aprslib.parse(packet_raw)
|
||||
packet = packets.factory(packet_dict)
|
||||
# This might be MicEPacket or TelemetryPacket depending on content
|
||||
self.assertIsNotNone(packet)
|
||||
# Test to_json
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
# Test from_dict round trip
|
||||
restored = packets.factory(json_dict)
|
||||
self.assertEqual(restored.from_call, packet.from_call)
|
||||
if hasattr(packet, 'telemetry') and packet.telemetry:
|
||||
self.assertIsNotNone(restored.telemetry)
|
||||
@@ -0,0 +1,99 @@
|
||||
import json
|
||||
import unittest
|
||||
|
||||
import aprslib
|
||||
|
||||
from aprsd import packets
|
||||
from tests import fake
|
||||
|
||||
|
||||
class TestThirdPartyPacket(unittest.TestCase):
|
||||
"""Test ThirdPartyPacket JSON serialization."""
|
||||
|
||||
def test_thirdparty_packet_to_json(self):
|
||||
"""Test ThirdPartyPacket.to_json() method."""
|
||||
subpacket = packets.MessagePacket(
|
||||
from_call='SUB',
|
||||
to_call='TARGET',
|
||||
message_text='Sub message',
|
||||
)
|
||||
packet = packets.ThirdPartyPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
subpacket=subpacket,
|
||||
)
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'ThirdPartyPacket')
|
||||
self.assertEqual(json_dict['from_call'], fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(json_dict['to_call'], fake.FAKE_TO_CALLSIGN)
|
||||
# subpacket should be serialized as a dict
|
||||
self.assertIn('subpacket', json_dict)
|
||||
self.assertIsInstance(json_dict['subpacket'], dict)
|
||||
|
||||
def test_thirdparty_packet_from_dict(self):
|
||||
"""Test ThirdPartyPacket.from_dict() method."""
|
||||
subpacket_dict = {
|
||||
'_type': 'MessagePacket',
|
||||
'from_call': 'SUB',
|
||||
'to_call': 'TARGET',
|
||||
'message_text': 'Sub message',
|
||||
}
|
||||
packet_dict = {
|
||||
'_type': 'ThirdPartyPacket',
|
||||
'from_call': fake.FAKE_FROM_CALLSIGN,
|
||||
'to_call': fake.FAKE_TO_CALLSIGN,
|
||||
'subpacket': subpacket_dict,
|
||||
}
|
||||
packet = packets.ThirdPartyPacket.from_dict(packet_dict)
|
||||
self.assertIsInstance(packet, packets.ThirdPartyPacket)
|
||||
self.assertEqual(packet.from_call, fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(packet.to_call, fake.FAKE_TO_CALLSIGN)
|
||||
self.assertIsNotNone(packet.subpacket)
|
||||
self.assertIsInstance(packet.subpacket, packets.MessagePacket)
|
||||
|
||||
def test_thirdparty_packet_round_trip(self):
|
||||
"""Test ThirdPartyPacket round-trip: to_json -> from_dict."""
|
||||
subpacket = packets.MessagePacket(
|
||||
from_call='SUB',
|
||||
to_call='TARGET',
|
||||
message_text='Sub message',
|
||||
)
|
||||
original = packets.ThirdPartyPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
subpacket=subpacket,
|
||||
)
|
||||
json_str = original.to_json()
|
||||
packet_dict = json.loads(json_str)
|
||||
restored = packets.ThirdPartyPacket.from_dict(packet_dict)
|
||||
self.assertEqual(restored.from_call, original.from_call)
|
||||
self.assertEqual(restored.to_call, original.to_call)
|
||||
self.assertEqual(restored._type, original._type)
|
||||
# Verify subpacket was restored
|
||||
self.assertIsNotNone(restored.subpacket)
|
||||
self.assertIsInstance(restored.subpacket, packets.MessagePacket)
|
||||
self.assertEqual(restored.subpacket.from_call, original.subpacket.from_call)
|
||||
self.assertEqual(restored.subpacket.to_call, original.subpacket.to_call)
|
||||
self.assertEqual(
|
||||
restored.subpacket.message_text, original.subpacket.message_text
|
||||
)
|
||||
|
||||
def test_thirdparty_packet_from_raw_string(self):
|
||||
"""Test ThirdPartyPacket creation from raw APRS string."""
|
||||
packet_raw = 'GTOWN>APDW16,WIDE1-1,WIDE2-1:}KM6LYW-9>APZ100,TCPIP,GTOWN*::KM6LYW :KM6LYW: 19 Miles SW'
|
||||
packet_dict = aprslib.parse(packet_raw)
|
||||
packet = packets.factory(packet_dict)
|
||||
self.assertIsInstance(packet, packets.ThirdPartyPacket)
|
||||
# Test to_json
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'ThirdPartyPacket')
|
||||
# Test from_dict round trip
|
||||
restored = packets.factory(json_dict)
|
||||
self.assertIsInstance(restored, packets.ThirdPartyPacket)
|
||||
self.assertEqual(restored.from_call, packet.from_call)
|
||||
self.assertIsNotNone(restored.subpacket)
|
||||
self.assertEqual(restored.subpacket.from_call, packet.subpacket.from_call)
|
||||
@@ -0,0 +1,82 @@
|
||||
import json
|
||||
import unittest
|
||||
|
||||
import aprslib
|
||||
|
||||
from aprsd import packets
|
||||
from tests import fake
|
||||
|
||||
|
||||
class TestUnknownPacket(unittest.TestCase):
|
||||
"""Test UnknownPacket JSON serialization."""
|
||||
|
||||
def test_unknown_packet_to_json(self):
|
||||
"""Test UnknownPacket.to_json() method."""
|
||||
packet = packets.UnknownPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
format='unknown_format',
|
||||
packet_type='unknown',
|
||||
unknown_fields={'extra_field': 'extra_value'},
|
||||
)
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'UnknownPacket')
|
||||
self.assertEqual(json_dict['from_call'], fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(json_dict['to_call'], fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(json_dict['format'], 'unknown_format')
|
||||
self.assertEqual(json_dict['packet_type'], 'unknown')
|
||||
|
||||
def test_unknown_packet_from_dict(self):
|
||||
"""Test UnknownPacket.from_dict() method."""
|
||||
packet_dict = {
|
||||
'_type': 'UnknownPacket',
|
||||
'from_call': fake.FAKE_FROM_CALLSIGN,
|
||||
'to_call': fake.FAKE_TO_CALLSIGN,
|
||||
'format': 'unknown_format',
|
||||
'packet_type': 'unknown',
|
||||
'extra_field': 'extra_value',
|
||||
}
|
||||
packet = packets.UnknownPacket.from_dict(packet_dict)
|
||||
self.assertIsInstance(packet, packets.UnknownPacket)
|
||||
self.assertEqual(packet.from_call, fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(packet.to_call, fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(packet.format, 'unknown_format')
|
||||
self.assertEqual(packet.packet_type, 'unknown')
|
||||
|
||||
def test_unknown_packet_round_trip(self):
|
||||
"""Test UnknownPacket round-trip: to_json -> from_dict."""
|
||||
original = packets.UnknownPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
format='unknown_format',
|
||||
packet_type='unknown',
|
||||
unknown_fields={'extra_field': 'extra_value'},
|
||||
)
|
||||
json_str = original.to_json()
|
||||
packet_dict = json.loads(json_str)
|
||||
restored = packets.UnknownPacket.from_dict(packet_dict)
|
||||
self.assertEqual(restored.from_call, original.from_call)
|
||||
self.assertEqual(restored.to_call, original.to_call)
|
||||
self.assertEqual(restored.format, original.format)
|
||||
self.assertEqual(restored.packet_type, original.packet_type)
|
||||
self.assertEqual(restored._type, original._type)
|
||||
|
||||
def test_unknown_packet_from_raw_string(self):
|
||||
"""Test UnknownPacket creation from raw APRS string."""
|
||||
# Use a packet format that might not be recognized
|
||||
packet_raw = 'KFAKE>APZ100:>Unknown format data'
|
||||
packet_dict = aprslib.parse(packet_raw)
|
||||
packet = packets.factory(packet_dict)
|
||||
# This might be UnknownPacket or another type depending on parsing
|
||||
self.assertIsNotNone(packet)
|
||||
# Test to_json
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
# Test from_dict round trip
|
||||
restored = packets.factory(json_dict)
|
||||
self.assertEqual(restored.from_call, packet.from_call)
|
||||
if isinstance(packet, packets.UnknownPacket):
|
||||
self.assertIsInstance(restored, packets.UnknownPacket)
|
||||
@@ -0,0 +1,151 @@
|
||||
import json
|
||||
import unittest
|
||||
|
||||
import aprslib
|
||||
|
||||
from aprsd import packets
|
||||
from tests import fake
|
||||
|
||||
|
||||
class TestWeatherPacket(unittest.TestCase):
|
||||
"""Test WeatherPacket JSON serialization."""
|
||||
|
||||
def test_weather_packet_to_json(self):
|
||||
"""Test WeatherPacket.to_json() method."""
|
||||
packet = packets.WeatherPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
latitude=37.7749,
|
||||
longitude=-122.4194,
|
||||
symbol='_',
|
||||
symbol_table='/',
|
||||
wind_speed=10.5,
|
||||
wind_direction=180,
|
||||
wind_gust=15.0,
|
||||
temperature=72.5,
|
||||
rain_1h=0.1,
|
||||
rain_24h=0.5,
|
||||
rain_since_midnight=0.3,
|
||||
humidity=65,
|
||||
pressure=1013.25,
|
||||
comment='Test weather comment',
|
||||
)
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'WeatherPacket')
|
||||
self.assertEqual(json_dict['from_call'], fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(json_dict['to_call'], fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(json_dict['latitude'], 37.7749)
|
||||
self.assertEqual(json_dict['longitude'], -122.4194)
|
||||
self.assertEqual(json_dict['symbol'], '_')
|
||||
self.assertEqual(json_dict['wind_speed'], 10.5)
|
||||
self.assertEqual(json_dict['wind_direction'], 180)
|
||||
self.assertEqual(json_dict['wind_gust'], 15.0)
|
||||
self.assertEqual(json_dict['temperature'], 72.5)
|
||||
self.assertEqual(json_dict['rain_1h'], 0.1)
|
||||
self.assertEqual(json_dict['rain_24h'], 0.5)
|
||||
self.assertEqual(json_dict['rain_since_midnight'], 0.3)
|
||||
self.assertEqual(json_dict['humidity'], 65)
|
||||
self.assertEqual(json_dict['pressure'], 1013.25)
|
||||
self.assertEqual(json_dict['comment'], 'Test weather comment')
|
||||
|
||||
def test_weather_packet_from_dict(self):
|
||||
"""Test WeatherPacket.from_dict() method."""
|
||||
packet_dict = {
|
||||
'_type': 'WeatherPacket',
|
||||
'from_call': fake.FAKE_FROM_CALLSIGN,
|
||||
'to_call': fake.FAKE_TO_CALLSIGN,
|
||||
'latitude': 37.7749,
|
||||
'longitude': -122.4194,
|
||||
'symbol': '_',
|
||||
'symbol_table': '/',
|
||||
'wind_speed': 10.5,
|
||||
'wind_direction': 180,
|
||||
'wind_gust': 15.0,
|
||||
'temperature': 72.5,
|
||||
'rain_1h': 0.1,
|
||||
'rain_24h': 0.5,
|
||||
'rain_since_midnight': 0.3,
|
||||
'humidity': 65,
|
||||
'pressure': 1013.25,
|
||||
'comment': 'Test weather comment',
|
||||
}
|
||||
packet = packets.WeatherPacket.from_dict(packet_dict)
|
||||
self.assertIsInstance(packet, packets.WeatherPacket)
|
||||
self.assertEqual(packet.from_call, fake.FAKE_FROM_CALLSIGN)
|
||||
self.assertEqual(packet.to_call, fake.FAKE_TO_CALLSIGN)
|
||||
self.assertEqual(packet.latitude, 37.7749)
|
||||
self.assertEqual(packet.longitude, -122.4194)
|
||||
self.assertEqual(packet.symbol, '_')
|
||||
self.assertEqual(packet.wind_speed, 10.5)
|
||||
self.assertEqual(packet.wind_direction, 180)
|
||||
self.assertEqual(packet.wind_gust, 15.0)
|
||||
self.assertEqual(packet.temperature, 72.5)
|
||||
self.assertEqual(packet.rain_1h, 0.1)
|
||||
self.assertEqual(packet.rain_24h, 0.5)
|
||||
self.assertEqual(packet.rain_since_midnight, 0.3)
|
||||
self.assertEqual(packet.humidity, 65)
|
||||
self.assertEqual(packet.pressure, 1013.25)
|
||||
self.assertEqual(packet.comment, 'Test weather comment')
|
||||
|
||||
def test_weather_packet_round_trip(self):
|
||||
"""Test WeatherPacket round-trip: to_json -> from_dict."""
|
||||
original = packets.WeatherPacket(
|
||||
from_call=fake.FAKE_FROM_CALLSIGN,
|
||||
to_call=fake.FAKE_TO_CALLSIGN,
|
||||
latitude=37.7749,
|
||||
longitude=-122.4194,
|
||||
symbol='_',
|
||||
symbol_table='/',
|
||||
wind_speed=10.5,
|
||||
wind_direction=180,
|
||||
wind_gust=15.0,
|
||||
temperature=72.5,
|
||||
rain_1h=0.1,
|
||||
rain_24h=0.5,
|
||||
rain_since_midnight=0.3,
|
||||
humidity=65,
|
||||
pressure=1013.25,
|
||||
comment='Test weather comment',
|
||||
)
|
||||
json_str = original.to_json()
|
||||
packet_dict = json.loads(json_str)
|
||||
restored = packets.WeatherPacket.from_dict(packet_dict)
|
||||
self.assertEqual(restored.from_call, original.from_call)
|
||||
self.assertEqual(restored.to_call, original.to_call)
|
||||
self.assertEqual(restored.latitude, original.latitude)
|
||||
self.assertEqual(restored.longitude, original.longitude)
|
||||
self.assertEqual(restored.symbol, original.symbol)
|
||||
self.assertEqual(restored.wind_speed, original.wind_speed)
|
||||
self.assertEqual(restored.wind_direction, original.wind_direction)
|
||||
self.assertEqual(restored.wind_gust, original.wind_gust)
|
||||
self.assertEqual(restored.temperature, original.temperature)
|
||||
self.assertEqual(restored.rain_1h, original.rain_1h)
|
||||
self.assertEqual(restored.rain_24h, original.rain_24h)
|
||||
self.assertEqual(restored.rain_since_midnight, original.rain_since_midnight)
|
||||
self.assertEqual(restored.humidity, original.humidity)
|
||||
self.assertEqual(restored.pressure, original.pressure)
|
||||
self.assertEqual(restored.comment, original.comment)
|
||||
self.assertEqual(restored._type, original._type)
|
||||
|
||||
def test_weather_packet_from_raw_string(self):
|
||||
"""Test WeatherPacket creation from raw APRS string."""
|
||||
packet_raw = 'FW9222>APRS,TCPXX*,qAX,CWOP-6:@122025z2953.94N/08423.77W_232/003g006t084r000p032P000h80b10157L745.DsWLL'
|
||||
packet_dict = aprslib.parse(packet_raw)
|
||||
packet = packets.factory(packet_dict)
|
||||
self.assertIsInstance(packet, packets.WeatherPacket)
|
||||
# Test to_json
|
||||
json_str = packet.to_json()
|
||||
self.assertIsInstance(json_str, str)
|
||||
json_dict = json.loads(json_str)
|
||||
self.assertEqual(json_dict['_type'], 'WeatherPacket')
|
||||
# Test from_dict round trip
|
||||
restored = packets.factory(json_dict)
|
||||
self.assertIsInstance(restored, packets.WeatherPacket)
|
||||
self.assertEqual(restored.from_call, packet.from_call)
|
||||
self.assertEqual(restored.temperature, packet.temperature)
|
||||
self.assertEqual(restored.humidity, packet.humidity)
|
||||
self.assertEqual(restored.pressure, packet.pressure)
|
||||
self.assertEqual(restored.wind_speed, packet.wind_speed)
|
||||
self.assertEqual(restored.wind_direction, packet.wind_direction)
|
||||
Reference in New Issue
Block a user