Write protection check tests

core/trading/active_management.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from decimal import Decimal as D
 
-from core.exchanges.convert import side_to_direction
+from core.exchanges.convert import convert_trades, side_to_direction
 from core.trading import checks
 from core.trading.market import get_base_quote, get_trade_size_in_base
 
@@ -25,11 +25,11 @@ class ActiveManagement(object):
         else:
             return self.balance
 
-    def handle_violation(self, check_type, action, trade):
-        print("VIOLATION", check_type, action, trade)
+    def handle_violation(self, check_type, action, trade, **kwargs):
+        print("VIOLATION", check_type, action, trade, kwargs)
 
     def check_trading_time(self, trade):
-        open_ts = trade["openTime"]
+        open_ts = trade["open_time"]
         open_ts_as_date = datetime.strptime(open_ts, "%Y-%m-%dT%H:%M:%S.%fZ")
         trading_time_pass = checks.within_trading_times(self.strategy, open_ts_as_date)
         if not trading_time_pass:
@@ -38,40 +38,80 @@ class ActiveManagement(object):
             )
 
     def check_trends(self, trade):
-        direction = side_to_direction(trade["side"])
+        direction = trade["direction"]
         symbol = trade["symbol"]
         trends_pass = checks.within_trends(self.strategy, symbol, direction)
         if not trends_pass:
-            print("VIOLATION", "trends", self.policy.when_trends_violated, trade)
             self.handle_violation("trends", self.policy.when_trends_violated, trade)
 
     def check_position_size(self, trade):
+        """
+        Check the position size is within the allowed deviation.
+        WARNING: This uses the current balance, not the balance at the time of the trade.
+        WARNING: This uses the current symbol prices, not those at the time of the trade.
+        This should normally be run every 5 seconds, so this is fine.
+        """
+        # TODO: add the trade value to the balance
+        # Need to determine which prices to use
         balance = self.get_balance()
-        print("BALANCE", balance)
-        direction = side_to_direction(trade["side"])
+        direction = trade["direction"]
         symbol = trade["symbol"]
+        # TODO:
         base, quote = get_base_quote(self.strategy.account.exchange, symbol)
         expected_trade_size = get_trade_size_in_base(
             direction, self.strategy.account, self.strategy, balance, base
         )
-        print("TRADE SIZE", expected_trade_size)
 
         deviation = D(0.05)  # 5%
-        actual_trade_size = D(trade["currentUnits"])
+        actual_trade_size = D(trade["amount"])
         # Ensure the trade size not above the expected trade size by more than 5%
         max_trade_size = expected_trade_size + (deviation * expected_trade_size)
         within_max_trade_size = actual_trade_size <= max_trade_size
 
         if not within_max_trade_size:
             self.handle_violation(
-                "position_size", self.policy.when_position_size_violated, trade
+                "position_size",
+                self.policy.when_position_size_violated,
+                trade,
+                {"size": expected_trade_size},
+            )
+
+    def check_protection(self, trade):
+        print("CHECK PROTECTION", trade)
+        deviation = D(0.05)  # 5%
+
+        matches = {
+            "stop_loss_percent": self.strategy.order_settings.stop_loss_percent,
+            "take_profit_percent": self.strategy.order_settings.take_profit_percent,
+            "trailing_stop_percent": self.strategy.order_settings.trailing_stop_loss_percent,
+        }
+
+        violations = {}
+
+        for key, expected in matches.items():
+            if key in trade:
+                actual = D(trade[key])
+                if expected is None:
+                    continue
+                expected = D(expected)
+                min_val = expected - (deviation * expected)
+                max_val = expected + (deviation * expected)
+                within_deviation = min_val <= actual <= max_val
+                if not within_deviation:
+                    violations[key] = expected
+
+        if violations:
+            self.handle_violation(
+                "protection", self.policy.when_protection_violated, trade, violations
             )
 
     def run_checks(self):
-        for trade in self.get_trades():
+        converted_trades = convert_trades(self.get_trades())
+        for trade in converted_trades:
             self.check_trading_time(trade)
             self.check_trends(trade)
             self.check_position_size(trade)
+            self.check_protection(trade)
 
         # Trading Time
         # Max loss

core/trading/checks.py

@@ -53,9 +53,7 @@ def within_max_loss(strategy):
 
 
 def within_trends(strategy, symbol, direction):
-    print("WITHIN TRENDS", symbol, direction)
     if strategy.trend_signals.exists():
-        print("TREND SIGNALS EXIST")
         if strategy.trends is None:
             log.debug("Refusing to trade with no trend signals received")
             sendmsg(