hemna/aprsd
1
0
Fork 0
mirror of https://github.com/craigerl/aprsd.git synced 2026-06-08 09:04:49 -04:00
Code Issues Projects Releases Wiki Activity

Added unit tests for packets.

Browse Source 
Also did some code cleanup.
This commit is contained in:
Walter Boring
2026-01-05 16:51:54 -05:00
parent f9979fa3da
commit 1da92e52ef
48 changed files with 1791 additions and 445 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/cmds/test_send_message.py
+9 -9
View File
@@ -12,7 +12,7 @@ from aprsd.main import cli
from .. import fake
CONF = cfg.CONF
F = t.TypeVar("F", bound=t.Callable[..., t.Any])
F = t.TypeVar('F', bound=t.Callable[..., t.Any])
class TestSendMessageCommand(unittest.TestCase):
@@ -28,37 +28,37 @@ class TestSendMessageCommand(unittest.TestCase):
# CONF.aprsd_admin_extension.user = "admin"
# CONF.aprsd_admin_extension.password = "password"
@mock.patch("aprsd.log.log.setup_logging")
@mock.patch('aprsd.log.log.setup_logging')
def test_no_tocallsign(self, mock_logging):
"""Make sure we get an error if there is no tocallsign."""
self.config_and_init(
login="something",
password="another",
login='something',
password='another',
)
runner = CliRunner()
result = runner.invoke(
cli,
["send-message"],
['send-message'],
catch_exceptions=False,
)
assert result.exit_code == 2
assert "Error: Missing argument 'TOCALLSIGN'" in result.output
@mock.patch("aprsd.log.log.setup_logging")
@mock.patch('aprsd.log.log.setup_logging')
def test_no_command(self, mock_logging):
"""Make sure we get an error if there is no command."""
self.config_and_init(
login="something",
password="another",
login='something',
password='another',
)
runner = CliRunner()
result = runner.invoke(
cli,
["send-message", "WB4BOR"],
['send-message', 'WB4BOR'],
catch_exceptions=False,
)
assert result.exit_code == 2
tests/fake.py
+19 -19
View File
@@ -1,9 +1,9 @@
from aprsd import plugin, threads
from aprsd.packets import core
FAKE_MESSAGE_TEXT = "fake MeSSage"
FAKE_FROM_CALLSIGN = "KFAKE"
FAKE_TO_CALLSIGN = "KMINE"
FAKE_MESSAGE_TEXT = 'fake MeSSage'
FAKE_FROM_CALLSIGN = 'KFAKE'
FAKE_TO_CALLSIGN = 'KMINE'
def fake_packet(
@@ -15,20 +15,20 @@ def fake_packet(
response=None,
):
packet_dict = {
"from": fromcall,
"addresse": tocall,
"to": tocall,
"format": message_format,
"raw": "",
'from': fromcall,
'addresse': tocall,
'to': tocall,
'format': message_format,
'raw': '',
}
if message:
packet_dict["message_text"] = message
packet_dict['message_text'] = message
if msg_number:
packet_dict["msgNo"] = str(msg_number)
packet_dict['msgNo'] = str(msg_number)
if response:
packet_dict["response"] = response
packet_dict['response'] = response
return core.factory(packet_dict)
@@ -41,7 +41,7 @@ def fake_ack_packet():
class FakeBaseNoThreadsPlugin(plugin.APRSDPluginBase):
version = "1.0"
version = '1.0'
def setup(self):
self.enabled = True
@@ -50,19 +50,19 @@ class FakeBaseNoThreadsPlugin(plugin.APRSDPluginBase):
return None
def process(self, packet):
return "process"
return 'process'
class FakeThread(threads.APRSDThread):
def __init__(self):
super().__init__("FakeThread")
super().__init__('FakeThread')
def loop(self):
return False
class FakeBaseThreadsPlugin(plugin.APRSDPluginBase):
version = "1.0"
version = '1.0'
def setup(self):
self.enabled = True
@@ -71,16 +71,16 @@ class FakeBaseThreadsPlugin(plugin.APRSDPluginBase):
return None
def process(self, packet):
return "process"
return 'process'
def create_threads(self):
return FakeThread()
class FakeRegexCommandPlugin(plugin.APRSDRegexCommandPluginBase):
version = "1.0"
command_regex = "^[fF]"
command_name = "fake"
version = '1.0'
command_regex = '^[fF]'
command_name = 'fake'
def process(self, packet):
return FAKE_MESSAGE_TEXT
tests/packets/test_ack_packet.py
+76
View File
@@ -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)
tests/packets/test_beacon_packet.py
+98
View File
@@ -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)
tests/packets/test_bulletin_packet.py
+75
View File
@@ -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)
tests/packets/test_gps_packet.py
+109
View File
@@ -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)
tests/packets/test_message_packet.py
+80
View File
@@ -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)
tests/packets/test_mice_packet.py
+107
View File
@@ -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)
tests/packets/test_object_packet.py
+122
View File
@@ -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)
tests/packets/test_packet.py
+75
View File
@@ -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)
tests/packets/test_reject_packet.py
+76
View File
@@ -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)
tests/packets/test_status_packet.py
+93
View File
@@ -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)
tests/packets/test_telemetry_packet.py
+115
View File
@@ -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)
tests/packets/test_thirdparty_packet.py
+99
View File
@@ -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)
tests/packets/test_unknown_packet.py
+82
View File
@@ -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)
tests/packets/test_weather_packet.py
+151
View File
@@ -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)
tests/plugins/test_fortune.py
+8 -9
View File
@@ -7,29 +7,28 @@ from aprsd.plugins import fortune as fortune_plugin
from .. import fake, test_plugin
CONF = cfg.CONF
class TestFortunePlugin(test_plugin.TestPlugin):
@mock.patch("shutil.which")
@mock.patch('shutil.which')
def test_fortune_fail(self, mock_which):
mock_which.return_value = None
fortune = fortune_plugin.FortunePlugin()
expected = "FortunePlugin isn't enabled"
packet = fake.fake_packet(message="fortune")
packet = fake.fake_packet(message='fortune')
actual = fortune.filter(packet)
self.assertEqual(expected, actual)
@mock.patch("subprocess.check_output")
@mock.patch("shutil.which")
@mock.patch('subprocess.check_output')
@mock.patch('shutil.which')
def test_fortune_success(self, mock_which, mock_output):
mock_which.return_value = "/usr/bin/games/fortune"
mock_output.return_value = "Funny fortune"
mock_which.return_value = '/usr/bin/games/fortune'
mock_output.return_value = 'Funny fortune'
CONF.callsign = fake.FAKE_TO_CALLSIGN
fortune = fortune_plugin.FortunePlugin()
expected = "Funny fortune"
packet = fake.fake_packet(message="fortune")
expected = 'Funny fortune'
packet = fake.fake_packet(message='fortune')
actual = fortune.filter(packet)
self.assertEqual(expected, actual)
tests/plugins/test_ping.py
+7 -8
View File
@@ -7,12 +7,11 @@ from aprsd.plugins import ping as ping_plugin
from .. import fake, test_plugin
CONF = cfg.CONF
class TestPingPlugin(test_plugin.TestPlugin):
@mock.patch("time.localtime")
@mock.patch('time.localtime')
def test_ping(self, mock_time):
fake_time = mock.MagicMock()
h = fake_time.tm_hour = 16
@@ -24,7 +23,7 @@ class TestPingPlugin(test_plugin.TestPlugin):
ping = ping_plugin.PingPlugin()
packet = fake.fake_packet(
message="location",
message='location',
msg_number=1,
)
@@ -33,16 +32,16 @@ class TestPingPlugin(test_plugin.TestPlugin):
def ping_str(h, m, s):
return (
"Pong! "
'Pong! '
+ str(h).zfill(2)
+ ":"
+ ':'
+ str(m).zfill(2)
+ ":"
+ ':'
+ str(s).zfill(2)
)
packet = fake.fake_packet(
message="Ping",
message='Ping',
msg_number=1,
)
actual = ping.filter(packet)
@@ -50,7 +49,7 @@ class TestPingPlugin(test_plugin.TestPlugin):
self.assertEqual(expected, actual)
packet = fake.fake_packet(
message="ping",
message='ping',
msg_number=1,
)
actual = ping.filter(packet)
tests/plugins/test_time.py
+9 -9
View File
@@ -12,26 +12,26 @@ CONF = cfg.CONF
class TestTimePlugins(test_plugin.TestPlugin):
@mock.patch("aprsd.plugins.time.TimePlugin._get_local_tz")
@mock.patch("aprsd.plugins.time.TimePlugin._get_utcnow")
@mock.patch('aprsd.plugins.time.TimePlugin._get_local_tz')
@mock.patch('aprsd.plugins.time.TimePlugin._get_utcnow')
def test_time(self, mock_utcnow, mock_localtz):
utcnow = pytz.datetime.datetime.utcnow()
mock_utcnow.return_value = utcnow
tz = pytz.timezone("US/Pacific")
tz = pytz.timezone('US/Pacific')
mock_localtz.return_value = tz
gmt_t = pytz.utc.localize(utcnow)
local_t = gmt_t.astimezone(tz)
fake_time = mock.MagicMock()
h = int(local_t.strftime("%H"))
m = int(local_t.strftime("%M"))
h = int(local_t.strftime('%H'))
m = int(local_t.strftime('%M'))
fake_time.tm_sec = 13
CONF.callsign = fake.FAKE_TO_CALLSIGN
time = time_plugin.TimePlugin()
packet = fake.fake_packet(
message="location",
message='location',
msg_number=1,
)
@@ -41,11 +41,11 @@ class TestTimePlugins(test_plugin.TestPlugin):
cur_time = fuzzy(h, m, 1)
packet = fake.fake_packet(
message="time",
message='time',
msg_number=1,
)
local_short_str = local_t.strftime("%H:%M %Z")
expected = "{} ({})".format(
local_short_str = local_t.strftime('%H:%M %Z')
expected = '{} ({})'.format(
cur_time,
local_short_str,
)
tests/plugins/test_weather.py
+62 -62
View File
@@ -18,89 +18,89 @@ class TestUSWeatherPlugin(test_plugin.TestPlugin):
CONF.callsign = fake.FAKE_TO_CALLSIGN
wx = weather_plugin.USWeatherPlugin()
expected = "USWeatherPlugin isn't enabled"
packet = fake.fake_packet(message="weather")
packet = fake.fake_packet(message='weather')
actual = wx.filter(packet)
self.assertEqual(expected, actual)
@mock.patch("aprsd.plugin_utils.get_aprs_fi")
@mock.patch('aprsd.plugin_utils.get_aprs_fi')
def test_failed_aprs_fi_location(self, mock_check):
# When the aprs.fi api key isn't set, then
# the Plugin will be disabled.
mock_check.side_effect = Exception
CONF.aprs_fi.apiKey = "abc123"
CONF.aprs_fi.apiKey = 'abc123'
CONF.callsign = fake.FAKE_TO_CALLSIGN
wx = weather_plugin.USWeatherPlugin()
expected = "Failed to fetch aprs.fi location"
packet = fake.fake_packet(message="weather")
expected = 'Failed to fetch aprs.fi location'
packet = fake.fake_packet(message='weather')
actual = wx.filter(packet)
self.assertEqual(expected, actual)
@mock.patch("aprsd.plugin_utils.get_aprs_fi")
@mock.patch('aprsd.plugin_utils.get_aprs_fi')
def test_failed_aprs_fi_location_no_entries(self, mock_check):
# When the aprs.fi api key isn't set, then
# the Plugin will be disabled.
mock_check.return_value = {"entries": []}
CONF.aprs_fi.apiKey = "abc123"
mock_check.return_value = {'entries': []}
CONF.aprs_fi.apiKey = 'abc123'
CONF.callsign = fake.FAKE_TO_CALLSIGN
wx = weather_plugin.USWeatherPlugin()
wx.enabled = True
expected = "Failed to fetch aprs.fi location"
packet = fake.fake_packet(message="weather")
expected = 'Failed to fetch aprs.fi location'
packet = fake.fake_packet(message='weather')
actual = wx.filter(packet)
self.assertEqual(expected, actual)
@mock.patch("aprsd.plugin_utils.get_aprs_fi")
@mock.patch("aprsd.plugin_utils.get_weather_gov_for_gps")
@mock.patch('aprsd.plugin_utils.get_aprs_fi')
@mock.patch('aprsd.plugin_utils.get_weather_gov_for_gps')
def test_unknown_gps(self, mock_weather, mock_check_aprs):
# When the aprs.fi api key isn't set, then
# the LocationPlugin will be disabled.
mock_check_aprs.return_value = {
"entries": [
'entries': [
{
"lat": 10,
"lng": 11,
"lasttime": 10,
'lat': 10,
'lng': 11,
'lasttime': 10,
},
],
}
mock_weather.side_effect = Exception
CONF.aprs_fi.apiKey = "abc123"
CONF.aprs_fi.apiKey = 'abc123'
CONF.callsign = fake.FAKE_TO_CALLSIGN
wx = weather_plugin.USWeatherPlugin()
wx.enabled = True
expected = "Unable to get weather"
packet = fake.fake_packet(message="weather")
expected = 'Unable to get weather'
packet = fake.fake_packet(message='weather')
actual = wx.filter(packet)
self.assertEqual(expected, actual)
@mock.patch("aprsd.plugin_utils.get_aprs_fi")
@mock.patch("aprsd.plugin_utils.get_weather_gov_for_gps")
@mock.patch('aprsd.plugin_utils.get_aprs_fi')
@mock.patch('aprsd.plugin_utils.get_weather_gov_for_gps')
def test_working(self, mock_weather, mock_check_aprs):
# When the aprs.fi api key isn't set, then
# the LocationPlugin will be disabled.
mock_check_aprs.return_value = {
"entries": [
'entries': [
{
"lat": 10,
"lng": 11,
"lasttime": 10,
'lat': 10,
'lng': 11,
'lasttime': 10,
},
],
}
mock_weather.return_value = {
"currentobservation": {"Temp": "400"},
"data": {
"temperature": ["10", "11"],
"weather": ["test", "another"],
'currentobservation': {'Temp': '400'},
'data': {
'temperature': ['10', '11'],
'weather': ['test', 'another'],
},
"time": {"startPeriodName": ["ignored", "sometime"]},
'time': {'startPeriodName': ['ignored', 'sometime']},
}
CONF.aprs_fi.apiKey = "abc123"
CONF.aprs_fi.apiKey = 'abc123'
CONF.callsign = fake.FAKE_TO_CALLSIGN
wx = weather_plugin.USWeatherPlugin()
wx.enabled = True
expected = "400F(10F/11F) test. sometime, another."
packet = fake.fake_packet(message="weather")
expected = '400F(10F/11F) test. sometime, another.'
packet = fake.fake_packet(message='weather')
actual = wx.filter(packet)
self.assertEqual(expected, actual)
@@ -112,93 +112,93 @@ class TestUSMetarPlugin(test_plugin.TestPlugin):
CONF.aprs_fi.apiKey = None
wx = weather_plugin.USMetarPlugin()
expected = "USMetarPlugin isn't enabled"
packet = fake.fake_packet(message="metar")
packet = fake.fake_packet(message='metar')
actual = wx.filter(packet)
self.assertEqual(expected, actual)
@mock.patch("aprsd.plugin_utils.get_aprs_fi")
@mock.patch('aprsd.plugin_utils.get_aprs_fi')
def test_failed_aprs_fi_location(self, mock_check):
# When the aprs.fi api key isn't set, then
# the Plugin will be disabled.
mock_check.side_effect = Exception
CONF.aprs_fi.apiKey = "abc123"
CONF.aprs_fi.apiKey = 'abc123'
CONF.callsign = fake.FAKE_TO_CALLSIGN
wx = weather_plugin.USMetarPlugin()
wx.enabled = True
expected = "Failed to fetch aprs.fi location"
packet = fake.fake_packet(message="metar")
expected = 'Failed to fetch aprs.fi location'
packet = fake.fake_packet(message='metar')
actual = wx.filter(packet)
self.assertEqual(expected, actual)
@mock.patch("aprsd.plugin_utils.get_aprs_fi")
@mock.patch('aprsd.plugin_utils.get_aprs_fi')
def test_failed_aprs_fi_location_no_entries(self, mock_check):
# When the aprs.fi api key isn't set, then
# the Plugin will be disabled.
mock_check.return_value = {"entries": []}
CONF.aprs_fi.apiKey = "abc123"
mock_check.return_value = {'entries': []}
CONF.aprs_fi.apiKey = 'abc123'
CONF.callsign = fake.FAKE_TO_CALLSIGN
wx = weather_plugin.USMetarPlugin()
wx.enabled = True
expected = "Failed to fetch aprs.fi location"
packet = fake.fake_packet(message="metar")
expected = 'Failed to fetch aprs.fi location'
packet = fake.fake_packet(message='metar')
actual = wx.filter(packet)
self.assertEqual(expected, actual)
@mock.patch("aprsd.plugin_utils.get_weather_gov_metar")
@mock.patch('aprsd.plugin_utils.get_weather_gov_metar')
def test_gov_metar_fetch_fails(self, mock_metar):
mock_metar.side_effect = Exception
CONF.aprs_fi.apiKey = "abc123"
CONF.aprs_fi.apiKey = 'abc123'
CONF.callsign = fake.FAKE_TO_CALLSIGN
wx = weather_plugin.USMetarPlugin()
wx.enabled = True
expected = "Unable to find station METAR"
packet = fake.fake_packet(message="metar KPAO")
expected = 'Unable to find station METAR'
packet = fake.fake_packet(message='metar KPAO')
actual = wx.filter(packet)
self.assertEqual(expected, actual)
@mock.patch("aprsd.plugin_utils.get_weather_gov_metar")
@mock.patch('aprsd.plugin_utils.get_weather_gov_metar')
def test_airport_works(self, mock_metar):
class Response:
text = '{"properties": {"rawMessage": "BOGUSMETAR"}}'
mock_metar.return_value = Response()
CONF.aprs_fi.apiKey = "abc123"
CONF.aprs_fi.apiKey = 'abc123'
CONF.callsign = fake.FAKE_TO_CALLSIGN
wx = weather_plugin.USMetarPlugin()
wx.enabled = True
expected = "BOGUSMETAR"
packet = fake.fake_packet(message="metar KPAO")
expected = 'BOGUSMETAR'
packet = fake.fake_packet(message='metar KPAO')
actual = wx.filter(packet)
self.assertEqual(expected, actual)
@mock.patch("aprsd.plugin_utils.get_weather_gov_metar")
@mock.patch("aprsd.plugin_utils.get_aprs_fi")
@mock.patch("aprsd.plugin_utils.get_weather_gov_for_gps")
@mock.patch('aprsd.plugin_utils.get_weather_gov_metar')
@mock.patch('aprsd.plugin_utils.get_aprs_fi')
@mock.patch('aprsd.plugin_utils.get_weather_gov_for_gps')
def test_metar_works(self, mock_wx_for_gps, mock_check_aprs, mock_metar):
mock_wx_for_gps.return_value = {
"location": {"metar": "BOGUSMETAR"},
'location': {'metar': 'BOGUSMETAR'},
}
class Response:
text = '{"properties": {"rawMessage": "BOGUSMETAR"}}'
mock_check_aprs.return_value = {
"entries": [
'entries': [
{
"lat": 10,
"lng": 11,
"lasttime": 10,
'lat': 10,
'lng': 11,
'lasttime': 10,
},
],
}
mock_metar.return_value = Response()
CONF.aprs_fi.apiKey = "abc123"
CONF.aprs_fi.apiKey = 'abc123'
CONF.callsign = fake.FAKE_TO_CALLSIGN
wx = weather_plugin.USMetarPlugin()
wx.enabled = True
expected = "BOGUSMETAR"
packet = fake.fake_packet(message="metar")
expected = 'BOGUSMETAR'
packet = fake.fake_packet(message='metar')
actual = wx.filter(packet)
self.assertEqual(expected, actual)
tests/test_packets.py
+50 -50
View File
@@ -20,18 +20,18 @@ class TestPacketBase(unittest.TestCase):
message_format=core.PACKET_TYPE_MESSAGE,
):
packet_dict = {
"from": from_call,
"addresse": to_call,
"to": to_call,
"format": message_format,
"raw": "",
'from': from_call,
'addresse': to_call,
'to': to_call,
'format': message_format,
'raw': '',
}
if message:
packet_dict["message_text"] = message
packet_dict['message_text'] = message
if msg_number:
packet_dict["msgNo"] = str(msg_number)
packet_dict['msgNo'] = str(msg_number)
return packet_dict
@@ -52,7 +52,7 @@ class TestPacketBase(unittest.TestCase):
self.assertEqual(
fake.FAKE_FROM_CALLSIGN,
pkt.get("from_call"),
pkt.get('from_call'),
)
def test_packet_factory(self):
@@ -64,21 +64,21 @@ class TestPacketBase(unittest.TestCase):
self.assertEqual(fake.FAKE_TO_CALLSIGN, pkt.to_call)
self.assertEqual(fake.FAKE_TO_CALLSIGN, pkt.addresse)
pkt_dict["symbol"] = "_"
pkt_dict["weather"] = {
"wind_gust": 1.11,
"temperature": 32.01,
"humidity": 85,
"pressure": 1095.12,
"comment": "Home!",
pkt_dict['symbol'] = '_'
pkt_dict['weather'] = {
'wind_gust': 1.11,
'temperature': 32.01,
'humidity': 85,
'pressure': 1095.12,
'comment': 'Home!',
}
pkt_dict["format"] = core.PACKET_TYPE_UNCOMPRESSED
pkt_dict['format'] = core.PACKET_TYPE_UNCOMPRESSED
pkt = packets.factory(pkt_dict)
self.assertIsInstance(pkt, packets.WeatherPacket)
@mock.patch("aprsd.packets.core.GPSPacket._build_time_zulu")
@mock.patch('aprsd.packets.core.GPSPacket._build_time_zulu')
def test_packet_format_rain_1h(self, mock_time_zulu):
mock_time_zulu.return_value = "221450"
mock_time_zulu.return_value = '221450'
wx = packets.WeatherPacket(
from_call=fake.FAKE_FROM_CALLSIGN,
@@ -87,58 +87,58 @@ class TestPacketBase(unittest.TestCase):
)
wx.prepare()
expected = "KFAKE>KMINE,WIDE1-1,WIDE2-1:@221450z0.0/0.0_000/000g000t000r000p000P000h00b00000"
expected = 'KFAKE>KMINE,WIDE1-1,WIDE2-1:@221450z0.0/0.0_000/000g000t000r000p000P000h00b00000'
self.assertEqual(expected, wx.raw)
rain_location = 59
self.assertEqual(rain_location, wx.raw.find("r000"))
self.assertEqual(rain_location, wx.raw.find('r000'))
wx.rain_1h = 1.11
wx.prepare()
expected = "KFAKE>KMINE,WIDE1-1,WIDE2-1:@221450z0.0/0.0_000/000g000t000r111p000P000h00b00000"
expected = 'KFAKE>KMINE,WIDE1-1,WIDE2-1:@221450z0.0/0.0_000/000g000t000r111p000P000h00b00000'
self.assertEqual(expected, wx.raw)
wx.rain_1h = 0.01
wx.prepare()
expected = "KFAKE>KMINE,WIDE1-1,WIDE2-1:@221450z0.0/0.0_000/000g000t000r001p000P000h00b00000"
expected = 'KFAKE>KMINE,WIDE1-1,WIDE2-1:@221450z0.0/0.0_000/000g000t000r001p000P000h00b00000'
self.assertEqual(expected, wx.raw)
def test_beacon_factory(self):
"""Test to ensure a beacon packet is created."""
packet_raw = (
"WB4BOR-12>APZ100,WIDE2-1:@161647z3724.15N107847.58W$ APRSD WebChat"
'WB4BOR-12>APZ100,WIDE2-1:@161647z3724.15N107847.58W$ APRSD WebChat'
)
packet_dict = aprslib.parse(packet_raw)
packet = packets.factory(packet_dict)
self.assertIsInstance(packet, packets.BeaconPacket)
packet_raw = "kd8mey-10>APRS,TCPIP*,qAC,T2SYDNEY:=4247.80N/08539.00WrPHG1210/Making 220 Great Again Allstar# 552191"
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)
def test_reject_factory(self):
"""Test to ensure a reject packet is created."""
packet_raw = "HB9FDL-1>APK102,HB9FM-4*,WIDE2,qAR,HB9FEF-11::REPEAT :rej4139"
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)
self.assertEqual("4139", packet.msgNo)
self.assertEqual("HB9FDL-1", packet.from_call)
self.assertEqual("REPEAT", packet.to_call)
self.assertEqual("reject", packet.packet_type)
self.assertEqual('4139', packet.msgNo)
self.assertEqual('HB9FDL-1', packet.from_call)
self.assertEqual('REPEAT', packet.to_call)
self.assertEqual('reject', packet.packet_type)
self.assertIsNone(packet.payload)
def test_thirdparty_factory(self):
"""Test to ensure a third party packet is created."""
packet_raw = "GTOWN>APDW16,WIDE1-1,WIDE2-1:}KM6LYW-9>APZ100,TCPIP,GTOWN*::KM6LYW :KM6LYW: 19 Miles SW"
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)
def test_weather_factory(self):
"""Test to ensure a weather packet is created."""
packet_raw = "FW9222>APRS,TCPXX*,qAX,CWOP-6:@122025z2953.94N/08423.77W_232/003g006t084r000p032P000h80b10157L745.DsWLL"
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)
@@ -178,7 +178,7 @@ class TestPacketBase(unittest.TestCase):
)
expected = (
f"{fake.FAKE_FROM_CALLSIGN}>APZ100::{fake.FAKE_TO_CALLSIGN:<9}:ack123"
f'{fake.FAKE_FROM_CALLSIGN}>APZ100::{fake.FAKE_TO_CALLSIGN:<9}:ack123'
)
self.assertEqual(expected, str(ack))
@@ -191,7 +191,7 @@ class TestPacketBase(unittest.TestCase):
)
expected = (
f"{fake.FAKE_FROM_CALLSIGN}>APZ100::{fake.FAKE_TO_CALLSIGN:<9}:rej123"
f'{fake.FAKE_FROM_CALLSIGN}>APZ100::{fake.FAKE_TO_CALLSIGN:<9}:rej123'
)
self.assertEqual(expected, str(reject))
@@ -200,20 +200,20 @@ class TestPacketBase(unittest.TestCase):
lat = 28.123456
lon = -80.123456
ts = 1711219496.6426
comment = "My Beacon Comment"
comment = 'My Beacon Comment'
packet = packets.BeaconPacket(
from_call=fake.FAKE_FROM_CALLSIGN,
to_call=fake.FAKE_TO_CALLSIGN,
latitude=lat,
longitude=lon,
timestamp=ts,
symbol=">",
symbol='>',
comment=comment,
)
expected_lat = aprslib_util.latitude_to_ddm(lat)
expected_lon = aprslib_util.longitude_to_ddm(lon)
expected = f"KFAKE>APZ100:@231844z{expected_lat}/{expected_lon}>{comment}"
expected = f'KFAKE>APZ100:@231844z{expected_lat}/{expected_lon}>{comment}'
self.assertEqual(expected, str(packet))
def test_beacon_format_no_comment(self):
@@ -227,13 +227,13 @@ class TestPacketBase(unittest.TestCase):
latitude=lat,
longitude=lon,
timestamp=ts,
symbol=">",
symbol='>',
)
empty_comment = "APRSD Beacon"
empty_comment = 'APRSD Beacon'
expected_lat = aprslib_util.latitude_to_ddm(lat)
expected_lon = aprslib_util.longitude_to_ddm(lon)
expected = f"KFAKE>APZ100:@231844z{expected_lat}/{expected_lon}>{empty_comment}"
expected = f'KFAKE>APZ100:@231844z{expected_lat}/{expected_lon}>{empty_comment}'
self.assertEqual(expected, str(packet))
def test_bulletin_format(self):
@@ -242,32 +242,32 @@ class TestPacketBase(unittest.TestCase):
bid = 0
packet = packets.BulletinPacket(
from_call=fake.FAKE_FROM_CALLSIGN,
message_text="My Bulletin Message",
message_text='My Bulletin Message',
bid=0,
)
expected = (
f"{fake.FAKE_FROM_CALLSIGN}>APZ100::BLN{bid:<9}:{packet.message_text}"
f'{fake.FAKE_FROM_CALLSIGN}>APZ100::BLN{bid:<9}:{packet.message_text}'
)
self.assertEqual(expected, str(packet))
# bulletin id = 1
bid = 1
txt = "((((((( CX2SA - Salto Uruguay ))))))) http://www.cx2sa.org"
txt = '((((((( CX2SA - Salto Uruguay ))))))) http://www.cx2sa.org'
packet = packets.BulletinPacket(
from_call=fake.FAKE_FROM_CALLSIGN,
message_text=txt,
bid=1,
)
expected = f"{fake.FAKE_FROM_CALLSIGN}>APZ100::BLN{bid:<9}:{txt}"
expected = f'{fake.FAKE_FROM_CALLSIGN}>APZ100::BLN{bid:<9}:{txt}'
self.assertEqual(expected, str(packet))
def test_message_format(self):
"""Test the message packet format."""
message = "My Message"
msgno = "ABX"
message = 'My Message'
msgno = 'ABX'
packet = packets.MessagePacket(
from_call=fake.FAKE_FROM_CALLSIGN,
to_call=fake.FAKE_TO_CALLSIGN,
@@ -275,19 +275,19 @@ class TestPacketBase(unittest.TestCase):
msgNo=msgno,
)
expected = f"{fake.FAKE_FROM_CALLSIGN}>APZ100::{fake.FAKE_TO_CALLSIGN:<9}:{message}{{{msgno}"
expected = f'{fake.FAKE_FROM_CALLSIGN}>APZ100::{fake.FAKE_TO_CALLSIGN:<9}:{message}{{{msgno}'
self.assertEqual(expected, str(packet))
# test with bad words
# Currently fails with mixed case
message = "My cunt piss fuck shIt text"
exp_msg = "My **** **** **** **** text"
msgno = "ABX"
message = 'My cunt piss fuck shIt text'
exp_msg = 'My **** **** **** **** text'
msgno = 'ABX'
packet = packets.MessagePacket(
from_call=fake.FAKE_FROM_CALLSIGN,
to_call=fake.FAKE_TO_CALLSIGN,
message_text=message,
msgNo=msgno,
)
expected = f"{fake.FAKE_FROM_CALLSIGN}>APZ100::{fake.FAKE_TO_CALLSIGN:<9}:{exp_msg}{{{msgno}"
expected = f'{fake.FAKE_FROM_CALLSIGN}>APZ100::{fake.FAKE_TO_CALLSIGN:<9}:{exp_msg}{{{msgno}'
self.assertEqual(expected, str(packet))