mirror of
https://github.com/freqtrade/freqtrade.git
synced 2026-05-07 22:44:22 +00:00
211 lines
7.9 KiB
Python
211 lines
7.9 KiB
Python
from datetime import timedelta
|
|
|
|
import pytest
|
|
from pandas import DataFrame, Timestamp
|
|
|
|
from freqtrade.data.btanalysis import (
|
|
analyze_trade_parallelism,
|
|
load_backtest_data,
|
|
)
|
|
from freqtrade.data.btanalysis.trade_parallelism import balance_distribution_over_time
|
|
from freqtrade.util import dt_utc
|
|
|
|
|
|
def test_analyze_trade_parallelism(testdatadir):
|
|
filename = testdatadir / "backtest_results/backtest-result.json"
|
|
bt_data = load_backtest_data(filename)
|
|
|
|
res = analyze_trade_parallelism(bt_data, "5m")
|
|
assert isinstance(res, DataFrame)
|
|
assert "open_trades" in res.columns
|
|
assert res["open_trades"].max() == 3
|
|
assert res["open_trades"].min() == 0
|
|
|
|
|
|
@pytest.mark.parametrize("is_short", [False, True])
|
|
def test_balance_distribution_over_time(is_short):
|
|
"""
|
|
Test balance_distribution_over_time for both long and short trades.
|
|
"""
|
|
# Create a minimal trades DataFrame with 4 trades over time
|
|
# Base dates for trades
|
|
start_date = dt_utc(2023, 1, 1)
|
|
base_date = start_date + timedelta(hours=15)
|
|
stake_currency = "USDT"
|
|
start_balance = 1000.0
|
|
fee = 0.001 # 0.1% fee
|
|
|
|
# Create trades spanning different time periods
|
|
trades_data = {
|
|
"pair": ["BTC/USDT", "ETH/USDT", "XRP/USDT", "LTC/USDT"],
|
|
"stake_amount": [100.0, 150.0, 80.0, 120.0],
|
|
"open_date": [
|
|
base_date,
|
|
base_date + timedelta(hours=2),
|
|
base_date + timedelta(hours=5),
|
|
base_date + timedelta(hours=8),
|
|
],
|
|
"close_date": [
|
|
base_date + timedelta(hours=3),
|
|
base_date + timedelta(hours=6),
|
|
base_date + timedelta(hours=9),
|
|
base_date + timedelta(hours=12),
|
|
],
|
|
"open_rate": [40000.0, 2000.0, 0.5, 100.0],
|
|
"close_rate": [41000.0, 2100.0, 0.52, 105.0],
|
|
"fee_open": [fee, fee, fee, fee],
|
|
"fee_close": [fee, fee, fee, fee],
|
|
"is_short": [is_short, is_short, is_short, is_short],
|
|
"leverage": [1.0, 1.0, 1.0, 1.0],
|
|
"orders": [
|
|
# Trade 1: BTC/USDT - entry at 40000, exit at 41000
|
|
[
|
|
{
|
|
"amount": 0.0025, # 100 / 40000
|
|
"filled": 0.0025,
|
|
"safe_price": 40000.0,
|
|
"ft_order_side": "sell" if is_short else "buy",
|
|
"order_filled_timestamp": int(base_date.timestamp() * 1000),
|
|
"ft_is_entry": True,
|
|
},
|
|
{
|
|
"amount": 0.0025,
|
|
"filled": 0.0025,
|
|
"safe_price": 41000.0,
|
|
"ft_order_side": "buy" if is_short else "sell",
|
|
"order_filled_timestamp": int(
|
|
(base_date + timedelta(hours=3)).timestamp() * 1000
|
|
),
|
|
"ft_is_entry": False,
|
|
},
|
|
],
|
|
# Trade 2: ETH/USDT - entry at 2000, exit at 2100
|
|
[
|
|
{
|
|
"amount": 0.075, # 150 / 2000
|
|
"filled": 0.075,
|
|
"safe_price": 2000.0,
|
|
"ft_order_side": "sell" if is_short else "buy",
|
|
"order_filled_timestamp": int(
|
|
(base_date + timedelta(hours=2)).timestamp() * 1000
|
|
),
|
|
"ft_is_entry": True,
|
|
},
|
|
{
|
|
"amount": 0.075,
|
|
"filled": 0.075,
|
|
"safe_price": 2100.0,
|
|
"ft_order_side": "buy" if is_short else "sell",
|
|
"order_filled_timestamp": int(
|
|
(base_date + timedelta(hours=6)).timestamp() * 1000
|
|
),
|
|
"ft_is_entry": False,
|
|
},
|
|
],
|
|
# Trade 3: XRP/USDT - entry at 0.5, exit at 0.52
|
|
[
|
|
{
|
|
"amount": 160.0, # 80 / 0.5
|
|
"filled": 160.0,
|
|
"safe_price": 0.5,
|
|
"ft_order_side": "sell" if is_short else "buy",
|
|
"order_filled_timestamp": int(
|
|
(base_date + timedelta(hours=5)).timestamp() * 1000
|
|
),
|
|
"ft_is_entry": True,
|
|
},
|
|
{
|
|
"amount": 160.0,
|
|
"filled": 160.0,
|
|
"safe_price": 0.52,
|
|
"ft_order_side": "buy" if is_short else "sell",
|
|
"order_filled_timestamp": int(
|
|
(base_date + timedelta(hours=9)).timestamp() * 1000
|
|
),
|
|
"ft_is_entry": False,
|
|
},
|
|
],
|
|
# Trade 4: LTC/USDT - entry at 100, exit at 105
|
|
[
|
|
{
|
|
"amount": 1.2, # 120 / 100
|
|
"filled": 1.2,
|
|
"safe_price": 100.0,
|
|
"ft_order_side": "sell" if is_short else "buy",
|
|
"order_filled_timestamp": int(
|
|
(base_date + timedelta(hours=8)).timestamp() * 1000
|
|
),
|
|
"ft_is_entry": True,
|
|
},
|
|
{
|
|
"amount": 1.2,
|
|
"filled": 1.2,
|
|
"safe_price": 105.0,
|
|
"ft_order_side": "buy" if is_short else "sell",
|
|
"order_filled_timestamp": int(
|
|
(base_date + timedelta(hours=12)).timestamp() * 1000
|
|
),
|
|
"ft_is_entry": False,
|
|
},
|
|
],
|
|
],
|
|
}
|
|
|
|
trades_df = DataFrame(trades_data)
|
|
pairlist = ["BTC/USDT", "ETH/USDT", "XRP/USDT", "LTC/USDT"]
|
|
|
|
min_date = start_date
|
|
max_date = start_date + timedelta(hours=35)
|
|
|
|
result = balance_distribution_over_time(
|
|
trades=trades_df,
|
|
min_date=min_date,
|
|
max_date=max_date,
|
|
timeframe="1h",
|
|
stake_currency=stake_currency,
|
|
start_balance=start_balance,
|
|
pairlist=pairlist,
|
|
)
|
|
|
|
# Verify basic structure
|
|
assert isinstance(result, DataFrame)
|
|
assert stake_currency in result.columns
|
|
for pair in pairlist:
|
|
assert pair in result.columns
|
|
assert f"{pair}_leverage" in result.columns
|
|
assert f"{pair}_is_short" in result.columns
|
|
assert f"{pair}_collateral" in result.columns
|
|
|
|
# Verify the index is a DatetimeIndex
|
|
assert isinstance(result.index, Timestamp.__class__.__bases__[0])
|
|
|
|
# Verify we have entries over the full time period (36h)
|
|
assert len(result) == 36
|
|
|
|
# First trade opens 15h after the start date
|
|
assert result.iloc[0][stake_currency] == 1000
|
|
expected_first_balance = start_balance - (100.0 + 100.0 * fee)
|
|
assert result.iloc[15][stake_currency] == pytest.approx(expected_first_balance)
|
|
|
|
# Check that pair columns have non-zero values during trade periods
|
|
# Trade 1 (BTC/USDT) is open from hour 15 to hour 18
|
|
# At hour 16, BTC/USDT should have position
|
|
btc_during_trade = result.loc[base_date + timedelta(hours=1), "BTC/USDT"]
|
|
assert btc_during_trade > 0, "Trade should have positive position during open period"
|
|
|
|
# After Trade 1 closes at hour 3, BTC/USDT position should be 0
|
|
btc_after_close = result.loc[base_date + timedelta(hours=4) :, "BTC/USDT"]
|
|
assert all(btc_after_close == 0), "Position should be 0 after trade closes"
|
|
|
|
# Final stake currency should reflect all trades' cash flows minus fees
|
|
final_balance = result.iloc[-1][stake_currency]
|
|
|
|
# Verify the balance changed (trades had effect)
|
|
assert final_balance != start_balance, "Balance should change after trading"
|
|
|
|
# Since all exit prices > entry prices, exits return more cash than entries spent
|
|
# This means final balance > start balance for long trades and < start balance for short trades
|
|
assert (final_balance > start_balance) if not is_short else (final_balance < start_balance), (
|
|
"Balance increases for long and decreases for short trades"
|
|
)
|