"""Tests for the factor-weight learning loop (P4) + validation gate.""" from __future__ import annotations import datetime as dt import unittest from app import weight_learning as wl class SpearmanICTest(unittest.TestCase): def test_perfect_positive(self): fv = {"A": 1.0, "B": 2.0, "C": 3.0, "D": 4.0} fr = {"A": 0.1, "B": 0.2, "C": 0.3, "D": 0.4} self.assertTrue(abs(wl.spearman_ic(fv, fr) - 1.0) < 1e-5) def test_inverse_is_negative_one(self): fv = {"A": 1.0, "B": 2.0, "C": 3.0, "D": 4.0} fr = {"A": 0.4, "B": 0.3, "C": 0.2, "D": 0.1} self.assertTrue(abs(wl.spearman_ic(fv, fr) + 1.0) < 1e-5) def test_too_few_symbols_returns_none(self): self.assertIsNone(wl.spearman_ic({"A": 1.0}, {"A": 0.1})) def test_invalid_symbols_excluded(self): fv = {"A": 1.0, "B": 2.0, "C": 3.0, "D": 4.0, "E": float("nan")} fr = {"A": 0.1, "B": 0.2, "C": 0.3, "D": 0.4, "E": 0.5} self.assertTrue(abs(wl.spearman_ic(fv, fr) - 1.0) < 1e-5) class ValidationGateTest(unittest.TestCase): def test_passes_when_both_windows_positive_and_significant(self): l = wl.learn_factor_series([0.2] * 10) # train (10 positive, all strong) + holdout (6 positive) -> validated train = [0.2] * 10 holdout = [0.3] * 6 res = wl.apply_validation_gate(l, train, holdout) self.assertTrue(res.validated) self.assertEqual(res.gate_notes, []) self.assertIsNotNone(res.ic_train) self.assertIsNotNone(res.ic_holdout) def test_fails_when_sample_too_small(self): l = wl.learn_factor_series([0.2] * 6) res = wl.apply_validation_gate(l, [0.2] * 3, [0.3] * 3) self.assertFalse(res.validated) self.assertTrue(any("sample too small" in n for n in res.gate_notes)) def test_fails_when_holdout_not_above_baseline(self): l = wl.learn_factor_series([0.2] * 10) res = wl.apply_validation_gate(l, [0.2] * 10, [-0.1] * 6) self.assertFalse(res.validated) self.assertTrue(any("baseline" in n for n in res.gate_notes)) def test_fails_when_train_and_holdout_disagree_in_sign(self): l = wl.learn_factor_series([0.2] * 10) res = wl.apply_validation_gate(l, [0.2] * 10, [-0.05] * 6) self.assertFalse(res.validated) def test_fails_when_ic_not_significant(self): l = wl.learn_factor_series([0.02] * 10) res = wl.apply_validation_gate(l, [0.02] * 10, [0.02] * 6) self.assertFalse(res.validated) # tiny IC, |t| below bar class WeightUpdateGateTest(unittest.TestCase): def test_unvalidated_factor_never_auto_applies(self): # positive IC but NOT validated -> weight must NOT move l = wl.FactorLearning("f", n_periods=20, ic_mean=0.3, old_weight=1.0) wl.apply_weight_update(l, shrink=0.5) self.assertEqual(l.new_weight, 1.0) # unchanged (no auto-apply) self.assertFalse(l.validated) def test_validated_positive_ic_raises_weight(self): l = wl.FactorLearning("f", n_periods=20, ic_mean=0.3, old_weight=1.0, validated=True) wl.apply_weight_update(l, shrink=0.5) self.assertIsNotNone(l.new_weight) self.assertTrue(l.new_weight > 1.0) def test_validated_negative_ic_lowers_weight(self): l = wl.FactorLearning("f", n_periods=20, ic_mean=-0.4, old_weight=1.0, validated=True) wl.apply_weight_update(l, shrink=0.5) self.assertIsNotNone(l.new_weight) self.assertTrue(l.new_weight < 1.0) def test_clamped_to_bounds(self): l = wl.FactorLearning("f", n_periods=20, ic_mean=10.0, old_weight=1.0, validated=True) wl.apply_weight_update(l, shrink=1.0, max_w=3.0) self.assertEqual(l.new_weight, 3.0) def test_blocked_keeps_weight(self): l = wl.FactorLearning("f", n_periods=0, ic_mean=None, old_weight=1.0, blocked=True) wl.apply_weight_update(l) self.assertEqual(l.new_weight, 1.0) def test_no_old_weight_returns(self): l = wl.FactorLearning("f", n_periods=12, ic_mean=0.2, old_weight=None, validated=True) wl.apply_weight_update(l) self.assertIsNone(l.new_weight) class MomentumGatedLearningTest(unittest.TestCase): @staticmethod def _series(): def bars(base, drift): out = [] for i in range(600): d = (dt.date(2024, 1, 1) + dt.timedelta(days=i)).isoformat() out.append({"date": d, "adjusted_close": base + drift * i}) return out return {"A": {"bars": bars(10.0, 0.05)}, "B": {"bars": bars(20.0, 0.0)}} def test_gated_runs_and_returns_validated_flag(self): res = wl.learn_momentum_gated(self._series(), ["A", "B"], "2025-01-01", "2026-06-01") self.assertIsInstance(res, wl.FactorLearning) self.assertIn(res.validated, (True, False)) # always a boolean verdict self.assertGreaterEqual(res.n_periods, 0) class AddMonthsTest(unittest.TestCase): def test_clamps_day_to_end_of_month(self): self.assertEqual(wl._add_months(dt.date(2026, 1, 31), 1), dt.date(2026, 2, 28)) self.assertEqual(wl._add_months(dt.date(2026, 1, 31), 2), dt.date(2026, 3, 31)) self.assertEqual(wl._add_months(dt.date(2024, 1, 31), 1), dt.date(2024, 2, 29)) class LearnFactorSeriesTest(unittest.TestCase): def test_aggregates_ics(self): res = wl.learn_factor_series([0.1, 0.2, 0.3, 0.4]) self.assertEqual(res.n_periods, 4) self.assertTrue(res.ic_mean is not None and abs(res.ic_mean - 0.25) < 1e-6) self.assertIsNotNone(res.ic_tstat) def test_empty_is_blocked_like(self): res = wl.learn_factor_series([]) self.assertEqual(res.n_periods, 0) self.assertIsNone(res.ic_mean) if __name__ == "__main__": unittest.main()