matitos
9dc00eba95
Trailing stops: strategies can pass trailing_stop_pct to enter_long/enter_short. advance_trailing_stop in app/engine/portfolio.py ratchets the stop with the price (up for longs, down for shorts) and never loosens; the engine persists the ratcheted level and the backtester applies the same logic. Position gains a trailing_stop_pct column (additive migration). momentum exposes it as a param. Parameter sweeps: app/backtest/sweep.py runs a cartesian grid through the same backtester and ranks by return minus max drawdown. POST /api/sweep plus a dashboard Parameter sweep panel.
173 lines
6.1 KiB
Python
173 lines
6.1 KiB
Python
from __future__ import annotations
|
|
|
|
from typing import ClassVar
|
|
|
|
import pytest
|
|
|
|
from app.backtest import Backtester
|
|
from app.backtest.metrics import max_drawdown_pct, sharpe_ratio
|
|
from app.engine.strategies.base import Strategy, StrategyContext
|
|
from app.schemas import BacktestPointOut, BacktestTradeOut, Candle
|
|
|
|
|
|
class HoldStrategy(Strategy):
|
|
"""Enter long on the first candle and stay in (closed at end of data)."""
|
|
|
|
key: ClassVar[str] = "test_hold"
|
|
name: ClassVar[str] = "Test Hold"
|
|
default_params: ClassVar[dict] = {}
|
|
|
|
def on_candle(self, ctx: StrategyContext) -> None:
|
|
if ctx.is_flat:
|
|
ctx.enter_long(size=1.0)
|
|
|
|
|
|
class NeverStrategy(Strategy):
|
|
key: ClassVar[str] = "test_never"
|
|
name: ClassVar[str] = "Test Never"
|
|
default_params: ClassVar[dict] = {}
|
|
|
|
def on_candle(self, ctx: StrategyContext) -> None:
|
|
return None
|
|
|
|
|
|
class StopStrategy(Strategy):
|
|
key: ClassVar[str] = "test_stop"
|
|
name: ClassVar[str] = "Test Stop"
|
|
default_params: ClassVar[dict] = {}
|
|
|
|
def on_candle(self, ctx: StrategyContext) -> None:
|
|
if ctx.is_flat and not getattr(self, "_entered", False):
|
|
self._entered = True
|
|
ctx.enter_long(size=1.0, stop_loss=ctx.price * 0.9)
|
|
|
|
|
|
def candles_from_closes(closes: list[float]) -> list[Candle]:
|
|
return [Candle(ts=i, open=c, high=c, low=c, close=c, volume=1.0) for i, c in enumerate(closes)]
|
|
|
|
|
|
def test_hold_backtest_math() -> None:
|
|
backtester = Backtester(fee_bps=0, slippage_bps=0, starting_balance=10_000)
|
|
result = backtester.run(candles_from_closes([100, 110, 120]), HoldStrategy(), "BTC/USDT", "1h")
|
|
|
|
assert result.error is None
|
|
assert result.metrics.num_trades == 1
|
|
# 99 units bought at 100 (cash capped at 99%), closed at 120.
|
|
assert result.metrics.final_equity == pytest.approx(11_980.0)
|
|
assert result.trades[0].pnl == pytest.approx(1_980.0)
|
|
assert result.trades[0].return_pct == pytest.approx(20.0)
|
|
assert result.trades[0].reason == "end of data"
|
|
assert len(result.equity_curve) == 3
|
|
|
|
|
|
def test_no_trades_leaves_balance_untouched() -> None:
|
|
backtester = Backtester(fee_bps=10, slippage_bps=5, starting_balance=5_000)
|
|
result = backtester.run(
|
|
candles_from_closes([100, 101, 102, 103]), NeverStrategy(), "BTC/USDT", "1m"
|
|
)
|
|
assert result.metrics.num_trades == 0
|
|
assert result.metrics.final_equity == pytest.approx(5_000.0)
|
|
assert result.metrics.total_return_pct == pytest.approx(0.0)
|
|
assert result.metrics.max_drawdown_pct == pytest.approx(0.0)
|
|
|
|
|
|
def test_stop_loss_is_honoured() -> None:
|
|
backtester = Backtester(fee_bps=0, slippage_bps=0, starting_balance=10_000)
|
|
candles = candles_from_closes([100, 100, 80])
|
|
candles[2] = Candle(ts=2, open=100, high=100, low=80, close=80, volume=1.0)
|
|
result = backtester.run(candles, StopStrategy(), "BTC/USDT", "1h")
|
|
|
|
assert result.metrics.num_trades == 1
|
|
assert "stop loss" in result.trades[0].reason
|
|
assert result.metrics.final_equity < 10_000
|
|
|
|
|
|
class TrailStrategy(Strategy):
|
|
key: ClassVar[str] = "test_trail"
|
|
name: ClassVar[str] = "Test Trail"
|
|
default_params: ClassVar[dict] = {}
|
|
|
|
def on_candle(self, ctx: StrategyContext) -> None:
|
|
if ctx.is_flat and not getattr(self, "_entered", False):
|
|
self._entered = True
|
|
ctx.enter_long(size=1.0, trailing_stop_pct=0.10)
|
|
|
|
|
|
def test_trailing_stop_locks_in_profit() -> None:
|
|
# Entry at 100, rise to 150, then a reversal. A 10% trail should exit near
|
|
# 135 (150 * 0.9) instead of round-tripping to the entry.
|
|
backtester = Backtester(fee_bps=0, slippage_bps=0, starting_balance=10_000)
|
|
candles = candles_from_closes([100, 120, 150, 130, 125, 120])
|
|
candles[2] = Candle(ts=2, open=120, high=150, low=120, close=150, volume=1.0)
|
|
candles[3] = Candle(ts=3, open=150, high=150, low=130, close=130, volume=1.0)
|
|
candles[4] = Candle(ts=4, open=130, high=132, low=125, close=125, volume=1.0)
|
|
candles[5] = Candle(ts=5, open=125, high=128, low=120, close=120, volume=1.0)
|
|
result = backtester.run(candles, TrailStrategy(), "BTC/USDT", "1h")
|
|
|
|
assert result.metrics.num_trades == 1
|
|
trade = result.trades[0]
|
|
assert "stop loss" in trade.reason
|
|
# 99 units, exit at the trailing stop (135), well above entry 100.
|
|
assert trade.exit_price == pytest.approx(135.0)
|
|
assert result.metrics.final_equity > 10_000
|
|
|
|
|
|
def test_strategy_error_is_surfaced() -> None:
|
|
class Boom(Strategy):
|
|
key = "test_boom"
|
|
name = "Boom"
|
|
default_params: ClassVar[dict] = {}
|
|
|
|
def on_candle(self, ctx: StrategyContext) -> None:
|
|
raise RuntimeError("kaboom")
|
|
|
|
result = Backtester().run(candles_from_closes([1, 2, 3]), Boom(), "BTC/USDT", "1m")
|
|
assert result.error is not None and "kaboom" in result.error
|
|
|
|
|
|
def test_max_drawdown() -> None:
|
|
assert max_drawdown_pct([100, 120, 90, 130]) == pytest.approx(25.0)
|
|
assert max_drawdown_pct([100, 100, 100]) == pytest.approx(0.0)
|
|
|
|
|
|
def test_sharpe_none_for_unknown_timeframe() -> None:
|
|
assert sharpe_ratio([100, 101, 102, 103], "nonsense") is None
|
|
|
|
|
|
def _points(equities: list[float]) -> list[BacktestPointOut]:
|
|
return [BacktestPointOut(ts=i, equity=e, buy_hold=e, price=e) for i, e in enumerate(equities)]
|
|
|
|
|
|
def test_metrics_profit_factor_and_win_rate() -> None:
|
|
from app.backtest.metrics import compute_metrics
|
|
|
|
trades = [
|
|
BacktestTradeOut(
|
|
side="long",
|
|
entry_ts=0,
|
|
exit_ts=1,
|
|
entry_price=100,
|
|
exit_price=110,
|
|
qty=1,
|
|
pnl=10,
|
|
return_pct=10,
|
|
reason="x",
|
|
),
|
|
BacktestTradeOut(
|
|
side="long",
|
|
entry_ts=2,
|
|
exit_ts=3,
|
|
entry_price=100,
|
|
exit_price=95,
|
|
qty=1,
|
|
pnl=-5,
|
|
return_pct=-5,
|
|
reason="x",
|
|
),
|
|
]
|
|
metrics = compute_metrics(_points([10_000, 10_010, 10_005]), trades, 10_000, "1h")
|
|
assert metrics.win_rate_pct == pytest.approx(50.0)
|
|
assert metrics.profit_factor == pytest.approx(2.0)
|
|
assert metrics.best_trade_pct == pytest.approx(10.0)
|
|
assert metrics.worst_trade_pct == pytest.approx(-5.0)
|