XF/fisk
1
0
Fork 0
Code Issues 2 Pull Requests Projects Releases Wiki Activity

Continue implementing live risk checks

Browse Source
This commit is contained in:
Mark Veidemanis
2023-01-11 19:46:47 +00:00
parent 93be9e6ffe
commit e55f903f42
12 changed files with 527 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
core/tests/exchanges/test_common.py → core/tests/exchanges/test_convert.py
View File

@@ -1,6 +1,6 @@
from django.test import TestCase
from core.exchanges.common import sl_price_to_percent, tp_price_to_percent
from core.exchanges.convert import sl_price_to_percent, tp_price_to_percent
class CommonTestCase(TestCase):

1
core/tests/helpers.py
View File

@@ -86,6 +86,7 @@ If you have done this, please see the following line for more information:
exchange=exchange,
api_key=api_key,
api_secret=api_secret,
initial_balance=100,
)
def setUp(self):

132
core/tests/trading/test_live.py
View File

@@ -1,11 +1,12 @@
from decimal import Decimal as D
from unittest.mock import patch
from django.test import TestCase
from core.exchanges.common import convert_open_trades
from core.models import Trade
from core.exchanges.convert import convert_trades
from core.models import RiskModel, Trade
from core.tests.helpers import ElasticMock, LiveBase
from core.trading.market import get_precision, get_price, get_sl, get_tp
from core.trading import market, risk
class LiveTradingTestCase(ElasticMock, LiveBase, TestCase):
@@ -21,6 +22,14 @@ class LiveTradingTestCase(ElasticMock, LiveBase, TestCase):
direction="buy",
)
self.commission = 0.025
self.risk_model = RiskModel.objects.create(
user=self.user,
name="Test Risk Model",
max_loss_percent=4,
max_risk_percent=2,
max_open_trades=3,
max_open_trades_per_symbol=2,
)
def test_account_functional(self):
"""
@@ -34,11 +43,12 @@ class LiveTradingTestCase(ElasticMock, LiveBase, TestCase):
if trade:
posted = trade.post()
else:
trade = self.trade
posted = self.trade.post()
# Check the opened trade
self.assertEqual(posted["type"], "MARKET_ORDER")
self.assertEqual(posted["symbol"], "EUR_USD")
self.assertEqual(posted["units"], "10")
self.assertEqual(posted["symbol"], trade.symbol)
self.assertEqual(posted["units"], str(trade.amount))
self.assertEqual(posted["timeInForce"], "FOK")
return posted
@@ -48,14 +58,17 @@ class LiveTradingTestCase(ElasticMock, LiveBase, TestCase):
trade.refresh_from_db()
closed = self.account.client.close_trade(trade.order_id)
else:
trade = self.trade
# refresh the trade to get the trade id
self.trade.refresh_from_db()
closed = self.account.client.close_trade(self.trade.order_id)
# Check the feedback from closing the trade
print("CLOSED", closed)
print("TRADE AMOUNT", trade.amount)
self.assertEqual(closed["type"], "MARKET_ORDER")
self.assertEqual(closed["symbol"], "EUR_USD")
self.assertEqual(closed["units"], "-10")
self.assertEqual(closed["symbol"], trade.symbol)
self.assertEqual(closed["units"], str(0 - int(trade.amount)))
self.assertEqual(closed["timeInForce"], "FOK")
self.assertEqual(closed["reason"], "TRADE_CLOSE")
@@ -78,7 +91,7 @@ class LiveTradingTestCase(ElasticMock, LiveBase, TestCase):
trades = self.account.client.get_all_open_trades()
self.trade.refresh_from_db()
found = False
for trade in trades["itemlist"]:
for trade in trades:
if trade["id"] == self.trade.order_id:
self.assertEqual(trade["symbol"], "EUR_USD")
self.assertEqual(trade["currentUnits"], "10")
@@ -91,14 +104,11 @@ class LiveTradingTestCase(ElasticMock, LiveBase, TestCase):
if not found:
self.fail("Could not find the trade in the list of open trades")
def test_convert_open_trades(self):
"""
Test converting open trades response to Trade-like format.
"""
eur_usd_price = get_price(self.account, "buy", "EUR_USD")
trade_tp = get_tp("buy", 1, eur_usd_price)
trade_sl = get_sl("buy", 2, eur_usd_price)
# trade_tsl = get_sl("buy", 1, eur_usd_price, return_var=True)
def create_complex_trade(self, direction, amount, symbol, tp_percent, sl_percent):
eur_usd_price = market.get_price(self.account, direction, symbol)
trade_tp = market.get_tp(direction, tp_percent, eur_usd_price)
trade_sl = market.get_sl(direction, sl_percent, eur_usd_price)
# trade_tsl = market.get_sl("buy", 1, eur_usd_price, return_var=True)
# # TP 1% profit
# trade_tp = eur_usd_price * D(1.01)
# # SL 2% loss
@@ -106,7 +116,7 @@ class LiveTradingTestCase(ElasticMock, LiveBase, TestCase):
# # TSL 1% loss
# trade_tsl = eur_usd_price * D(0.99)
trade_precision, display_precision = get_precision(self.account, "EUR_USD")
trade_precision, display_precision = market.get_precision(self.account, symbol)
# Round everything to the display precision
trade_tp = round(trade_tp, display_precision)
@@ -116,19 +126,79 @@ class LiveTradingTestCase(ElasticMock, LiveBase, TestCase):
complex_trade = Trade.objects.create(
user=self.user,
account=self.account,
symbol="EUR_USD",
symbol=symbol,
time_in_force="FOK",
type="market",
amount=10,
direction="buy",
amount=amount,
direction=direction,
take_profit=trade_tp,
stop_loss=trade_sl,
# trailing_stop_loss=trade_tsl,
)
return complex_trade
@patch("core.exchanges.oanda.OANDAExchange.get_balance", return_value=100)
def test_check_risk_max_risk_pass(self, mock_balance):
# SL of 19% on a 10 trade on a 100 account is 1.8 loss
# Should be comfortably under 2% risk
trade = self.create_complex_trade("buy", 10, "EUR_USD", 1, 18)
allowed = risk.check_risk(self.risk_model, self.account, trade)
self.assertTrue(allowed["allowed"])
@patch("core.exchanges.oanda.OANDAExchange.get_balance", return_value=100)
def test_check_risk_max_risk_fail(self, mock_balance):
# SL of 21% on a 10 trade on a 100 account is 2.2 loss
# Should be over 2% risk
trade = self.create_complex_trade("buy", 10, "EUR_USD", 1, 22)
allowed = risk.check_risk(self.risk_model, self.account, trade)
print("ALLOWED", allowed)
self.assertFalse(allowed["allowed"])
self.assertEqual(allowed["reason"], "Maximum risk exceeded.")
@patch("core.exchanges.oanda.OANDAExchange.get_balance", return_value=94)
# We have lost 6% of our account
def test_check_risk_max_loss_fail(self, mock_balance):
# Doesn't matter, shouldn't get as far as the trade
trade = self.create_complex_trade("buy", 1, "EUR_USD", 1, 1)
allowed = risk.check_risk(self.risk_model, self.account, trade)
self.assertFalse(allowed["allowed"])
self.assertEqual(allowed["reason"], "Maximum loss exceeded.")
@patch("core.exchanges.oanda.OANDAExchange.get_balance", return_value=100)
def test_check_risk_max_open_trades_fail(self, mock_balance):
# The maximum open trades is 3. Let's open 2 trades
trade1 = self.create_complex_trade("buy", 1, "EUR_USD", 1, 1)
self.open_trade(trade1)
trade2 = self.create_complex_trade("buy", 1, "EUR_USD", 1, 1)
self.open_trade(trade2)
trade3 = self.create_complex_trade("buy", 1, "EUR_USD", 1, 1)
allowed = risk.check_risk(self.risk_model, self.account, trade3)
self.assertFalse(allowed["allowed"])
self.assertEqual(allowed["reason"], "Maximum open trades exceeded.")
self.close_trade(trade1)
self.close_trade(trade2)
@patch("core.exchanges.oanda.OANDAExchange.get_balance", return_value=100)
def test_check_risk_max_open_trades_per_symbol_fail(self, mock_balance):
pass
def test_convert_trades(self):
"""
Test converting open trades response to Trade-like format.
"""
complex_trade = self.create_complex_trade("buy", 10, "EUR_USD", 1, 2)
self.open_trade(complex_trade)
# Get and annotate the trades
trades = self.account.client.get_all_open_trades()
trades_converted = convert_open_trades(trades["itemlist"])
trades_converted = convert_trades(trades)
# Check the converted trades
self.assertEqual(len(trades_converted), 1)
expected_tp_percent = D(1 - self.commission)
expected_sl_percent = D(2 - self.commission)
@@ -141,4 +211,24 @@ class LiveTradingTestCase(ElasticMock, LiveBase, TestCase):
self.assertLess(tp_percent_difference, max_difference)
self.assertLess(sl_percent_difference, max_difference)
# Convert the trades to USD
trades_usd = market.convert_trades_to_usd(self.account, trades_converted)
# Convert the trade to USD ourselves
trade_in_usd = D(trades_usd[0]["amount"]) * D(trades_usd[0]["current_price"])
# It will never be perfect, but let's check it's at least close
trade_usd_conversion_difference = (
trades_usd[0]["trade_amount_usd"] - trade_in_usd
)
self.assertLess(trade_usd_conversion_difference, D(0.01))
# Check the converted TP and SL values
trade_usd_tp_difference = trades_usd[0]["take_profit_usd"] - D(0.1)
trade_usd_sl_difference = trades_usd[0]["stop_loss_usd"] - D(0.2)
self.assertLess(trade_usd_tp_difference, D(0.01))
self.assertLess(trade_usd_sl_difference, D(0.02))
self.close_trade(complex_trade)

14
core/tests/trading/test_risk.py
View File

@@ -1,6 +1,6 @@
from django.test import TestCase
from core.exchanges import common
from core.exchanges import convert
from core.models import RiskModel, User
from core.trading import risk
@@ -228,7 +228,7 @@ class RiskModelTestCase(TestCase):
# Hardcoded prices to avoid calling market API here
"stop_loss_usd": 50, # 5% of $1000
}
converted = common.convert_open_trades([trade])
converted = convert.convert_trades([trade])
self.assertEqual(converted[0]["stop_loss_percent"], 5)
self.assertEqual(converted[0]["stop_loss_usd"], 50)
max_risk_check = risk.check_max_risk(self.risk_model, 1000, converted)
@@ -253,7 +253,7 @@ class RiskModelTestCase(TestCase):
# Hardcoded prices to avoid calling market API here
"stop_loss_usd": 40, # 4% of $1000
}
converted = common.convert_open_trades([trade, trade])
converted = convert.convert_trades([trade, trade])
self.assertEqual(converted[0]["stop_loss_percent"], 4)
self.assertEqual(converted[0]["stop_loss_usd"], 40)
max_risk_check = risk.check_max_risk(self.risk_model, 1000, converted)
@@ -277,7 +277,7 @@ class RiskModelTestCase(TestCase):
# Hardcoded prices to avoid calling market API here
"stop_loss_usd": 100, # 10% of $1000
}
converted = common.convert_open_trades([trade])
converted = convert.convert_trades([trade])
self.assertEqual(converted[0]["stop_loss_percent"], 10)
self.assertEqual(converted[0]["stop_loss_usd"], 100)
max_risk_check = risk.check_max_risk(self.risk_model, 1000, converted)
@@ -302,7 +302,7 @@ class RiskModelTestCase(TestCase):
# Hardcoded prices to avoid calling market API here
"stop_loss_usd": 50, # 5% of $1000
}
converted = common.convert_open_trades([trade, trade])
converted = convert.convert_trades([trade, trade])
self.assertEqual(converted[0]["stop_loss_percent"], 5)
self.assertEqual(converted[0]["stop_loss_usd"], 50)
self.assertEqual(converted[1]["stop_loss_percent"], 5)
@@ -334,7 +334,7 @@ class RiskModelTestCase(TestCase):
trade2["trailingStopLossOrder"] = {"price": 0.95}
del trade2["stopLossOrder"]
converted = common.convert_open_trades([trade, trade2])
converted = convert.convert_trades([trade, trade2])
self.assertEqual(converted[0]["stop_loss_percent"], 5)
self.assertEqual(converted[0]["stop_loss_usd"], 50)
self.assertEqual(converted[1]["trailing_stop_loss_percent"], 5)
@@ -365,7 +365,7 @@ class RiskModelTestCase(TestCase):
trade2 = trade.copy()
trade2["trailingStopLossOrder"] = {"price": 0.951}
converted = common.convert_open_trades([trade, trade2])
converted = convert.convert_trades([trade, trade2])
self.assertEqual(converted[0]["stop_loss_percent"], 5)
self.assertEqual(converted[0]["stop_loss_usd"], 50)
self.assertEqual(float(converted[1]["trailing_stop_loss_percent"]), 4.9)