You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
234 lines
8.5 KiB
Python
234 lines
8.5 KiB
Python
from unittest.mock import Mock, patch
|
|
|
|
from django.test import TestCase
|
|
|
|
from core.exchanges.convert import convert_trades
|
|
from core.lib.schemas.oanda_s import parse_time
|
|
from core.models import Account, ActiveManagementPolicy, Hook, Signal, User
|
|
from core.tests.helpers import StrategyMixin, SymbolPriceMock
|
|
from core.trading.active_management import ActiveManagement
|
|
|
|
|
|
class ActiveManagementTestCase(StrategyMixin, SymbolPriceMock, TestCase):
|
|
def setUp(self):
|
|
self.user = User.objects.create_user(
|
|
username="testuser", email="test@example.com", password="test"
|
|
)
|
|
self.account = Account.objects.create(
|
|
user=self.user,
|
|
name="Test Account",
|
|
exchange="fake",
|
|
currency="USD",
|
|
)
|
|
self.account.supported_symbols = ["EUR_USD", "EUR_XXX", "USD_EUR", "XXX_EUR"]
|
|
self.account.save()
|
|
super().setUp()
|
|
self.active_management_policy = ActiveManagementPolicy.objects.create(
|
|
user=self.user,
|
|
name="Test Policy",
|
|
when_trading_time_violated="close",
|
|
when_trends_violated="close",
|
|
when_position_size_violated="close",
|
|
when_protection_violated="close",
|
|
when_asset_groups_violated="close",
|
|
when_max_open_trades_violated="close",
|
|
when_max_open_trades_per_symbol_violated="close",
|
|
when_max_loss_violated="close",
|
|
when_max_risk_violated="close",
|
|
when_crossfilter_violated="close",
|
|
)
|
|
|
|
self.strategy.active_management_policy = self.active_management_policy
|
|
self.strategy.save()
|
|
self.ams = ActiveManagement(self.strategy)
|
|
self.trades = [
|
|
{
|
|
"id": "20083",
|
|
"symbol": "EUR_USD",
|
|
"price": "1.06331",
|
|
"openTime": "2023-02-13T11:38:06.302917985Z", # Monday at 11:38
|
|
"initialUnits": "10",
|
|
"initialMarginRequired": "0.2966",
|
|
"state": "OPEN",
|
|
"currentUnits": "10",
|
|
"realizedPL": "0.0000",
|
|
"financing": "0.0000",
|
|
"dividendAdjustment": "0.0000",
|
|
"unrealizedPL": "-0.0008",
|
|
"marginUsed": "0.2966",
|
|
"takeProfitOrder": {"price": "1.06331"},
|
|
"stopLossOrder": {"price": "1.06331"},
|
|
"trailingStopLossOrder": {"price": "1.06331"},
|
|
"trailingStopValue": None,
|
|
"side": "long",
|
|
},
|
|
{
|
|
"id": "20083",
|
|
"symbol": "EUR_USD",
|
|
"price": "1.06331",
|
|
"openTime": "2023-02-13T11:38:06.302917985Z", # Monday at 11:38
|
|
"initialUnits": "10",
|
|
"initialMarginRequired": "0.2966",
|
|
"state": "OPEN",
|
|
"currentUnits": "10",
|
|
"realizedPL": "0.0000",
|
|
"financing": "0.0000",
|
|
"dividendAdjustment": "0.0000",
|
|
"unrealizedPL": "-0.0008",
|
|
"marginUsed": "0.2966",
|
|
"takeProfitOrder": {"price": "1.06331"},
|
|
"stopLossOrder": {"price": "1.06331"},
|
|
"trailingStopLossOrder": {"price": "1.06331"},
|
|
"trailingStopValue": None,
|
|
"side": "long",
|
|
},
|
|
]
|
|
# Run parse_time on all items in trades
|
|
for trade in self.trades:
|
|
trade["openTime"] = parse_time(trade)
|
|
self.ams.get_trades = self.fake_get_trades
|
|
self.ams.get_balance = self.fake_get_balance
|
|
# self.ams.trades = self.trades
|
|
|
|
def fake_get_trades(self):
|
|
self.ams.trades = self.trades
|
|
return self.trades
|
|
|
|
def fake_get_balance(self):
|
|
return 10000
|
|
|
|
def fake_get_currencies(self, symbols):
|
|
pass
|
|
|
|
def test_get_trades(self):
|
|
trades = self.ams.get_trades()
|
|
self.assertEqual(trades, self.trades)
|
|
|
|
def test_get_balance(self):
|
|
balance = self.ams.get_balance()
|
|
self.assertEqual(balance, 10000)
|
|
|
|
def check_violation(
|
|
self, violation, calls, expected_action, expected_trades, expected_args=None
|
|
):
|
|
"""
|
|
Check that the violation was called with the expected action and trades.
|
|
Matches the first argument of the call to the violation name.
|
|
:param: violation: type of the violation to check against
|
|
:param: calls: list of calls to the violation
|
|
:param: expected_action: expected action to be called, close, notify, etc.
|
|
:param: expected_trades: list of expected trades to be passed to the violation
|
|
:param: expected_args: optional, expected args to be passed to the violation
|
|
"""
|
|
calls = list(calls)
|
|
violation_calls = []
|
|
for call in calls:
|
|
if call[0][0] == violation:
|
|
violation_calls.append(call)
|
|
|
|
self.assertEqual(len(violation_calls), len(expected_trades))
|
|
expected_trades = convert_trades(expected_trades)
|
|
for call in violation_calls:
|
|
# Ensure the correct action has been called, like close
|
|
self.assertEqual(call[0][1], expected_action)
|
|
# Ensure the correct trade has been passed to the violation
|
|
self.assertIn(call[0][2], expected_trades)
|
|
if expected_args:
|
|
self.assertEqual(call[0][3], expected_args)
|
|
|
|
@patch("core.trading.active_management.ActiveManagement.handle_violation")
|
|
def test_run_checks(self, handle_violation):
|
|
self.ams.run_checks()
|
|
print("handle_violation.call_count", handle_violation.call_args_list)
|
|
self.assertEqual(handle_violation.call_count, 0)
|
|
|
|
@patch("core.trading.active_management.ActiveManagement.handle_violation")
|
|
def test_trading_time_violated(self, handle_violation):
|
|
self.trades[0]["openTime"] = "2023-02-17T11:38:06.302917Z" # Friday
|
|
self.ams.run_checks()
|
|
self.check_violation(
|
|
"trading_time", handle_violation.call_args_list, "close", [self.trades[0]]
|
|
)
|
|
|
|
def create_hook_signal(self):
|
|
hook = Hook.objects.create(
|
|
user=self.user,
|
|
name="Test Hook",
|
|
)
|
|
signal = Signal.objects.create(
|
|
user=self.user,
|
|
name="Test Signal",
|
|
hook=hook,
|
|
type="trend",
|
|
)
|
|
return signal
|
|
|
|
@patch("core.trading.active_management.ActiveManagement.handle_violation")
|
|
def test_trends_violated(self, handle_violation):
|
|
signal = self.create_hook_signal()
|
|
self.strategy.trend_signals.set([signal])
|
|
self.strategy.trends = {"EUR_USD": "sell"}
|
|
self.strategy.save()
|
|
self.ams.run_checks()
|
|
self.check_violation(
|
|
"trends", handle_violation.call_args_list, "close", self.trades
|
|
)
|
|
|
|
@patch("core.trading.active_management.ActiveManagement.handle_violation")
|
|
def test_trends_violated_none(self, handle_violation):
|
|
signal = self.create_hook_signal()
|
|
self.strategy.trend_signals.set([signal])
|
|
self.strategy.trends = {"EUR_USD": "buy"}
|
|
self.strategy.save()
|
|
self.ams.run_checks()
|
|
self.check_violation("trends", handle_violation.call_args_list, "close", [])
|
|
|
|
@patch("core.trading.active_management.ActiveManagement.handle_violation")
|
|
def test_trends_violated_partial(self, handle_violation):
|
|
signal = self.create_hook_signal()
|
|
self.strategy.trend_signals.set([signal])
|
|
self.strategy.trends = {"EUR_USD": "sell"}
|
|
self.strategy.save()
|
|
|
|
# Change the side of the first trade to match the trends
|
|
self.trades[0]["side"] = "short"
|
|
self.ams.run_checks()
|
|
|
|
self.check_violation(
|
|
"trends", handle_violation.call_args_list, "close", [self.trades[1]]
|
|
)
|
|
|
|
@patch("core.trading.active_management.ActiveManagement.handle_violation")
|
|
def test_position_size_violated(self, handle_violation):
|
|
self.trades[0]["currentUnits"] = "100000"
|
|
self.ams.run_checks()
|
|
|
|
self.check_violation(
|
|
"position_size",
|
|
handle_violation.call_args_list,
|
|
"close",
|
|
[self.trades[0]],
|
|
{"size": 50},
|
|
)
|
|
|
|
def test_protection_violated(self):
|
|
pass
|
|
|
|
def test_asset_groups_violated(self):
|
|
pass
|
|
|
|
def test_max_open_trades_violated(self):
|
|
pass
|
|
|
|
def test_max_open_trades_per_symbol_violated(self):
|
|
pass
|
|
|
|
def test_max_loss_violated(self):
|
|
pass
|
|
|
|
def test_max_risk_violated(self):
|
|
pass
|
|
|
|
def test_crossfilter_violated(self):
|
|
pass
|