mirror of
https://github.com/craigerl/aprsd.git
synced 2026-01-14 01:25:32 -05:00
386 lines
13 KiB
Python
386 lines
13 KiB
Python
import time
|
|
import unittest
|
|
from unittest import mock
|
|
|
|
from aprsd.packets import tracker
|
|
from aprsd.threads import tx
|
|
from tests import fake
|
|
from tests.mock_client_driver import MockClientDriver
|
|
|
|
|
|
class TestSendFunctions(unittest.TestCase):
|
|
"""Unit tests for send functions in tx module."""
|
|
|
|
def setUp(self):
|
|
"""Set up test fixtures."""
|
|
# Reset singleton instances
|
|
tracker.PacketTrack._instance = None
|
|
|
|
def tearDown(self):
|
|
"""Clean up after tests."""
|
|
tracker.PacketTrack._instance = None
|
|
|
|
@mock.patch('aprsd.threads.tx.collector.PacketCollector')
|
|
@mock.patch('aprsd.threads.tx._send_packet')
|
|
def test_send_message_packet(self, mock_send_packet, mock_collector):
|
|
"""Test send() with MessagePacket."""
|
|
from oslo_config import cfg
|
|
|
|
CONF = cfg.CONF
|
|
CONF.enable_sending_ack_packets = True
|
|
|
|
packet = fake.fake_packet()
|
|
tx.send(packet)
|
|
|
|
mock_collector.return_value.tx.assert_called()
|
|
mock_send_packet.assert_called()
|
|
|
|
@mock.patch('aprsd.threads.tx.collector.PacketCollector')
|
|
@mock.patch('aprsd.threads.tx._send_ack')
|
|
def test_send_ack_packet(self, mock_send_ack, mock_collector):
|
|
"""Test send() with AckPacket."""
|
|
from oslo_config import cfg
|
|
|
|
CONF = cfg.CONF
|
|
CONF.enable_sending_ack_packets = True
|
|
|
|
packet = fake.fake_ack_packet()
|
|
tx.send(packet)
|
|
|
|
mock_collector.return_value.tx.assert_called()
|
|
mock_send_ack.assert_called()
|
|
|
|
@mock.patch('aprsd.threads.tx.collector.PacketCollector')
|
|
@mock.patch('aprsd.threads.tx._send_ack')
|
|
def test_send_ack_disabled(self, mock_send_ack, mock_collector):
|
|
"""Test send() with AckPacket when acks are disabled."""
|
|
from oslo_config import cfg
|
|
|
|
CONF = cfg.CONF
|
|
CONF.enable_sending_ack_packets = False
|
|
|
|
packet = fake.fake_ack_packet()
|
|
|
|
with mock.patch('aprsd.threads.tx.LOG') as mock_log:
|
|
tx.send(packet)
|
|
mock_log.info.assert_called()
|
|
mock_send_ack.assert_not_called()
|
|
|
|
@mock.patch('aprsd.threads.tx.SendPacketThread')
|
|
def test_send_packet_threaded(self, mock_thread_class):
|
|
"""Test _send_packet() with threading."""
|
|
packet = fake.fake_packet()
|
|
mock_thread = mock.MagicMock()
|
|
mock_thread_class.return_value = mock_thread
|
|
|
|
tx._send_packet(packet, direct=False)
|
|
|
|
mock_thread_class.assert_called_with(packet=packet)
|
|
mock_thread.start.assert_called()
|
|
|
|
@mock.patch('aprsd.threads.tx._send_direct')
|
|
def test_send_packet_direct(self, mock_send_direct):
|
|
"""Test _send_packet() with direct send."""
|
|
packet = fake.fake_packet()
|
|
tx._send_packet(packet, direct=True)
|
|
mock_send_direct.assert_called_with(packet, aprs_client=None)
|
|
|
|
@mock.patch('aprsd.threads.tx.SendAckThread')
|
|
def test_send_ack_threaded(self, mock_thread_class):
|
|
"""Test _send_ack() with threading."""
|
|
packet = fake.fake_ack_packet()
|
|
mock_thread = mock.MagicMock()
|
|
mock_thread_class.return_value = mock_thread
|
|
|
|
tx._send_ack(packet, direct=False)
|
|
|
|
mock_thread_class.assert_called_with(packet=packet)
|
|
mock_thread.start.assert_called()
|
|
|
|
@mock.patch('aprsd.threads.tx._send_direct')
|
|
def test_send_ack_direct(self, mock_send_direct):
|
|
"""Test _send_ack() with direct send."""
|
|
packet = fake.fake_ack_packet()
|
|
tx._send_ack(packet, direct=True)
|
|
mock_send_direct.assert_called_with(packet, aprs_client=None)
|
|
|
|
@mock.patch('aprsd.threads.tx.APRSDClient')
|
|
@mock.patch('aprsd.threads.tx.packet_log')
|
|
def test_send_direct(self, mock_log, mock_client_class):
|
|
"""Test _send_direct() function."""
|
|
packet = fake.fake_packet()
|
|
mock_client = MockClientDriver()
|
|
mock_client._send_return = True
|
|
mock_client_class.return_value = mock_client
|
|
|
|
result = tx._send_direct(packet)
|
|
|
|
self.assertTrue(result)
|
|
mock_log.log.assert_called()
|
|
|
|
@mock.patch('aprsd.threads.tx.APRSDClient')
|
|
@mock.patch('aprsd.threads.tx.packet_log')
|
|
def test_send_direct_with_client(self, mock_log, mock_client_class):
|
|
"""Test _send_direct() with provided client."""
|
|
packet = fake.fake_packet()
|
|
mock_client = MockClientDriver()
|
|
mock_client._send_return = True
|
|
|
|
result = tx._send_direct(packet, aprs_client=mock_client)
|
|
|
|
self.assertTrue(result)
|
|
mock_client_class.assert_not_called()
|
|
|
|
@mock.patch('aprsd.threads.tx.APRSDClient')
|
|
@mock.patch('aprsd.threads.tx.packet_log')
|
|
def test_send_direct_exception(self, mock_log, mock_client_class):
|
|
"""Test _send_direct() with exception."""
|
|
packet = fake.fake_packet()
|
|
mock_client = MockClientDriver()
|
|
mock_client._send_side_effect = Exception('Send error')
|
|
mock_client_class.return_value = mock_client
|
|
|
|
with mock.patch('aprsd.threads.tx.LOG') as mock_log_error:
|
|
result = tx._send_direct(packet)
|
|
|
|
self.assertFalse(result)
|
|
mock_log_error.error.assert_called()
|
|
|
|
|
|
class TestSendPacketThread(unittest.TestCase):
|
|
"""Unit tests for the SendPacketThread class."""
|
|
|
|
def setUp(self):
|
|
"""Set up test fixtures."""
|
|
tracker.PacketTrack._instance = None
|
|
self.packet = fake.fake_packet(msg_number='123')
|
|
self.thread = tx.SendPacketThread(self.packet)
|
|
|
|
def tearDown(self):
|
|
"""Clean up after tests."""
|
|
self.thread.stop()
|
|
if self.thread.is_alive():
|
|
self.thread.join(timeout=1)
|
|
tracker.PacketTrack._instance = None
|
|
|
|
def test_init(self):
|
|
"""Test initialization."""
|
|
self.assertEqual(self.thread.packet, self.packet)
|
|
self.assertIn('TX-', self.thread.name)
|
|
self.assertEqual(self.thread.loop_count, 1)
|
|
|
|
@mock.patch('aprsd.threads.tx.tracker.PacketTrack')
|
|
def test_loop_packet_acked(self, mock_tracker_class):
|
|
"""Test loop() when packet is acked."""
|
|
mock_tracker = mock.MagicMock()
|
|
mock_tracker.get.return_value = None # Packet removed = acked
|
|
mock_tracker_class.return_value = mock_tracker
|
|
|
|
with mock.patch('aprsd.threads.tx.LOG') as mock_log:
|
|
result = self.thread.loop()
|
|
self.assertFalse(result)
|
|
mock_log.info.assert_called()
|
|
|
|
@mock.patch('aprsd.threads.tx.tracker.PacketTrack')
|
|
def test_loop_max_retries(self, mock_tracker_class):
|
|
"""Test loop() when max retries reached."""
|
|
mock_tracker = mock.MagicMock()
|
|
tracked_packet = fake.fake_packet(msg_number='123')
|
|
tracked_packet.send_count = 3
|
|
tracked_packet.retry_count = 3
|
|
mock_tracker.get.return_value = tracked_packet
|
|
mock_tracker_class.return_value = mock_tracker
|
|
|
|
with mock.patch('aprsd.threads.tx.LOG') as mock_log:
|
|
result = self.thread.loop()
|
|
self.assertFalse(result)
|
|
mock_log.info.assert_called()
|
|
mock_tracker.remove.assert_called()
|
|
|
|
@mock.patch('aprsd.threads.tx.tracker.PacketTrack')
|
|
@mock.patch('aprsd.threads.tx._send_direct')
|
|
def test_loop_send_now(self, mock_send_direct, mock_tracker_class):
|
|
"""Test loop() when it's time to send."""
|
|
mock_tracker = mock.MagicMock()
|
|
tracked_packet = fake.fake_packet(msg_number='123')
|
|
tracked_packet.send_count = 0
|
|
tracked_packet.retry_count = 3
|
|
tracked_packet.last_send_time = None
|
|
mock_tracker.get.return_value = tracked_packet
|
|
mock_tracker_class.return_value = mock_tracker
|
|
|
|
mock_send_direct.return_value = True
|
|
|
|
result = self.thread.loop()
|
|
|
|
self.assertTrue(result)
|
|
mock_send_direct.assert_called()
|
|
self.assertEqual(tracked_packet.send_count, 1)
|
|
|
|
@mock.patch('aprsd.threads.tx.tracker.PacketTrack')
|
|
@mock.patch('aprsd.threads.tx._send_direct')
|
|
def test_loop_send_failed(self, mock_send_direct, mock_tracker_class):
|
|
"""Test loop() when send fails."""
|
|
mock_tracker = mock.MagicMock()
|
|
tracked_packet = fake.fake_packet(msg_number='123')
|
|
tracked_packet.send_count = 0
|
|
tracked_packet.retry_count = 3
|
|
tracked_packet.last_send_time = None
|
|
mock_tracker.get.return_value = tracked_packet
|
|
mock_tracker_class.return_value = mock_tracker
|
|
|
|
mock_send_direct.return_value = False
|
|
|
|
result = self.thread.loop()
|
|
|
|
self.assertTrue(result)
|
|
self.assertEqual(
|
|
tracked_packet.send_count, 0
|
|
) # Should not increment on failure
|
|
|
|
|
|
class TestSendAckThread(unittest.TestCase):
|
|
"""Unit tests for the SendAckThread class."""
|
|
|
|
def setUp(self):
|
|
"""Set up test fixtures."""
|
|
from oslo_config import cfg
|
|
|
|
CONF = cfg.CONF
|
|
CONF.default_ack_send_count = 3
|
|
|
|
self.packet = fake.fake_ack_packet()
|
|
self.packet.send_count = 0
|
|
self.thread = tx.SendAckThread(self.packet)
|
|
|
|
def tearDown(self):
|
|
"""Clean up after tests."""
|
|
self.thread.stop()
|
|
if self.thread.is_alive():
|
|
self.thread.join(timeout=1)
|
|
|
|
def test_init(self):
|
|
"""Test initialization."""
|
|
self.assertEqual(self.thread.packet, self.packet)
|
|
self.assertIn('TXAck-', self.thread.name)
|
|
self.assertEqual(self.thread.max_retries, 3)
|
|
|
|
def test_loop_max_retries(self):
|
|
"""Test loop() when max retries reached."""
|
|
self.packet.send_count = 3
|
|
|
|
with mock.patch('aprsd.threads.tx.LOG') as mock_log:
|
|
result = self.thread.loop()
|
|
self.assertFalse(result)
|
|
mock_log.debug.assert_called()
|
|
|
|
@mock.patch('aprsd.threads.tx._send_direct')
|
|
def test_loop_send_now(self, mock_send_direct):
|
|
"""Test loop() when it's time to send."""
|
|
self.packet.last_send_time = None
|
|
mock_send_direct.return_value = True
|
|
|
|
result = self.thread.loop()
|
|
|
|
self.assertTrue(result)
|
|
mock_send_direct.assert_called()
|
|
self.assertEqual(self.packet.send_count, 1)
|
|
|
|
@mock.patch('aprsd.threads.tx._send_direct')
|
|
def test_loop_waiting(self, mock_send_direct):
|
|
"""Test loop() when waiting for next send."""
|
|
self.packet.last_send_time = int(time.time()) - 10 # Too soon
|
|
mock_send_direct.return_value = True
|
|
|
|
result = self.thread.loop()
|
|
|
|
self.assertTrue(result)
|
|
mock_send_direct.assert_not_called()
|
|
|
|
|
|
class TestBeaconSendThread(unittest.TestCase):
|
|
"""Unit tests for the BeaconSendThread class."""
|
|
|
|
def setUp(self):
|
|
"""Set up test fixtures."""
|
|
from oslo_config import cfg
|
|
|
|
CONF = cfg.CONF
|
|
CONF.latitude = 40.7128
|
|
CONF.longitude = -74.0060
|
|
CONF.beacon_interval = 10
|
|
CONF.beacon_symbol = '>'
|
|
CONF.callsign = 'TEST'
|
|
|
|
def tearDown(self):
|
|
"""Clean up after tests."""
|
|
pass
|
|
|
|
def test_init(self):
|
|
"""Test initialization."""
|
|
thread = tx.BeaconSendThread()
|
|
self.assertEqual(thread.name, 'BeaconSendThread')
|
|
self.assertEqual(thread._loop_cnt, 1)
|
|
|
|
def test_init_no_coordinates(self):
|
|
"""Test initialization without coordinates."""
|
|
from oslo_config import cfg
|
|
|
|
CONF = cfg.CONF
|
|
CONF.latitude = None
|
|
CONF.longitude = None
|
|
|
|
thread = tx.BeaconSendThread()
|
|
self.assertTrue(thread.thread_stop)
|
|
|
|
@mock.patch('aprsd.threads.tx.send')
|
|
def test_loop_send_beacon(self, mock_send):
|
|
"""Test loop() sends beacon at interval."""
|
|
from oslo_config import cfg
|
|
|
|
CONF = cfg.CONF
|
|
CONF.beacon_interval = 1
|
|
|
|
thread = tx.BeaconSendThread()
|
|
thread._loop_cnt = 1
|
|
|
|
result = thread.loop()
|
|
|
|
self.assertTrue(result)
|
|
mock_send.assert_called()
|
|
|
|
@mock.patch('aprsd.threads.tx.send')
|
|
def test_loop_not_time(self, mock_send):
|
|
"""Test loop() doesn't send before interval."""
|
|
from oslo_config import cfg
|
|
|
|
CONF = cfg.CONF
|
|
CONF.beacon_interval = 10
|
|
|
|
thread = tx.BeaconSendThread()
|
|
thread._loop_cnt = 5
|
|
|
|
result = thread.loop()
|
|
|
|
self.assertTrue(result)
|
|
mock_send.assert_not_called()
|
|
|
|
@mock.patch('aprsd.threads.tx.send')
|
|
@mock.patch('aprsd.threads.tx.APRSDClient')
|
|
def test_loop_send_exception(self, mock_client_class, mock_send):
|
|
"""Test loop() handles send exception."""
|
|
from oslo_config import cfg
|
|
|
|
CONF = cfg.CONF
|
|
CONF.beacon_interval = 1
|
|
|
|
thread = tx.BeaconSendThread()
|
|
thread._loop_cnt = 1
|
|
mock_send.side_effect = Exception('Send error')
|
|
|
|
with mock.patch('aprsd.threads.tx.LOG') as mock_log:
|
|
result = thread.loop()
|
|
self.assertTrue(result)
|
|
mock_log.error.assert_called()
|
|
mock_client_class.return_value.reset.assert_called()
|