"""

Test 8: compute_metrics with known inputs.

"""

import numpy as np

import pandas as pd

import pytest

from src.analysis.performance import compute_metrics, compute_metrics_with_positions

TRADING_DAYS = 252

# ---------------------------------------------------------------------------

# Helpers

# ---------------------------------------------------------------------------

def _pnl(values):

return pd.Series(values, dtype=float)

# ---------------------------------------------------------------------------

# Constant positive PnL

# ---------------------------------------------------------------------------

class TestConstantPositivePnL:

def setup_method(self):

self.pnl = _pnl([1.0] * TRADING_DAYS)

self.m = compute_metrics(self.pnl)

def test_sharpe_is_nan_or_very_large(self):

# std = 0 → Sharpe is undefined; implementation returns NaN

assert np.isnan(self.m["sharpe"])

def test_max_drawdown_is_zero(self):

assert self.m["max_drawdown"] == 0.0

def test_annual_return_positive(self):

assert self.m["annual_return"] == pytest.approx(TRADING_DAYS * 1.0)

def test_win_rate_is_one(self):

assert self.m["win_rate"] == pytest.approx(1.0)

# ---------------------------------------------------------------------------

# Alternating +1 / -1 PnL

# ---------------------------------------------------------------------------

class TestAlternatingPnL:

def setup_method(self):

values = [1.0 if i % 2 == 0 else -1.0 for i in range(TRADING_DAYS)]

self.pnl = _pnl(values)

self.m = compute_metrics(self.pnl)

def test_sharpe_near_zero(self):

assert abs(self.m["sharpe"]) < 0.1

def test_win_rate_near_half(self):

assert self.m["win_rate"] == pytest.approx(0.5)

def test_max_drawdown_negative(self):

assert self.m["max_drawdown"] < 0

def test_annual_return_near_zero(self):

assert abs(self.m["annual_return"]) < 1.0

# ---------------------------------------------------------------------------

# Edge cases

# ---------------------------------------------------------------------------

def test_empty_series_returns_all_nan():

m = compute_metrics(_pnl([]))

for key in ("sharpe", "max_drawdown", "annual_return", "win_rate", "turnover"):

assert np.isnan(m[key]), f"{key} should be NaN for empty series"

def test_all_nan_series_returns_all_nan():

m = compute_metrics(_pnl([np.nan, np.nan, np.nan]))

for key in ("sharpe", "max_drawdown", "annual_return", "win_rate"):

assert np.isnan(m[key])

def test_all_zeros_win_rate_is_nan():

# No active (non-zero) days → win rate undefined

m = compute_metrics(_pnl([0.0] * 20))

assert np.isnan(m["win_rate"])

def test_sharpe_sign_matches_return():

pos_pnl = _pnl([0.1] * 50 + [-0.01] * 50)

neg_pnl = _pnl([-0.1] * 50 + [0.01] * 50)

assert compute_metrics(pos_pnl)["sharpe"] > 0

assert compute_metrics(neg_pnl)["sharpe"] < 0

def test_max_drawdown_known_sequence():

# Equity: 0 → 3 → 2 → 5 → 1 → max DD = 1 - 5 = -4

pnl = _pnl([3.0, -1.0, 3.0, -4.0])

m = compute_metrics(pnl)

assert m["max_drawdown"] == pytest.approx(-4.0)

# ---------------------------------------------------------------------------

# Turnover via compute_metrics_with_positions

# ---------------------------------------------------------------------------

def test_turnover_full_reversal_every_day():

# Position alternates +1 / -1 → daily change = 2 → turnover = 2

pos = _pnl([1.0, -1.0, 1.0, -1.0, 1.0])

pnl = _pnl([0.1] * 5)

m = compute_metrics_with_positions(pnl, pos)

assert m["turnover"] == pytest.approx(2.0)

def test_turnover_no_trades():

pos = _pnl([1.0, 1.0, 1.0, 1.0])

pnl = _pnl([0.1] * 4)

m = compute_metrics_with_positions(pnl, pos)

assert m["turnover"] == pytest.approx(0.0)