refactor: simplify validate_symbol to only check target != trading_symbol (#247)

MDUYN · MDUYN · commit c5e4f5c76f3a · 2026-04-22T09:33:04.000+01:00
validate_symbol now only prevents nonsensical orders where
target_symbol equals trading_symbol (e.g. EUR/EUR). No data source
lookups or symbol format construction needed.
diff --git a/investing_algorithm_framework/app/context.py b/investing_algorithm_framework/app/context.py
@@ -53,34 +53,28 @@ def __init__(
 
     def _validate_target_symbol(self, target_symbol, market=None):
         """
-        Validate that the target_symbol is a known symbol by checking
-        against registered data source symbols.
+        Validate that the target_symbol combined with the portfolio's
+        trading_symbol does not result in trading_symbol/trading_symbol
+        (e.g., EUR/EUR), which is a nonsensical order.
 
         Args:
-            target_symbol: The symbol to validate (e.g., "BTC" or "BTC/EUR")
+            target_symbol: The symbol of the asset to trade
             market: The market to check against
 
         Raises:
-            OperationalException: If the symbol is not recognized
+            OperationalException: If target_symbol equals
+              the trading_symbol
         """
-        known_symbols = set()
-
-        # Collect symbols from registered data sources
-        if self.data_provider_service.data_provider_index is not None:
-            for data_source, _ in \
-                    self.data_provider_service \
-                    .data_provider_index.get_all():
-                if data_source.symbol is not None:
-                    known_symbols.add(data_source.symbol.upper())
-
-        target = target_symbol.upper()
+        portfolio = self.portfolio_service.find({"market": market})
+        trading_symbol = portfolio.trading_symbol.upper()
 
-        if target not in known_symbols:
-            sorted_symbols = sorted(known_symbols)
+        if target_symbol.upper() == trading_symbol:
             raise OperationalException(
-                f"Symbol '{target_symbol}' is not a known asset. "
-                f"Known symbols: {sorted_symbols}. "
-                f"Check for typos or add a DataSource for this symbol. "
+                f"target_symbol '{target_symbol}' is the same as "
+                f"the trading_symbol '{portfolio.trading_symbol}'. "
+                f"This would result in a "
+                f"'{portfolio.trading_symbol}/{portfolio.trading_symbol}' "
+                f"order which is not valid. "
                 f"To skip this check, set validate_symbol=False "
                 f"or omit the parameter."
             )
@@ -132,7 +126,7 @@ def create_order(
             sync: If set to True, the created order will be synced
             with the portfolio of the algorithm.
             validate_symbol: Default False. If set to True,
-              the target_symbol will be validated against known symbols.
+              validates that target_symbol is not the trading_symbol.
 
         Returns:
             The order created
@@ -235,8 +229,7 @@ def create_limit_order(
               the created order will be synced with the
                 portfolio of the algorithm
             validate_symbol (optional): Default False. If set to True,
-              the target_symbol will be validated against known symbols
-              from registered data sources.
+              validates that target_symbol is not the trading_symbol.
 
         Returns:
             Order: Instance of the order created
diff --git a/tests/app/algorithm/test_validate_symbol.py b/tests/app/algorithm/test_validate_symbol.py
@@ -1,12 +1,16 @@
 from investing_algorithm_framework import PortfolioConfiguration, \
-    MarketCredential, OrderSide, DataSource
+    MarketCredential, OrderSide
 from investing_algorithm_framework.domain import OperationalException
 from tests.resources import TestBase
 from tests.resources.strategies_for_testing import StrategyOne
 
 
 class TestValidateSymbol(TestBase):
-    """Tests for opt-in symbol validation on order creation (issue #247)."""
+    """Tests for opt-in symbol validation on order creation (issue #247).
+
+    Validates that target_symbol is not the same as trading_symbol,
+    which would result in a nonsensical order (e.g. EUR/EUR).
+    """
     portfolio_configurations = [
         PortfolioConfiguration(
             market="BITVAVO",
@@ -24,124 +28,94 @@ class TestValidateSymbol(TestBase):
         "EUR": 1000
     }
 
-    def _register_data_source(self, symbol):
-        """Register a data source symbol in the data provider index."""
-        data_source = DataSource(
-            identifier=f"{symbol}_ohlcv",
-            symbol=symbol,
-            data_type="OHLCV",
-            time_frame="1d",
-            market="BITVAVO",
-        )
-        data_provider_service = self.app.container.data_provider_service()
-        data_provider_service.data_provider_index\
-            .data_providers_lookup[data_source] = None
-
-    def test_default_allows_unknown_symbol(self):
-        """Default behavior: no symbol validation, any symbol is accepted."""
+    def test_default_allows_trading_symbol_as_target(self):
+        """Default behavior: no validation, even trading_symbol is accepted."""
         self.app.add_strategy(StrategyOne)
         self.app.context.create_limit_order(
-            target_symbol="UNKNOWN_TOKEN",
+            target_symbol="EUR",
             amount=1,
             price=10,
             order_side=OrderSide.BUY,
         )
         order_repository = self.app.container.order_repository()
-        order = order_repository.find({"target_symbol": "UNKNOWN_TOKEN"})
+        order = order_repository.find({"target_symbol": "EUR"})
         self.assertIsNotNone(order)
 
-    def test_validate_symbol_false_allows_unknown_symbol(self):
-        """Explicit validate_symbol=False allows any symbol."""
+    def test_validate_symbol_false_allows_trading_symbol_as_target(self):
+        """Explicit validate_symbol=False allows trading_symbol as target."""
         self.app.add_strategy(StrategyOne)
         self.app.context.create_limit_order(
-            target_symbol="UNKNOWN_TOKEN",
+            target_symbol="EUR",
             amount=1,
             price=10,
             order_side=OrderSide.BUY,
             validate_symbol=False,
         )
         order_repository = self.app.container.order_repository()
-        order = order_repository.find({"target_symbol": "UNKNOWN_TOKEN"})
+        order = order_repository.find({"target_symbol": "EUR"})
         self.assertIsNotNone(order)
 
-    def test_validate_symbol_true_rejects_unknown_symbol(self):
-        """validate_symbol=True raises for a symbol not in data sources."""
+    def test_validate_symbol_true_rejects_trading_symbol_as_target(self):
+        """validate_symbol=True raises when target_symbol equals
+        trading_symbol (e.g. EUR/EUR)."""
         self.app.add_strategy(StrategyOne)
-        self._register_data_source("BTC/EUR")
 
         with self.assertRaises(OperationalException) as cm:
             self.app.context.create_limit_order(
-                target_symbol="BT/EUR",
+                target_symbol="EUR",
                 amount=1,
                 price=10,
                 order_side=OrderSide.BUY,
                 validate_symbol=True,
             )
 
-        self.assertIn("BT/EUR", str(cm.exception))
-        self.assertIn("not a known asset", str(cm.exception))
-        self.assertIn("BTC/EUR", str(cm.exception))
+        error_msg = str(cm.exception)
+        self.assertIn("EUR", error_msg)
+        self.assertIn("trading_symbol", error_msg)
+        self.assertIn("EUR/EUR", error_msg)
 
-    def test_validate_symbol_true_accepts_known_symbol(self):
-        """validate_symbol=True passes for a symbol in data sources."""
+    def test_validate_symbol_true_case_insensitive(self):
+        """validate_symbol=True catches trading_symbol regardless of case."""
         self.app.add_strategy(StrategyOne)
-        self._register_data_source("BTC/EUR")
 
-        self.app.context.create_limit_order(
-            target_symbol="BTC/EUR",
-            amount=1,
-            price=10,
-            order_side=OrderSide.BUY,
-            validate_symbol=True,
-        )
-        order_repository = self.app.container.order_repository()
-        order = order_repository.find({"target_symbol": "BTC/EUR"})
-        self.assertIsNotNone(order)
+        with self.assertRaises(OperationalException):
+            self.app.context.create_limit_order(
+                target_symbol="eur",
+                amount=1,
+                price=10,
+                order_side=OrderSide.BUY,
+                validate_symbol=True,
+            )
 
-    def test_validate_symbol_true_multiple_data_sources(self):
-        """validate_symbol=True checks across all registered data sources."""
+    def test_validate_symbol_true_accepts_valid_target(self):
+        """validate_symbol=True passes for a target that differs
+        from trading_symbol."""
         self.app.add_strategy(StrategyOne)
-        self._register_data_source("BTC/EUR")
-        self._register_data_source("ETH/EUR")
 
-        # ETH/EUR should pass
         self.app.context.create_limit_order(
-            target_symbol="ETH/EUR",
+            target_symbol="BTC",
             amount=1,
             price=10,
             order_side=OrderSide.BUY,
             validate_symbol=True,
         )
         order_repository = self.app.container.order_repository()
-        order = order_repository.find({"target_symbol": "ETH/EUR"})
+        order = order_repository.find({"target_symbol": "BTC"})
         self.assertIsNotNone(order)
 
-        # SOL/EUR should fail
-        with self.assertRaises(OperationalException):
-            self.app.context.create_limit_order(
-                target_symbol="SOL/EUR",
-                amount=1,
-                price=10,
-                order_side=OrderSide.BUY,
-                validate_symbol=True,
-            )
-
-    def test_validate_symbol_error_message_contains_known_symbols(self):
-        """Error message lists known symbols for user reference."""
+    def test_validate_symbol_error_message(self):
+        """Error message explains the EUR/EUR problem and how to skip."""
         self.app.add_strategy(StrategyOne)
-        self._register_data_source("BTC/EUR")
-        self._register_data_source("ETH/EUR")
 
         with self.assertRaises(OperationalException) as cm:
             self.app.context.create_limit_order(
-                target_symbol="TYPO",
+                target_symbol="EUR",
                 amount=1,
                 price=10,
                 order_side=OrderSide.BUY,
                 validate_symbol=True,
             )
 
         error_msg = str(cm.exception)
-        self.assertIn("BTC/EUR", error_msg)
-        self.assertIn("ETH/EUR", error_msg)
+        self.assertIn("EUR/EUR", error_msg)
         self.assertIn("validate_symbol=False", error_msg)
