Implemented the next missing parity slice around small portable utilities.

tests/test_small_utils.py

@@ -0,0 +1,138 @@
+"""Tests for the bundled small utilities ported in ``src/small_utils.py``."""
+
+from __future__ import annotations
+
+import unittest
+
+from src.small_utils import (
+    count,
+    create_agent_id,
+    difference,
+    escape_xml,
+    escape_xml_attr,
+    every_in,
+    intersects,
+    intersperse,
+    object_group_by,
+    union,
+    uniq,
+    validate_uuid,
+)
+
+
+class IntersperseTest(unittest.TestCase):
+    def test_empty(self) -> None:
+        self.assertEqual(intersperse([], lambda i: ','), [])
+
+    def test_single_item_no_separator(self) -> None:
+        self.assertEqual(intersperse(['a'], lambda i: ','), ['a'])
+
+    def test_separator_receives_index_starting_at_one(self) -> None:
+        seen: list[int] = []
+
+        def sep(i: int) -> str:
+            seen.append(i)
+            return f'-{i}-'
+
+        out = intersperse(['a', 'b', 'c'], sep)
+        self.assertEqual(out, ['a', '-1-', 'b', '-2-', 'c'])
+        self.assertEqual(seen, [1, 2])
+
+
+class CountTest(unittest.TestCase):
+    def test_counts_truthy(self) -> None:
+        self.assertEqual(count([1, 2, 3, 4], lambda x: x % 2 == 0), 2)
+
+    def test_predicate_returning_objects_treated_as_truthy(self) -> None:
+        self.assertEqual(count(['', 'x', 'y'], lambda s: s), 2)
+
+
+class UniqTest(unittest.TestCase):
+    def test_preserves_first_seen_order(self) -> None:
+        self.assertEqual(uniq([3, 1, 2, 1, 3, 4]), [3, 1, 2, 4])
+
+
+class ObjectGroupByTest(unittest.TestCase):
+    def test_groups_by_key(self) -> None:
+        out = object_group_by(['apple', 'banana', 'avocado'], lambda s, _i: s[0])
+        self.assertEqual(out, {'a': ['apple', 'avocado'], 'b': ['banana']})
+
+    def test_passes_index_to_selector(self) -> None:
+        out = object_group_by(
+            ['x', 'y', 'z'], lambda _s, i: 'even' if i % 2 == 0 else 'odd',
+        )
+        self.assertEqual(out, {'even': ['x', 'z'], 'odd': ['y']})
+
+
+class SetOpsTest(unittest.TestCase):
+    def test_difference(self) -> None:
+        self.assertEqual(difference({1, 2, 3}, {2}), {1, 3})
+
+    def test_intersects_true(self) -> None:
+        self.assertTrue(intersects({1, 2}, {2, 3}))
+
+    def test_intersects_false(self) -> None:
+        self.assertFalse(intersects({1, 2}, {3, 4}))
+
+    def test_intersects_empty_short_circuits(self) -> None:
+        self.assertFalse(intersects(set(), {1}))
+        self.assertFalse(intersects({1}, set()))
+
+    def test_every_in(self) -> None:
+        self.assertTrue(every_in({1, 2}, {1, 2, 3}))
+        self.assertFalse(every_in({1, 4}, {1, 2, 3}))
+        self.assertTrue(every_in(set(), {1, 2}))
+
+    def test_union(self) -> None:
+        self.assertEqual(union({1, 2}, {2, 3}), {1, 2, 3})
+
+
+class XmlEscapeTest(unittest.TestCase):
+    def test_escape_xml(self) -> None:
+        self.assertEqual(
+            escape_xml('a & b < c > d'), 'a &amp; b &lt; c &gt; d',
+        )
+
+    def test_escape_xml_amp_first_no_double_escape(self) -> None:
+        self.assertEqual(escape_xml('<&>'), '&lt;&amp;&gt;')
+
+    def test_escape_xml_attr_includes_quotes(self) -> None:
+        self.assertEqual(
+            escape_xml_attr('he said "hi" & \'bye\''),
+            'he said &quot;hi&quot; &amp; &apos;bye&apos;',
+        )
+
+
+class ValidateUuidTest(unittest.TestCase):
+    def test_valid_lowercase(self) -> None:
+        u = '12345678-1234-1234-1234-123456789012'
+        self.assertEqual(validate_uuid(u), u)
+
+    def test_valid_uppercase(self) -> None:
+        u = 'ABCDEF12-1234-5678-90AB-CDEF12345678'
+        self.assertEqual(validate_uuid(u), u)
+
+    def test_invalid_format(self) -> None:
+        self.assertIsNone(validate_uuid('not-a-uuid'))
+
+    def test_non_string_returns_none(self) -> None:
+        self.assertIsNone(validate_uuid(123))
+        self.assertIsNone(validate_uuid(None))
+
+
+class CreateAgentIdTest(unittest.TestCase):
+    def test_no_label(self) -> None:
+        agent_id = create_agent_id()
+        self.assertRegex(agent_id, r'^a[0-9a-f]{16}$')
+
+    def test_with_label(self) -> None:
+        agent_id = create_agent_id('compact')
+        self.assertRegex(agent_id, r'^acompact-[0-9a-f]{16}$')
+
+    def test_unique_across_calls(self) -> None:
+        ids = {create_agent_id() for _ in range(50)}
+        self.assertEqual(len(ids), 50)
+
+
+if __name__ == '__main__':
+    unittest.main()