chore: 移除不再使用的 ChanMacro、system、tests。
这些目录已废弃，从仓库中清理。 Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
jackyu66git
@@ -1,134 +0,0 @@
|
||||
"""
|
||||
tests/conftest.py — Shared fixtures for ChanMacro tests.
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import pytest
|
||||
import sqlite3
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
from datetime import date, timedelta
|
||||
from pathlib import Path
|
||||
|
||||
# Ensure package root on path
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent))
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def db_path(tmp_path):
|
||||
"""Create a temporary SQLite database with full mock data."""
|
||||
db = str(tmp_path / "test_macro.db")
|
||||
from database import init_db
|
||||
conn = init_db(db)
|
||||
|
||||
np.random.seed(42)
|
||||
base = date(2025, 9, 1)
|
||||
n_days = 300
|
||||
|
||||
# Generate realistic price series with 3 regime periods
|
||||
prices = [90000]
|
||||
regimes = []
|
||||
for i in range(n_days):
|
||||
if i < 100:
|
||||
ret = np.random.normal(0.003, 0.015)
|
||||
regime = "TREND"
|
||||
elif i < 200:
|
||||
ret = np.random.normal(0.000, 0.012)
|
||||
regime = "RANGE"
|
||||
else:
|
||||
ret = np.random.normal(-0.003, 0.025)
|
||||
regime = "PANIC"
|
||||
prices.append(prices[-1] * (1 + ret))
|
||||
regimes.append(regime)
|
||||
|
||||
for i in range(n_days):
|
||||
d = base + timedelta(days=i)
|
||||
c = prices[i]
|
||||
r = regimes[i]
|
||||
|
||||
# OHLCV
|
||||
conn.execute("""
|
||||
INSERT OR REPLACE INTO ohlcv_daily
|
||||
(date,symbol,open,high,low,close,volume,ema20,ema60,ema120,atr_14,bb_width,adx_14)
|
||||
VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)
|
||||
""", (
|
||||
d.strftime("%Y-%m-%d"), "BTC/USDT:USDT",
|
||||
c * 0.99, c * 1.03, c * 0.97, c, 1000,
|
||||
c * (0.98 if r == "TREND" else 1.02 if r == "PANIC" else 1.0),
|
||||
c * (0.95 if r == "TREND" else 1.05 if r == "PANIC" else 1.0),
|
||||
c * (0.90 if r == "TREND" else 1.10 if r == "PANIC" else 1.0),
|
||||
c * (0.02 if r == "PANIC" else 0.015),
|
||||
4.5, 28.0 if r == "TREND" else 18.0,
|
||||
))
|
||||
|
||||
# Breadth
|
||||
adv = 42 if r == "TREND" else 25 if r == "RANGE" else 8
|
||||
conn.execute("""
|
||||
INSERT OR REPLACE INTO breadth_daily
|
||||
(date,total_tracked,advance_top50,decline_top50,above_ema20_top50,
|
||||
new_highs_20d_top50,advance_top30,advance_top20,
|
||||
above_ema20_top30,above_ema20_top20,new_highs_20d_top30,new_highs_20d_top20)
|
||||
VALUES (?,50,?,?,?,?,?,?,?,?,?,?)
|
||||
""", (
|
||||
d.strftime("%Y-%m-%d"), adv, 50 - adv, adv, min(adv, 15),
|
||||
int(adv * 0.7), int(adv * 0.5), int(adv * 0.7), int(adv * 0.5),
|
||||
min(int(adv * 0.7), 12), min(int(adv * 0.5), 8),
|
||||
))
|
||||
|
||||
# Derivatives
|
||||
oi_chg = 3.5 if r == "TREND" else 0.5 if r == "RANGE" else -2.0
|
||||
conn.execute("""
|
||||
INSERT OR REPLACE INTO derivatives
|
||||
(date,symbol,funding_rate,open_interest,oi_24h_change_pct,
|
||||
long_liquidations,short_liquidations,basis_annualised_pct)
|
||||
VALUES (?,?,?,?,?,?,?,?)
|
||||
""", (
|
||||
d.strftime("%Y-%m-%d"), "BTC/USDT:USDT",
|
||||
0.0001 + np.random.normal(0, 0.0002),
|
||||
35e9, oi_chg + np.random.normal(0, 1.0),
|
||||
50e6 * np.random.random(), 30e6 * np.random.random(),
|
||||
8.5 if r == "TREND" else 3.0,
|
||||
))
|
||||
|
||||
# Regime history
|
||||
conn.execute("""
|
||||
INSERT OR REPLACE INTO regime_history
|
||||
(date,regime,confidence,regime_version,maturity_score,all_scores_json,confirmation_days)
|
||||
VALUES (?,?,?,?,?,?,?)
|
||||
""", (d.strftime("%Y-%m-%d"), r, 0.75, "v1_price_breadth_vol", 50, "{}", 1))
|
||||
|
||||
conn.commit()
|
||||
conn.close()
|
||||
|
||||
# Override config to use test DB
|
||||
from config import config
|
||||
old_db = config.db_path
|
||||
config.db_path = db
|
||||
yield db
|
||||
config.db_path = old_db
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_state(db_path):
|
||||
"""Build a MarketStateVector for a known test date."""
|
||||
from models import (
|
||||
MarketStateVector, MarketRegime, BreadthBucket,
|
||||
OIState, VolRegime,
|
||||
)
|
||||
state = MarketStateVector(
|
||||
date=date(2026, 3, 15),
|
||||
regime=MarketRegime.TREND,
|
||||
regime_confidence=0.82,
|
||||
regime_version="v1_price_breadth_vol",
|
||||
regime_maturity_score=55.0,
|
||||
breadth_top20=82.0,
|
||||
breadth_top30=78.0,
|
||||
breadth_top50=74.0,
|
||||
breadth_bucket=BreadthBucket.STRONG,
|
||||
breadth_divergence=8.0,
|
||||
oi_state=OIState.NEW_LONGS,
|
||||
volatility_regime=VolRegime.NORMAL_VOL,
|
||||
)
|
||||
state.market_state_hash = state.compute_hash()
|
||||
return state
|
||||
@@ -1,173 +0,0 @@
|
||||
"""Test SignalTracker, TimeDecay, and BayesianExpectancyEngine."""
|
||||
import pytest
|
||||
from datetime import date, timedelta
|
||||
import numpy as np
|
||||
|
||||
|
||||
class TestTimeDecay:
|
||||
def test_recent_weight_near_one(self):
|
||||
from expectancy.decay import TimeDecay
|
||||
d = TimeDecay(180)
|
||||
w = d.weight(date(2026, 6, 20), date(2026, 6, 24))
|
||||
assert 0.95 < w < 1.0
|
||||
|
||||
def test_old_weight_decays(self):
|
||||
from expectancy.decay import TimeDecay
|
||||
d = TimeDecay(180)
|
||||
w = d.weight(date(2025, 6, 24), date(2026, 6, 24))
|
||||
assert 0.2 < w < 0.3 # ~365 days at half_life=180
|
||||
|
||||
def test_effective_samples(self):
|
||||
from expectancy.decay import TimeDecay
|
||||
d = TimeDecay(180)
|
||||
dates = [date(2026, 6, 24)] * 10
|
||||
weights = d.weights(dates, date(2026, 6, 24))
|
||||
eff = d.effective_samples(weights)
|
||||
assert eff == pytest.approx(10.0, rel=0.01)
|
||||
|
||||
def test_weighted_win_rate(self):
|
||||
from expectancy.decay import TimeDecay
|
||||
d = TimeDecay(180)
|
||||
wins = np.array([1, 0, 1, 0])
|
||||
weights = np.array([1.0, 1.0, 1.0, 1.0])
|
||||
wr = d.weighted_win_rate(wins, weights)
|
||||
assert wr == 0.5
|
||||
|
||||
def test_weight_at_age(self):
|
||||
from expectancy.decay import TimeDecay
|
||||
w = TimeDecay.weight_at_age(180, 180)
|
||||
assert w == pytest.approx(0.5, rel=0.01)
|
||||
|
||||
|
||||
class TestSignalTracker:
|
||||
def test_record_signal(self, db_path, sample_state):
|
||||
from expectancy.tracker import SignalTracker
|
||||
tracker = SignalTracker()
|
||||
rid = tracker.record(
|
||||
date(2026, 3, 15), "B3", 98000.0, sample_state,
|
||||
signal_grade="A", signal_strength=75.0,
|
||||
)
|
||||
assert rid is not None
|
||||
assert rid > 0
|
||||
|
||||
def test_get_samples(self, db_path, sample_state):
|
||||
from expectancy.tracker import SignalTracker
|
||||
tracker = SignalTracker()
|
||||
tracker.record(date(2026, 3, 15), "B3", 98000.0, sample_state)
|
||||
tracker.record(date(2026, 3, 16), "B2", 98500.0, sample_state)
|
||||
|
||||
samples = tracker.get_samples(signal_type="B3")
|
||||
assert len(samples) == 1
|
||||
assert samples[0]["signal_type"] == "B3"
|
||||
|
||||
def test_count_samples(self, db_path, sample_state):
|
||||
from expectancy.tracker import SignalTracker
|
||||
tracker = SignalTracker()
|
||||
tracker.record(date(2026, 3, 15), "B3", 98000.0, sample_state)
|
||||
tracker.record(date(2026, 3, 16), "B3", 98500.0, sample_state)
|
||||
|
||||
counts = tracker.count_samples()
|
||||
assert "B3/TREND" in counts
|
||||
assert counts["B3/TREND"] == 2
|
||||
|
||||
def test_filter_by_regime(self, db_path, sample_state):
|
||||
from expectancy.tracker import SignalTracker
|
||||
tracker = SignalTracker()
|
||||
tracker.record(date(2026, 3, 15), "B3", 98000.0, sample_state)
|
||||
|
||||
samples = tracker.get_samples(signal_type="B3", regime="TREND")
|
||||
assert len(samples) == 1
|
||||
|
||||
samples = tracker.get_samples(signal_type="B3", regime="PANIC")
|
||||
assert len(samples) == 0
|
||||
|
||||
def test_backfill_signals(self, db_path, sample_state):
|
||||
from expectancy.tracker import SignalTracker
|
||||
tracker = SignalTracker()
|
||||
signals = [
|
||||
{"date": date(2026, 3, 15), "signal_type": "B3", "entry_price": 98000},
|
||||
{"date": date(2026, 3, 20), "signal_type": "B2", "entry_price": 99000},
|
||||
]
|
||||
count = tracker.backfill_signals(signals)
|
||||
assert count == 2
|
||||
|
||||
|
||||
class TestBayesianExpectancyEngine:
|
||||
def test_estimate_returns_report(self, db_path, sample_state):
|
||||
from expectancy.tracker import SignalTracker
|
||||
from expectancy.engine import BayesianExpectancyEngine
|
||||
|
||||
# Record some signals first
|
||||
tracker = SignalTracker()
|
||||
for i in range(10):
|
||||
tracker.record(
|
||||
date(2026, 3, 15) + timedelta(days=i),
|
||||
"B3", 98000.0, sample_state,
|
||||
)
|
||||
|
||||
engine = BayesianExpectancyEngine(level_min_samples=3)
|
||||
report = engine.estimate(sample_state, "B3", date(2026, 3, 25))
|
||||
assert report.signal_type == "B3"
|
||||
assert len(report.layers) > 0
|
||||
assert report.source in ("bayesian", "insufficient")
|
||||
|
||||
def test_insufficient_with_no_samples(self, db_path, sample_state):
|
||||
from expectancy.engine import BayesianExpectancyEngine
|
||||
engine = BayesianExpectancyEngine(level_min_samples=10)
|
||||
report = engine.estimate(sample_state, "B1", date(2026, 3, 25))
|
||||
assert report.sufficiency.value in ("INSUFFICIENT", "LOW", "MEDIUM", "HIGH")
|
||||
|
||||
def test_empirical_bayes_shrinks_small_samples(self, db_path, sample_state):
|
||||
"""With N=3, raw=100%, posterior should be pulled toward prior."""
|
||||
from expectancy.tracker import SignalTracker
|
||||
from expectancy.engine import BayesianExpectancyEngine
|
||||
|
||||
tracker = SignalTracker()
|
||||
for i in range(3):
|
||||
tracker.record(
|
||||
date(2026, 3, 15) + timedelta(days=i),
|
||||
"B3", 98000.0, sample_state,
|
||||
)
|
||||
|
||||
engine = BayesianExpectancyEngine(level_min_samples=1)
|
||||
report = engine.estimate(sample_state, "B3", date(2026, 3, 25))
|
||||
|
||||
# With small N, posterior should differ from raw
|
||||
base_layer = report.layers[0]
|
||||
if base_layer.raw_winrate and base_layer.samples < 50:
|
||||
# Posterior should be pulled toward prior (50% or global rate)
|
||||
if base_layer.raw_winrate > 0.8:
|
||||
assert base_layer.posterior_winrate < base_layer.raw_winrate
|
||||
|
||||
def test_leveled_fallback_stops_at_min_samples(self, db_path, sample_state):
|
||||
from expectancy.tracker import SignalTracker
|
||||
from expectancy.engine import BayesianExpectancyEngine
|
||||
|
||||
tracker = SignalTracker()
|
||||
for i in range(20):
|
||||
tracker.record(date(2026, 3, 15) + timedelta(days=i), "B3", 98000.0, sample_state)
|
||||
|
||||
engine = BayesianExpectancyEngine(level_min_samples=15)
|
||||
report = engine.estimate(sample_state, "B3", date(2026, 3, 25))
|
||||
# Should have stopped at a level with >= 15 effective samples
|
||||
assert report.final_estimate >= 0
|
||||
|
||||
|
||||
class TestSufficiencyGuard:
|
||||
def test_insufficient(self):
|
||||
from expectancy.engine import SufficiencyGuard
|
||||
from models import SufficiencyLevel
|
||||
g = SufficiencyGuard()
|
||||
assert g.evaluate(10) == SufficiencyLevel.INSUFFICIENT
|
||||
|
||||
def test_low(self):
|
||||
from expectancy.engine import SufficiencyGuard
|
||||
from models import SufficiencyLevel
|
||||
g = SufficiencyGuard()
|
||||
assert g.evaluate(40) == SufficiencyLevel.LOW
|
||||
|
||||
def test_high(self):
|
||||
from expectancy.engine import SufficiencyGuard
|
||||
from models import SufficiencyLevel
|
||||
g = SufficiencyGuard()
|
||||
assert g.evaluate(200) == SufficiencyLevel.HIGH
|
||||
@@ -1,130 +0,0 @@
|
||||
"""Test all Pydantic models and enums."""
|
||||
import pytest
|
||||
from datetime import date
|
||||
from models import (
|
||||
MarketRegime, OIState, BreadthBucket, VolRegime,
|
||||
MarketStateVector, FactorScore, RegimeResult,
|
||||
SignalFeatureRecord, ExpectancyReport, DailyOutput,
|
||||
FactorContribution, SufficiencyLevel, SignalGrade,
|
||||
)
|
||||
|
||||
|
||||
class TestEnums:
|
||||
def test_regime_values(self):
|
||||
assert MarketRegime.TREND.value == "TREND"
|
||||
assert MarketRegime.RANGE.value == "RANGE"
|
||||
assert MarketRegime.PANIC.value == "PANIC"
|
||||
|
||||
def test_oi_state_has_neutral(self):
|
||||
assert OIState.NEUTRAL.value == "Neutral"
|
||||
assert len(OIState) == 5
|
||||
|
||||
def test_breadth_bucket_values(self):
|
||||
assert BreadthBucket.EXTREME.value == "EXTREME"
|
||||
assert len(BreadthBucket) == 5
|
||||
|
||||
def test_vol_regime_values(self):
|
||||
assert VolRegime.LOW_VOL.value == "LOW_VOL"
|
||||
assert VolRegime.EXPLOSIVE_VOL.value == "EXPLOSIVE_VOL"
|
||||
|
||||
|
||||
class TestMarketStateVector:
|
||||
def test_minimal_construction(self):
|
||||
sv = MarketStateVector(
|
||||
date="2026-06-24",
|
||||
regime=MarketRegime.TREND,
|
||||
regime_confidence=0.82,
|
||||
regime_version="v1_price_breadth_vol",
|
||||
)
|
||||
assert sv.date == date(2026, 6, 24)
|
||||
assert sv.regime == MarketRegime.TREND
|
||||
assert sv.breadth_top50 == 50.0 # default
|
||||
|
||||
def test_date_string_parsing(self):
|
||||
sv = MarketStateVector(
|
||||
date="2026-01-15",
|
||||
regime=MarketRegime.RANGE,
|
||||
regime_confidence=0.55,
|
||||
regime_version="v1_price_breadth_vol",
|
||||
)
|
||||
assert sv.date == date(2026, 1, 15)
|
||||
|
||||
def test_compute_hash(self):
|
||||
sv = MarketStateVector(
|
||||
date="2026-06-24",
|
||||
regime=MarketRegime.TREND,
|
||||
regime_confidence=0.82,
|
||||
regime_version="v1_price_breadth_vol",
|
||||
breadth_bucket=BreadthBucket.EXTREME,
|
||||
oi_state=OIState.NEW_LONGS,
|
||||
volatility_regime=VolRegime.NORMAL_VOL,
|
||||
)
|
||||
h = sv.compute_hash()
|
||||
assert len(h) == 12
|
||||
# Same state = same hash
|
||||
sv2 = MarketStateVector(
|
||||
date="2026-06-25",
|
||||
regime=MarketRegime.TREND,
|
||||
regime_confidence=0.80,
|
||||
regime_version="v1_price_breadth_vol",
|
||||
breadth_bucket=BreadthBucket.EXTREME,
|
||||
oi_state=OIState.NEW_LONGS,
|
||||
volatility_regime=VolRegime.NORMAL_VOL,
|
||||
)
|
||||
assert sv2.compute_hash() == h
|
||||
|
||||
def test_state_embedding(self):
|
||||
sv = MarketStateVector(
|
||||
date="2026-06-24",
|
||||
regime=MarketRegime.TREND,
|
||||
regime_confidence=0.82,
|
||||
regime_version="v1_price_breadth_vol",
|
||||
breadth_top20=80.0,
|
||||
breadth_top30=75.0,
|
||||
breadth_top50=70.0,
|
||||
regime_maturity_score=60.0,
|
||||
)
|
||||
emb = sv.state_embedding()
|
||||
assert len(emb) == 5
|
||||
assert emb[0] == 80.0
|
||||
assert emb[3] == 60.0
|
||||
|
||||
|
||||
class TestRegimeResult:
|
||||
def test_construction(self):
|
||||
r = RegimeResult(
|
||||
date="2026-06-24",
|
||||
regime=MarketRegime.TREND,
|
||||
confidence=0.82,
|
||||
regime_version="v1_price_breadth_vol",
|
||||
maturity_score=55.0,
|
||||
all_scores={"TREND": 82.0, "RANGE": 45.0, "PANIC": 20.0},
|
||||
confirmation_days=5,
|
||||
)
|
||||
assert r.regime == MarketRegime.TREND
|
||||
assert r.confirmation_days == 5
|
||||
|
||||
|
||||
class TestExpectancyReport:
|
||||
def test_insufficient(self):
|
||||
r = ExpectancyReport(
|
||||
signal_type="B3",
|
||||
date="2026-06-24",
|
||||
final_estimate=0.0,
|
||||
sufficiency=SufficiencyLevel.INSUFFICIENT,
|
||||
source="insufficient",
|
||||
)
|
||||
assert r.final_estimate == 0.0
|
||||
assert r.sufficiency == SufficiencyLevel.INSUFFICIENT
|
||||
|
||||
|
||||
class TestFactorContribution:
|
||||
def test_construction(self):
|
||||
fc = FactorContribution(
|
||||
factor="ETF Flow",
|
||||
raw_score=85.0,
|
||||
weight=0.1925,
|
||||
impact=6.7,
|
||||
direction="bullish",
|
||||
)
|
||||
assert fc.impact > 0
|
||||
@@ -1,109 +0,0 @@
|
||||
"""Test regime detector and validation."""
|
||||
import pytest
|
||||
from datetime import date
|
||||
import pandas as pd
|
||||
import numpy as np
|
||||
|
||||
|
||||
class TestRegimeDetector:
|
||||
def test_detects_trend(self):
|
||||
from regime_detector import RegimeDetector
|
||||
from models import MarketRegime
|
||||
d = RegimeDetector()
|
||||
r = d.detect(75.0, 80.0, "NORMAL_VOL", date(2026, 6, 24))
|
||||
assert r.regime == MarketRegime.TREND
|
||||
assert r.confidence > 0.5
|
||||
|
||||
def test_detects_range(self):
|
||||
from regime_detector import RegimeDetector
|
||||
from models import MarketRegime
|
||||
d = RegimeDetector()
|
||||
r = d.detect(50.0, 50.0, "LOW_VOL", date(2026, 6, 24))
|
||||
assert r.regime in (MarketRegime.RANGE, MarketRegime.TREND)
|
||||
|
||||
def test_detects_panic(self):
|
||||
from regime_detector import RegimeDetector
|
||||
from models import MarketRegime
|
||||
d = RegimeDetector()
|
||||
r = d.detect(15.0, 10.0, "EXPLOSIVE_VOL", date(2026, 6, 24))
|
||||
assert r.regime == MarketRegime.PANIC
|
||||
|
||||
def test_2day_confirmation(self):
|
||||
from regime_detector import RegimeDetector
|
||||
from models import MarketRegime
|
||||
d = RegimeDetector()
|
||||
# Day 1: RANGE
|
||||
r1 = d.detect(50.0, 50.0, "LOW_VOL", date(2026, 6, 24))
|
||||
assert r1.regime == MarketRegime.RANGE # first run, no confirmation needed
|
||||
# Day 2: still RANGE
|
||||
r2 = d.detect(50.0, 50.0, "LOW_VOL", date(2026, 6, 25))
|
||||
assert r2.regime == MarketRegime.RANGE
|
||||
assert r2.confirmation_days == 2
|
||||
|
||||
def test_transition_needs_confirmation(self):
|
||||
from regime_detector import RegimeDetector
|
||||
from models import MarketRegime
|
||||
d = RegimeDetector()
|
||||
# Establish TREND
|
||||
d.detect(75.0, 80.0, "NORMAL_VOL", date(2026, 6, 24))
|
||||
d.detect(75.0, 80.0, "NORMAL_VOL", date(2026, 6, 25))
|
||||
# Day 3: weak scores → raw best = RANGE, but TREND should persist
|
||||
r3 = d.detect(35.0, 40.0, "NORMAL_VOL", date(2026, 6, 26))
|
||||
# First day of pending transition — should still be TREND
|
||||
assert r3.regime == MarketRegime.TREND
|
||||
assert d.pending_regime is not None
|
||||
|
||||
def test_version_is_stored(self):
|
||||
from regime_detector import RegimeDetector
|
||||
d = RegimeDetector(regime_version="v1_price_breadth_vol")
|
||||
r = d.detect(75.0, 80.0, "NORMAL_VOL", date(2026, 6, 24))
|
||||
assert r.regime_version == "v1_price_breadth_vol"
|
||||
|
||||
def test_load_state(self, db_path):
|
||||
from regime_detector import RegimeDetector
|
||||
from models import MarketRegime
|
||||
d = RegimeDetector()
|
||||
d.load_state(db_path)
|
||||
# DB has TREND for first 100 days, so most recent should load
|
||||
assert d.current_regime is not None
|
||||
|
||||
def test_confidence_for_confirmed_regime(self):
|
||||
"""Confidence should be for the confirmed regime, not raw best."""
|
||||
from regime_detector import RegimeDetector
|
||||
from models import MarketRegime
|
||||
d = RegimeDetector()
|
||||
# Establish TREND
|
||||
d.detect(75.0, 80.0, "NORMAL_VOL", date(2026, 6, 24))
|
||||
d.detect(75.0, 80.0, "NORMAL_VOL", date(2026, 6, 25))
|
||||
# Now feed weak scores → raw best would be PANIC or RANGE
|
||||
r = d.detect(15.0, 10.0, "EXPLOSIVE_VOL", date(2026, 6, 26))
|
||||
# Should still report TREND (need 2 confirmations to switch)
|
||||
assert r.regime == MarketRegime.TREND
|
||||
|
||||
|
||||
class TestTransitionValidator:
|
||||
def test_stable_regime_passes(self):
|
||||
from validation.transition_validator import TransitionValidator
|
||||
# Create stable regime sequence: long periods
|
||||
seq = pd.Series(
|
||||
["TREND"] * 50 + ["RANGE"] * 50 + ["PANIC"] * 40,
|
||||
index=pd.date_range("2026-01-01", periods=140),
|
||||
)
|
||||
tv = TransitionValidator()
|
||||
report = tv.validate(seq)
|
||||
assert report.is_stable
|
||||
assert report.avg_duration > 20
|
||||
assert report.flip_rate < 0.05
|
||||
|
||||
def test_unstable_regime_fails(self):
|
||||
from validation.transition_validator import TransitionValidator
|
||||
# Create unstable sequence: flips every 2 days
|
||||
seq = pd.Series(
|
||||
["TREND", "TREND", "RANGE", "RANGE", "TREND", "TREND",
|
||||
"PANIC", "PANIC", "RANGE", "RANGE"] * 5,
|
||||
index=pd.date_range("2026-01-01", periods=50),
|
||||
)
|
||||
tv = TransitionValidator()
|
||||
report = tv.validate(seq)
|
||||
assert not report.is_stable
|
||||
assert report.flip_rate > 0.15
|
||||
@@ -1,121 +0,0 @@
|
||||
"""Test all 4 core scorers."""
|
||||
import pytest
|
||||
from datetime import date
|
||||
|
||||
|
||||
class TestPriceStructureScorer:
|
||||
def test_computes_score(self, db_path):
|
||||
from scoring.price_structure import PriceStructureScorer
|
||||
scorer = PriceStructureScorer()
|
||||
result = scorer.compute(date(2026, 3, 15))
|
||||
assert result.name == "Price Structure"
|
||||
assert 0 <= result.score <= 100
|
||||
assert result.trend_strength >= 0
|
||||
assert result.volatility_compression >= 0
|
||||
assert result.momentum >= 0
|
||||
assert result.label
|
||||
|
||||
def test_bullish_in_trend(self, db_path):
|
||||
from scoring.price_structure import PriceStructureScorer
|
||||
scorer = PriceStructureScorer()
|
||||
result = scorer.compute(date(2025, 11, 15)) # TREND period
|
||||
assert result.score > 50 # Should be bullish in uptrend
|
||||
|
||||
def test_bearish_in_panic(self, db_path):
|
||||
from scoring.price_structure import PriceStructureScorer
|
||||
scorer = PriceStructureScorer()
|
||||
result = scorer.compute(date(2026, 5, 15)) # PANIC period
|
||||
# In panic period, EMA alignment should be bearish
|
||||
assert result.trend_strength < 60
|
||||
|
||||
def test_no_data_handling(self, db_path):
|
||||
from scoring.price_structure import PriceStructureScorer
|
||||
scorer = PriceStructureScorer()
|
||||
result = scorer.compute(date(2020, 1, 1))
|
||||
assert result.score == 50.0
|
||||
assert result.label == "No Data"
|
||||
|
||||
|
||||
class TestBreadthScorer:
|
||||
def test_computes_score(self, db_path):
|
||||
from scoring.breadth_scorer import BreadthScorer
|
||||
scorer = BreadthScorer()
|
||||
result = scorer.compute(date(2026, 3, 15))
|
||||
assert result.name == "Breadth"
|
||||
assert 0 <= result.score <= 100
|
||||
assert result.breadth_bucket
|
||||
assert result.breadth_top20 >= 0
|
||||
assert result.breadth_top50 >= 0
|
||||
|
||||
def test_tier_values(self, db_path):
|
||||
from scoring.breadth_scorer import BreadthScorer
|
||||
scorer = BreadthScorer()
|
||||
result = scorer.compute(date(2025, 11, 15)) # TREND period
|
||||
# Top20 should generally be higher than Top50 (large caps lead)
|
||||
assert result.breadth_top20 >= 0
|
||||
assert result.breadth_top50 >= 0
|
||||
|
||||
def test_bucket_assignment(self, db_path):
|
||||
from scoring.breadth_scorer import BreadthScorer, BreadthBucket
|
||||
scorer = BreadthScorer()
|
||||
result = scorer.compute(date(2025, 11, 15)) # TREND: adv=42/50
|
||||
assert result.breadth_bucket in (
|
||||
BreadthBucket.EXTREME, BreadthBucket.STRONG, BreadthBucket.NORMAL
|
||||
)
|
||||
|
||||
def test_no_data(self, db_path):
|
||||
from scoring.breadth_scorer import BreadthScorer
|
||||
scorer = BreadthScorer()
|
||||
result = scorer.compute(date(2020, 1, 1))
|
||||
assert result.score == 50.0
|
||||
|
||||
|
||||
class TestOIMatrixScorer:
|
||||
def test_computes_state(self, db_path):
|
||||
from scoring.oi_matrix import OIMatrixScorer, OIState
|
||||
scorer = OIMatrixScorer()
|
||||
result = scorer.compute(date(2025, 11, 15)) # TREND period, oi_chg=+3.5
|
||||
assert result.oi_state in OIState
|
||||
assert 0 <= result.score <= 100
|
||||
|
||||
def test_new_longs_in_trend(self, db_path):
|
||||
from scoring.oi_matrix import OIMatrixScorer, OIState
|
||||
scorer = OIMatrixScorer()
|
||||
# Test multiple dates in TREND period — at least one should be NEW_LONGS or NEUTRAL
|
||||
found_bullish = False
|
||||
for d in ["2025-11-15", "2025-11-20", "2025-12-01", "2025-12-15"]:
|
||||
result = scorer.compute(date.fromisoformat(d))
|
||||
if result.oi_state in (OIState.NEW_LONGS, OIState.SHORT_COVERING, OIState.NEUTRAL):
|
||||
found_bullish = True
|
||||
break
|
||||
assert found_bullish, "No bullish OI state found in TREND period"
|
||||
|
||||
def test_no_data(self, db_path):
|
||||
from scoring.oi_matrix import OIMatrixScorer
|
||||
scorer = OIMatrixScorer()
|
||||
result = scorer.compute(date(2020, 1, 1))
|
||||
assert result.score == 50.0
|
||||
assert result.label == "No Data"
|
||||
|
||||
|
||||
class TestVolatilityRegimeScorer:
|
||||
def test_computes_regime(self, db_path):
|
||||
from scoring.volatility_regime import VolatilityRegimeScorer, VolRegime
|
||||
scorer = VolatilityRegimeScorer()
|
||||
result = scorer.compute(date(2026, 3, 15))
|
||||
assert result.vol_regime in VolRegime
|
||||
assert 0 <= result.score <= 100
|
||||
|
||||
def test_higher_vol_in_panic(self, db_path):
|
||||
from scoring.volatility_regime import VolatilityRegimeScorer, VolRegime
|
||||
scorer = VolatilityRegimeScorer()
|
||||
trend_result = scorer.compute(date(2025, 11, 15))
|
||||
panic_result = scorer.compute(date(2026, 5, 15))
|
||||
# PANIC period has higher ATR → higher vol regime or score
|
||||
assert panic_result.atr_pct >= trend_result.atr_pct * 0.5 # at least comparable
|
||||
|
||||
def test_no_data(self, db_path):
|
||||
from scoring.volatility_regime import VolatilityRegimeScorer
|
||||
scorer = VolatilityRegimeScorer()
|
||||
result = scorer.compute(date(2020, 1, 1))
|
||||
assert result.score == 50.0
|
||||
Reference in New Issue
Block a user