Extend tests to test with a custom type

Signed-off-by: Leandro Lucarella <[email protected]>

Author: llucax

tests/test_collections.py

@@ -4,36 +4,130 @@
 """Tests for the collections module."""
 
 
-from frequenz.core.collections import Bounds
+from typing import Self
 
+import pytest
 
-def test_bounds_contains() -> None:
-    """Tests with complete bounds."""
-    bounds = Bounds(lower=10.0, upper=100.0)
-    assert 50.0 in bounds  # within
-    assert 10.0 in bounds  # at lower
-    assert 100.0 in bounds  # at upper
-    assert 9.0 not in bounds  # below lower
-    assert 101.0 not in bounds  # above upper
+from frequenz.core.collections import Bounds, LessThanComparable
 
 
-def test_bounds_contains_no_lower() -> None:
-    """Tests without lower bound."""
-    bounds_no_lower = Bounds(lower=None, upper=100.0)
-    assert 50.0 in bounds_no_lower  # within upper
-    assert 100.0 in bounds_no_lower  # at upper
-    assert 101.0 not in bounds_no_lower  # above upper
+class CustomComparable:
+    """A custom comparable class."""
 
+    def __init__(self, value: int) -> None:
+        """Initialize this instance."""
+        self.value = value
 
-def test_bounds_contains_no_upper() -> None:
-    """Tests without upper bound."""
-    bounds_no_upper = Bounds(lower=10.0, upper=None)
-    assert 50.0 in bounds_no_upper  # within lower
-    assert 10.0 in bounds_no_upper  # at lower
-    assert 9.0 not in bounds_no_upper  # below lower
+    def __lt__(self, other: Self) -> bool:
+        """Return whether this instance is less than other."""
+        return self.value < other.value
 
+    def __eq__(self, other: object) -> bool:
+        """Return whether this instance is equal to other."""
+        if not isinstance(other, CustomComparable):
+            return False
+        return self.value == other.value
 
-def test_bounds_contains_no_bounds() -> None:
-    """Tests with no bounds."""
-    bounds_no_bounds: Bounds[float | None] = Bounds(lower=None, upper=None)
-    assert 50.0 in bounds_no_bounds  # any value within bounds
+    def __repr__(self) -> str:
+        """Return a string representation of this instance."""
+        return str(self.value)
+
+
+@pytest.mark.parametrize(
+    "lower, upper, within, at_lower, at_upper, below_lower, above_upper",
+    [
+        (10.0, 100.0, 50.0, 10.0, 100.0, 9.0, 101.0),
+        (
+            CustomComparable(10),
+            CustomComparable(100),
+            CustomComparable(50),
+            CustomComparable(10),
+            CustomComparable(100),
+            CustomComparable(9),
+            CustomComparable(101),
+        ),
+    ],
+)
+def test_bounds_contains(  # pylint: disable=too-many-arguments
+    lower: LessThanComparable,
+    upper: LessThanComparable,
+    within: LessThanComparable,
+    at_lower: LessThanComparable,
+    at_upper: LessThanComparable,
+    below_lower: LessThanComparable,
+    above_upper: LessThanComparable,
+) -> None:
+    """Test if a value is within the bounds."""
+    bounds = Bounds(lower=lower, upper=upper)
+    assert within in bounds  # within
+    assert at_lower in bounds  # at lower
+    assert at_upper in bounds  # at upper
+    assert below_lower not in bounds  # below lower
+    assert above_upper not in bounds  # above upper
+
+
+@pytest.mark.parametrize(
+    "upper, within, at_upper, above_upper",
+    [
+        (100.0, 50.0, 100.0, 101.0),
+        (
+            CustomComparable(100),
+            CustomComparable(50),
+            CustomComparable(100),
+            CustomComparable(101),
+        ),
+    ],
+)
+def test_bounds_contains_no_lower(
+    upper: LessThanComparable,
+    within: LessThanComparable,
+    at_upper: LessThanComparable,
+    above_upper: LessThanComparable,
+) -> None:
+    """Test if a value is within the bounds with no lower bound."""
+    bounds_no_lower = Bounds(lower=None, upper=upper)
+    assert within in bounds_no_lower  # within upper
+    assert at_upper in bounds_no_lower  # at upper
+    assert above_upper not in bounds_no_lower  # above upper
+
+
+@pytest.mark.parametrize(
+    "lower, within, at_lower, below_lower",
+    [
+        (10.0, 50.0, 10.0, 9.0),
+        (
+            CustomComparable(10),
+            CustomComparable(50),
+            CustomComparable(10),
+            CustomComparable(9),
+        ),
+    ],
+)
+def test_bounds_contains_no_upper(
+    lower: LessThanComparable,
+    within: LessThanComparable,
+    at_lower: LessThanComparable,
+    below_lower: LessThanComparable,
+) -> None:
+    """Test if a value is within the bounds with no upper bound."""
+    bounds_no_upper = Bounds(lower=lower, upper=None)
+    assert within in bounds_no_upper  # within lower
+    assert at_lower in bounds_no_upper  # at lower
+    assert below_lower not in bounds_no_upper  # below lower
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        50.0,
+        10.0,
+        -10.0,
+        CustomComparable(50),
+        CustomComparable(10),
+        CustomComparable(-10),
+    ],
+)
+def test_bounds_contains_no_bounds(value: LessThanComparable) -> None:
+    """Test if a value is within the bounds with no bounds."""
+    bounds_no_bounds: Bounds[LessThanComparable | None] = Bounds(lower=None, upper=None)
+    assert value in bounds_no_bounds  # any value within bounds