test(pipeline): convert pipeline tests from pytest to unittest

CI uses 'unittest discover' and does not install pytest as a dev
dependency, so 'import pytest' caused ImportError on the runner.
Rewrites all assertions/raises to native unittest.TestCase APIs.
No production code changes; behavior covered is identical.

Author: MDUYN

tests/domain/pipeline/test_factors.py

@@ -2,10 +2,10 @@
 from __future__ import annotations
 
 import math
+import unittest
 from datetime import datetime, timedelta
 
 import polars as pl
-import pytest
 
 from investing_algorithm_framework import (
     AverageDollarVolume,
@@ -43,140 +43,153 @@ def _bar(dt_idx, close, volume=1.0):
     return (dt, close, close, close, close, volume)
 
 
-def test_returns_simple_percent_return():
-    panel = _panel({"X": [_bar(i, c) for i, c in enumerate([10, 11, 12, 13])]})
-    series = Returns(window=2).compute_panel(panel).to_list()
-    # Bar 0,1 → null; bar 2 → 12/10 - 1; bar 3 → 13/11 - 1
-    assert series[0] is None and series[1] is None
-    assert series[2] == pytest.approx(0.2)
-    assert series[3] == pytest.approx(13.0 / 11.0 - 1.0)
-
-
-def test_average_dollar_volume_rolling_mean():
-    panel = _panel(
-        {
-            "X": [
-                (datetime(2024, 1, 1) + timedelta(days=i), c, c, c, c, vol)
-                for i, (c, vol) in enumerate(
-                    [(10, 1), (20, 2), (30, 3), (40, 4)]
-                )
-            ]
-        }
-    )
-    series = AverageDollarVolume(window=2).compute_panel(panel).to_list()
-    # close*volume = [10, 40, 90, 160]; rolling mean window=2
-    assert series[0] is None
-    assert series[1] == pytest.approx(25.0)
-    assert series[2] == pytest.approx(65.0)
-    assert series[3] == pytest.approx(125.0)
-
-
-def test_sma_rolling_mean():
-    panel = _panel({"X": [_bar(i, c) for i, c in enumerate([1, 2, 3, 4, 5])]})
-    series = SMA(window=3).compute_panel(panel).to_list()
-    assert series[0] is None and series[1] is None
-    assert series[2] == pytest.approx(2.0)
-    assert series[3] == pytest.approx(3.0)
-    assert series[4] == pytest.approx(4.0)
-
-
-def test_volatility_log_return_stdev_scaled():
-    closes = [100.0, 101.0, 99.0, 102.0, 100.0, 103.0]
-    panel = _panel({"X": [_bar(i, c) for i, c in enumerate(closes)]})
-    window = 4
-    pp_year = 252
-    series = (
-        Volatility(window=window, periods_per_year=pp_year)
-        .compute_panel(panel)
-        .to_list()
-    )
-    # Manually compute the last value
-    log_rets = [math.log(closes[i] / closes[i - 1]) for i in range(1, len(closes))]
-    last_window = log_rets[-window:]
-    mean = sum(last_window) / window
-    var = sum((x - mean) ** 2 for x in last_window) / (window - 1)
-    expected = math.sqrt(var) * math.sqrt(pp_year)
-    assert series[-1] == pytest.approx(expected)
-
-
-def test_rsi_all_gains_returns_100():
-    panel = _panel({"X": [_bar(i, c) for i, c in enumerate(range(1, 20))]})
-    series = RSI(window=4).compute_panel(panel).to_list()
-    # All gains, no losses → avg_loss == 0 → RSI clamped to 100
-    assert series[-1] == pytest.approx(100.0)
-
-
-def test_rsi_with_losses_strictly_between_0_and_100():
-    closes = [100, 102, 101, 103, 99, 104, 100, 106, 101]
-    panel = _panel({"X": [_bar(i, c) for i, c in enumerate(closes)]})
-    series = RSI(window=4).compute_panel(panel).to_list()
-    last = series[-1]
-    assert last is not None
-    assert 0.0 < last < 100.0
-
-
-def test_factor_rank_orders_within_each_bar():
-    # 3 symbols, 1 bar of meaningful data — but rank needs Returns(window=1).
-    panel = _panel(
-        {
-            "AAA": [_bar(0, 100), _bar(1, 110)],  # +10%
-            "BBB": [_bar(0, 100), _bar(1, 105)],  # +5%
-            "CCC": [_bar(0, 100), _bar(1, 120)],  # +20%
-        }
-    )
-    ranked = Returns(window=1).rank().compute_panel(panel)
-    df = panel.select(["datetime", "symbol"]).with_columns(
-        ranked.alias("rk")
-    ).filter(pl.col("datetime") == datetime(2024, 1, 2))
-    out = {row["symbol"]: row["rk"] for row in df.to_dicts()}
-    # Ascending ordinal ranks: BBB=1, AAA=2, CCC=3
-    assert out["BBB"] == 1.0
-    assert out["AAA"] == 2.0
-    assert out["CCC"] == 3.0
-
-
-def test_factor_top_filter_keeps_highest():
-    panel = _panel(
-        {
-            "AAA": [_bar(0, 100), _bar(1, 110)],
-            "BBB": [_bar(0, 100), _bar(1, 105)],
-            "CCC": [_bar(0, 100), _bar(1, 120)],
-        }
-    )
-    mask = Returns(window=1).top(2).compute_panel(panel)
-    df = panel.select(["datetime", "symbol"]).with_columns(
-        mask.alias("m")
-    ).filter(pl.col("datetime") == datetime(2024, 1, 2))
-    out = {row["symbol"]: row["m"] for row in df.to_dicts()}
-    # Top 2 by descending returns: CCC (20%) and AAA (10%)
-    assert out["AAA"] is True
-    assert out["CCC"] is True
-    assert out["BBB"] is False
-
-
-def test_factor_bottom_filter_keeps_lowest():
-    panel = _panel(
-        {
-            "AAA": [_bar(0, 100), _bar(1, 110)],
-            "BBB": [_bar(0, 100), _bar(1, 105)],
-            "CCC": [_bar(0, 100), _bar(1, 120)],
-        }
-    )
-    mask = Returns(window=1).bottom(1).compute_panel(panel)
-    df = panel.select(["datetime", "symbol"]).with_columns(
-        mask.alias("m")
-    ).filter(pl.col("datetime") == datetime(2024, 1, 2))
-    out = {row["symbol"]: row["m"] for row in df.to_dicts()}
-    assert out["BBB"] is True
-    assert out["AAA"] is False
-    assert out["CCC"] is False
-
-
-def test_factor_invalid_window_raises():
-    with pytest.raises(ValueError):
-        Returns(window=0)
-
-
-def test_volatility_invalid_periods_raises():
-    with pytest.raises(ValueError):
-        Volatility(window=10, periods_per_year=0)
+class TestPipelineFactors(unittest.TestCase):
+
+    def test_returns_simple_percent_return(self):
+        panel = _panel(
+            {"X": [_bar(i, c) for i, c in enumerate([10, 11, 12, 13])]}
+        )
+        series = Returns(window=2).compute_panel(panel).to_list()
+        # Bar 0,1 → null; bar 2 → 12/10 - 1; bar 3 → 13/11 - 1
+        self.assertIsNone(series[0])
+        self.assertIsNone(series[1])
+        self.assertAlmostEqual(series[2], 0.2)
+        self.assertAlmostEqual(series[3], 13.0 / 11.0 - 1.0)
+
+    def test_average_dollar_volume_rolling_mean(self):
+        panel = _panel(
+            {
+                "X": [
+                    (datetime(2024, 1, 1) + timedelta(days=i), c, c, c, c, vol)
+                    for i, (c, vol) in enumerate(
+                        [(10, 1), (20, 2), (30, 3), (40, 4)]
+                    )
+                ]
+            }
+        )
+        series = AverageDollarVolume(window=2).compute_panel(panel).to_list()
+        # close*volume = [10, 40, 90, 160]; rolling mean window=2
+        self.assertIsNone(series[0])
+        self.assertAlmostEqual(series[1], 25.0)
+        self.assertAlmostEqual(series[2], 65.0)
+        self.assertAlmostEqual(series[3], 125.0)
+
+    def test_sma_rolling_mean(self):
+        panel = _panel(
+            {"X": [_bar(i, c) for i, c in enumerate([1, 2, 3, 4, 5])]}
+        )
+        series = SMA(window=3).compute_panel(panel).to_list()
+        self.assertIsNone(series[0])
+        self.assertIsNone(series[1])
+        self.assertAlmostEqual(series[2], 2.0)
+        self.assertAlmostEqual(series[3], 3.0)
+        self.assertAlmostEqual(series[4], 4.0)
+
+    def test_volatility_log_return_stdev_scaled(self):
+        closes = [100.0, 101.0, 99.0, 102.0, 100.0, 103.0]
+        panel = _panel({"X": [_bar(i, c) for i, c in enumerate(closes)]})
+        window = 4
+        pp_year = 252
+        series = (
+            Volatility(window=window, periods_per_year=pp_year)
+            .compute_panel(panel)
+            .to_list()
+        )
+        # Manually compute the last value
+        log_rets = [
+            math.log(closes[i] / closes[i - 1]) for i in range(1, len(closes))
+        ]
+        last_window = log_rets[-window:]
+        mean = sum(last_window) / window
+        var = sum((x - mean) ** 2 for x in last_window) / (window - 1)
+        expected = math.sqrt(var) * math.sqrt(pp_year)
+        self.assertAlmostEqual(series[-1], expected)
+
+    def test_rsi_all_gains_returns_100(self):
+        panel = _panel(
+            {"X": [_bar(i, c) for i, c in enumerate(range(1, 20))]}
+        )
+        series = RSI(window=4).compute_panel(panel).to_list()
+        # All gains, no losses → avg_loss == 0 → RSI clamped to 100
+        self.assertAlmostEqual(series[-1], 100.0)
+
+    def test_rsi_with_losses_strictly_between_0_and_100(self):
+        closes = [100, 102, 101, 103, 99, 104, 100, 106, 101]
+        panel = _panel({"X": [_bar(i, c) for i, c in enumerate(closes)]})
+        series = RSI(window=4).compute_panel(panel).to_list()
+        last = series[-1]
+        self.assertIsNotNone(last)
+        self.assertGreater(last, 0.0)
+        self.assertLess(last, 100.0)
+
+    def test_factor_rank_orders_within_each_bar(self):
+        # 3 symbols, 1 bar of meaningful data — rank needs Returns(window=1).
+        panel = _panel(
+            {
+                "AAA": [_bar(0, 100), _bar(1, 110)],  # +10%
+                "BBB": [_bar(0, 100), _bar(1, 105)],  # +5%
+                "CCC": [_bar(0, 100), _bar(1, 120)],  # +20%
+            }
+        )
+        ranked = Returns(window=1).rank().compute_panel(panel)
+        df = (
+            panel.select(["datetime", "symbol"])
+            .with_columns(ranked.alias("rk"))
+            .filter(pl.col("datetime") == datetime(2024, 1, 2))
+        )
+        out = {row["symbol"]: row["rk"] for row in df.to_dicts()}
+        # Ascending ordinal ranks: BBB=1, AAA=2, CCC=3
+        self.assertEqual(out["BBB"], 1.0)
+        self.assertEqual(out["AAA"], 2.0)
+        self.assertEqual(out["CCC"], 3.0)
+
+    def test_factor_top_filter_keeps_highest(self):
+        panel = _panel(
+            {
+                "AAA": [_bar(0, 100), _bar(1, 110)],
+                "BBB": [_bar(0, 100), _bar(1, 105)],
+                "CCC": [_bar(0, 100), _bar(1, 120)],
+            }
+        )
+        mask = Returns(window=1).top(2).compute_panel(panel)
+        df = (
+            panel.select(["datetime", "symbol"])
+            .with_columns(mask.alias("m"))
+            .filter(pl.col("datetime") == datetime(2024, 1, 2))
+        )
+        out = {row["symbol"]: row["m"] for row in df.to_dicts()}
+        # Top 2 by descending returns: CCC (20%) and AAA (10%)
+        self.assertTrue(out["AAA"])
+        self.assertTrue(out["CCC"])
+        self.assertFalse(out["BBB"])
+
+    def test_factor_bottom_filter_keeps_lowest(self):
+        panel = _panel(
+            {
+                "AAA": [_bar(0, 100), _bar(1, 110)],
+                "BBB": [_bar(0, 100), _bar(1, 105)],
+                "CCC": [_bar(0, 100), _bar(1, 120)],
+            }
+        )
+        mask = Returns(window=1).bottom(1).compute_panel(panel)
+        df = (
+            panel.select(["datetime", "symbol"])
+            .with_columns(mask.alias("m"))
+            .filter(pl.col("datetime") == datetime(2024, 1, 2))
+        )
+        out = {row["symbol"]: row["m"] for row in df.to_dicts()}
+        self.assertTrue(out["BBB"])
+        self.assertFalse(out["AAA"])
+        self.assertFalse(out["CCC"])
+
+    def test_factor_invalid_window_raises(self):
+        with self.assertRaises(ValueError):
+            Returns(window=0)
+
+    def test_volatility_invalid_periods_raises(self):
+        with self.assertRaises(ValueError):
+            Volatility(window=10, periods_per_year=0)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/domain/pipeline/test_pipeline.py

@@ -5,7 +5,7 @@
 """
 from __future__ import annotations
 
-import pytest
+import unittest
 
 from investing_algorithm_framework import (
     AverageDollarVolume,
@@ -22,48 +22,50 @@ class _Screener(Pipeline):
     alpha = momentum.rank(mask=universe)
 
 
-def test_pipeline_collects_columns_excluding_universe():
-    cols = _Screener.get_columns()
-    assert list(cols.keys()) == ["dollar_volume", "momentum", "alpha"]
-    assert _Screener.get_universe() is _Screener.universe
+class TestPipelineIntrospection(unittest.TestCase):
 
+    def test_pipeline_collects_columns_excluding_universe(self):
+        cols = _Screener.get_columns()
+        self.assertEqual(
+            list(cols.keys()), ["dollar_volume", "momentum", "alpha"]
+        )
+        self.assertIs(_Screener.get_universe(), _Screener.universe)
 
-def test_pipeline_required_columns_union():
-    required = _Screener.required_columns()
-    # AverageDollarVolume needs close+volume, Returns needs close
-    assert "close" in required
-    assert "volume" in required
+    def test_pipeline_required_columns_union(self):
+        required = _Screener.required_columns()
+        # AverageDollarVolume needs close+volume, Returns needs close
+        self.assertIn("close", required)
+        self.assertIn("volume", required)
 
+    def test_pipeline_required_window_is_max(self):
+        self.assertEqual(_Screener.required_window(), 5)
 
-def test_pipeline_required_window_is_max():
-    assert _Screener.required_window() == 5
+    def test_pipeline_name_defaults_to_class_name(self):
+        self.assertEqual(_Screener.name(), "_Screener")
 
+    def test_pipeline_with_no_columns_raises(self):
+        with self.assertRaisesRegex(TypeError, "declares no factor columns"):
+            class _Empty(Pipeline):
+                pass
 
-def test_pipeline_name_defaults_to_class_name():
-    assert _Screener.name() == "_Screener"
+    def test_pipeline_universe_must_be_filter(self):
+        with self.assertRaisesRegex(TypeError, "must be a Filter"):
+            class _BadUniverse(Pipeline):
+                momentum = Returns(window=3)
+                # Returns is a Factor, not a Filter
+                universe = momentum
 
+    def test_pipeline_inheritance_collects_parent_columns(self):
+        class _Child(_Screener):
+            sma = SMA(window=4)
 
-def test_pipeline_with_no_columns_raises():
-    with pytest.raises(TypeError, match="declares no factor columns"):
-        class _Empty(Pipeline):
-            pass
+        cols = _Child.get_columns()
+        # Child columns + parent columns
+        self.assertIn("sma", cols)
+        self.assertIn("dollar_volume", cols)
+        self.assertIn("momentum", cols)
+        self.assertIn("alpha", cols)
 
 
-def test_pipeline_universe_must_be_filter():
-    with pytest.raises(TypeError, match="must be a Filter"):
-        class _BadUniverse(Pipeline):
-            momentum = Returns(window=3)
-            # Returns is a Factor, not a Filter
-            universe = momentum
-
-
-def test_pipeline_inheritance_collects_parent_columns():
-    class _Child(_Screener):
-        sma = SMA(window=4)
-
-    cols = _Child.get_columns()
-    # Child columns + parent columns
-    assert "sma" in cols
-    assert "dollar_volume" in cols
-    assert "momentum" in cols
-    assert "alpha" in cols
+if __name__ == "__main__":
+    unittest.main()