added more unit tests

tests/utils/test_ring_buffer_additional.py

@@ -0,0 +1,172 @@
+import unittest
+
+from aprsd.utils.ring_buffer import RingBuffer
+
+
+class TestRingBufferAdditional(unittest.TestCase):
+    """Additional unit tests for the RingBuffer class to cover edge cases."""
+
+    def test_empty_buffer(self):
+        """Test behavior with empty buffer."""
+        rb = RingBuffer(5)
+        self.assertEqual(len(rb), 0)
+        self.assertEqual(rb.get(), [])
+
+    def test_buffer_with_zero_size(self):
+        """Test buffer with zero size."""
+        rb = RingBuffer(0)
+        # Should not crash, but behavior might be different
+        # In this implementation, it will behave like a normal list
+        rb.append(1)
+        self.assertEqual(len(rb), 1)
+        self.assertEqual(rb.get(), [1])
+
+    def test_buffer_with_negative_size(self):
+        """Test buffer with negative size."""
+        # This might not be a valid use case, but let's test it
+        rb = RingBuffer(-1)
+        rb.append(1)
+        self.assertEqual(len(rb), 1)
+        self.assertEqual(rb.get(), [1])
+
+    def test_append_none_value(self):
+        """Test appending None values."""
+        rb = RingBuffer(3)
+        rb.append(None)
+        rb.append(1)
+        rb.append(2)
+
+        result = rb.get()
+        self.assertEqual(len(result), 3)
+        self.assertIsNone(result[0])
+        self.assertEqual(result[1], 1)
+        self.assertEqual(result[2], 2)
+
+    def test_append_multiple_types(self):
+        """Test appending multiple different types of values."""
+        rb = RingBuffer(4)
+        rb.append('string')
+        rb.append(42)
+        rb.append([1, 2, 3])
+        rb.append({'key': 'value'})
+
+        result = rb.get()
+        self.assertEqual(len(result), 4)
+        self.assertEqual(result[0], 'string')
+        self.assertEqual(result[1], 42)
+        self.assertEqual(result[2], [1, 2, 3])
+        self.assertEqual(result[3], {'key': 'value'})
+
+    def test_multiple_appends_then_get(self):
+        """Test multiple appends followed by get operations."""
+        rb = RingBuffer(5)
+
+        # Append multiple items
+        for i in range(10):
+            rb.append(i)
+
+        # Get should return the last 5 items
+        result = rb.get()
+        self.assertEqual(len(result), 5)
+        self.assertEqual(result, [5, 6, 7, 8, 9])
+
+    def test_get_returns_copy(self):
+        """Test that get() returns a copy, not a reference."""
+        rb = RingBuffer(3)
+        rb.append(1)
+        rb.append(2)
+        rb.append(3)
+
+        result = rb.get()
+        # Modify the returned list
+        result.append(4)
+
+        # Original buffer should not be affected
+        original = rb.get()
+        self.assertEqual(len(original), 3)
+        self.assertNotIn(4, original)
+
+    def test_buffer_size_one(self):
+        """Test buffer with size 1."""
+        rb = RingBuffer(1)
+        rb.append(1)
+        self.assertEqual(len(rb), 1)
+        self.assertEqual(rb.get(), [1])
+
+        rb.append(2)
+        self.assertEqual(len(rb), 1)
+        result = rb.get()
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0], 2)
+
+    def test_buffer_size_two(self):
+        """Test buffer with size 2."""
+        rb = RingBuffer(2)
+        rb.append(1)
+        rb.append(2)
+        self.assertEqual(len(rb), 2)
+        self.assertEqual(rb.get(), [1, 2])
+
+        rb.append(3)
+        self.assertEqual(len(rb), 2)
+        result = rb.get()
+        self.assertEqual(len(result), 2)
+        self.assertEqual(result[0], 2)
+        self.assertEqual(result[1], 3)
+
+    def test_large_buffer_size(self):
+        """Test with a large buffer size."""
+        rb = RingBuffer(1000)
+        for i in range(1000):
+            rb.append(i)
+
+        result = rb.get()
+        self.assertEqual(len(result), 1000)
+        self.assertEqual(result[0], 0)
+        self.assertEqual(result[-1], 999)
+
+    def test_buffer_with_many_wraparounds(self):
+        """Test buffer with many wraparounds."""
+        rb = RingBuffer(3)
+        # Fill and wrap multiple times
+        for i in range(100):
+            rb.append(i)
+
+        result = rb.get()
+        self.assertEqual(len(result), 3)
+        # Should contain the last 3 elements
+        self.assertEqual(result[0], 97)
+        self.assertEqual(result[1], 98)
+        self.assertEqual(result[2], 99)
+
+    def test_multiple_get_calls(self):
+        """Test multiple get() calls return consistent results."""
+        rb = RingBuffer(3)
+        rb.append(1)
+        rb.append(2)
+        rb.append(3)
+
+        result1 = rb.get()
+        result2 = rb.get()
+        result3 = rb.get()
+
+        self.assertEqual(result1, result2)
+        self.assertEqual(result2, result3)
+        self.assertEqual(result1, [1, 2, 3])
+
+    def test_get_order_consistency(self):
+        """Test that get() maintains order consistency."""
+        rb = RingBuffer(5)
+        # Add elements
+        elements = [1, 2, 3, 4, 5, 6, 7]
+        for elem in elements:
+            rb.append(elem)
+
+        result = rb.get()
+        # Should contain the last 5 elements in correct order
+        self.assertEqual(len(result), 5)
+        self.assertEqual(result, [3, 4, 5, 6, 7])
+
+
+if __name__ == '__main__':
+    unittest.main()