lumibot 4.2.9__py3-none-any.whl → 4.2.10__py3-none-any.whl

tests/test_strategy_close_position.py

@@ -0,0 +1,83 @@
+import logging
+from types import SimpleNamespace
+import unittest
+
+from lumibot.entities import Asset, Position
+from lumibot.strategies import Strategy
+from lumibot.strategies._strategy import Vars
+
+
+class DummyBroker:
+    IS_BACKTESTING_BROKER = False
+
+    def __init__(self):
+        self.name = "dummy"
+        self.data_source = SimpleNamespace(SOURCE="TEST")
+        self.quote_assets = set()
+        self._filled_positions = []
+        self.close_calls = []
+
+    def get_tracked_position(self, strategy_name, asset):
+        for position in self._filled_positions:
+            if position.strategy == strategy_name and position.asset == asset:
+                return position
+        return None
+
+    def get_tracked_positions(self, strategy_name=None):
+        return [
+            position
+            for position in self._filled_positions
+            if strategy_name is None or position.strategy == strategy_name
+        ]
+
+    def close_position(self, strategy_name, asset, fraction=1.0):
+        position = self.get_tracked_position(strategy_name, asset)
+        if position is None or position.quantity == 0:
+            self.close_calls.append({"asset": asset, "order": None})
+            return None
+
+        qty = position.quantity * fraction
+        order = SimpleNamespace(
+            identifier="CLOSE-ORDER",
+            asset=asset,
+            quantity=qty,
+            side="sell",
+            order_type="market",
+        )
+        self.close_calls.append({"asset": asset, "order": order})
+        return order
+
+
+class DummyStrategy(Strategy):
+    parameters = {}
+
+    def __init__(self, broker):
+        self.broker = broker
+        self.logger = logging.getLogger("DummyStrategy")
+        self._name = "DummyStrategy"
+        self.vars = Vars()
+        self._quote_asset = Asset("USD", Asset.AssetType.FOREX)
+        self.broker.quote_assets.add(self._quote_asset)
+
+
+class TestStrategyClosePosition(unittest.TestCase):
+    def test_close_position_resolves_continuous_future(self):
+        broker = DummyBroker()
+        strategy = DummyStrategy(broker)
+
+        contract_asset = Asset("ESZ4", asset_type=Asset.AssetType.FUTURE)
+        position = Position(strategy=strategy.name, asset=contract_asset, quantity=2)
+        broker._filled_positions.append(position)
+
+        cont_asset = Asset("ES", asset_type=Asset.AssetType.CONT_FUTURE)
+        result = strategy.close_position(cont_asset)
+
+        self.assertIsNotNone(result)
+        self.assertEqual(result.asset, contract_asset)
+        self.assertEqual(len(broker.close_calls), 1)
+        self.assertEqual(broker.close_calls[0]["asset"], contract_asset)
+        self.assertIsNotNone(broker.close_calls[0]["order"])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_thetadata_helper.py

@@ -881,7 +881,13 @@ def test_get_request_error_in_json(mock_get, mock_check_connection):
         password="test_password",
         wait_for_connection=True,
     )
-    assert mock_check_connection.call_count == 5
+    assert mock_check_connection.call_count == 2
+    first_call_kwargs = mock_check_connection.call_args_list[0].kwargs
+    assert first_call_kwargs == {
+        "username": "test_user",
+        "password": "test_password",
+        "wait_for_connection": False,
+    }
 
 
 @patch('lumibot.tools.thetadata_helper.check_connection')
@@ -907,6 +913,44 @@ def test_get_request_exception_handling(mock_get, mock_check_connection):
     assert mock_check_connection.call_count == 3
 
 
+
+@patch('lumibot.tools.thetadata_helper.start_theta_data_client')
+@patch('lumibot.tools.thetadata_helper.check_connection')
+def test_get_request_consecutive_474_triggers_restarts(mock_check_connection, mock_start_client, monkeypatch):
+    mock_check_connection.return_value = (object(), True)
+
+    responses = [MagicMock(status_code=474, text='Connection lost to Theta Data MDDS.') for _ in range(9)]
+
+    def fake_get(*args, **kwargs):
+        if not responses:
+            raise AssertionError('Test exhausted mock responses unexpectedly')
+        return responses.pop(0)
+
+    monkeypatch.setattr(thetadata_helper.requests, 'get', fake_get)
+    monkeypatch.setattr(thetadata_helper.time, 'sleep', lambda *args, **kwargs: None)
+    monkeypatch.setattr(thetadata_helper, 'BOOT_GRACE_PERIOD', 0, raising=False)
+    monkeypatch.setattr(thetadata_helper, 'CONNECTION_RETRY_SLEEP', 0, raising=False)
+
+    with pytest.raises(ValueError, match='Cannot connect to Theta Data!'):
+        thetadata_helper.get_request(
+            url='http://test.com',
+            headers={'Authorization': 'Bearer test_token'},
+            querystring={'param1': 'value1'},
+            username='test_user',
+            password='test_password',
+        )
+
+    assert mock_start_client.call_count == 3
+    # Initial liveness probe plus retry coordination checks
+    assert mock_check_connection.call_count > 3
+    first_call_kwargs = mock_check_connection.call_args_list[0].kwargs
+    assert first_call_kwargs == {
+        'username': 'test_user',
+        'password': 'test_password',
+        'wait_for_connection': False,
+    }
+
+
 @patch('lumibot.tools.thetadata_helper.get_request')
 def test_get_historical_data_stock(mock_get_request):
     # Arrange

tests/test_tradovate.py

@@ -23,6 +23,15 @@ import logging
 import time
 import requests
 from datetime import datetime
+from types import SimpleNamespace
+
+from lumibot.brokers.broker import Broker
+
+
+@pytest.fixture(autouse=True)
+def disable_tradovate_stream(monkeypatch):
+    """Prevent background polling threads during unit tests."""
+    monkeypatch.setattr(Broker, "_launch_stream", lambda self: None)
 
 
 class TestTradovateImports:
@@ -576,6 +585,290 @@ class TestTradovateAPIPayload:
         print("✅ Stop order payload format test passed")
 
 
+class TestTradovateLifecycle:
+    """Tests for Tradovate order lifecycle wiring (polling, submit, cancel)."""
+
+    def _make_broker(self):
+        from lumibot.brokers import Tradovate
+        base_config = {
+            "USERNAME": "test_user",
+            "DEDICATED_PASSWORD": "test_pass",
+            "CID": "test_cid",
+            "SECRET": "test_secret",
+            "IS_PAPER": True,
+        }
+        tokens = {
+            "accessToken": "token",
+            "marketToken": "market",
+            "hasMarketData": True,
+        }
+        account_info = {"accountSpec": "TEST", "accountId": 123}
+        user_info = "user"
+
+        with patch.object(Tradovate, "_get_tokens", return_value=tokens), \
+             patch.object(Tradovate, "_get_account_info", return_value=account_info), \
+             patch.object(Tradovate, "_get_user_info", return_value=user_info):
+            broker = Tradovate(config=base_config)
+        return broker
+
+    def test_submit_order_emits_new_event(self):
+        from lumibot.entities import Asset, Order
+
+        broker = self._make_broker()
+        asset = Asset("MES", asset_type=Asset.AssetType.CONT_FUTURE)
+        strategy_name = "Strategy"
+        order = Order(
+            strategy=strategy_name,
+            asset=asset,
+            quantity=1,
+            side="buy",
+            order_type=Order.OrderType.MARKET,
+        )
+
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"orderId": 999}
+
+        with patch.object(broker, "_request", return_value=mock_response), \
+             patch.object(broker, "_process_trade_event") as mock_process:
+            broker._submit_order(order)
+
+        mock_process.assert_called_once_with(order, broker.NEW_ORDER)
+
+    def test_do_polling_dispatches_fill_event(self):
+        from lumibot.entities import Asset, Order
+
+        broker = self._make_broker()
+        broker.stream = SimpleNamespace(dispatch=lambda event, **payload: broker._dispatched.append((event, payload)))
+        broker._dispatched = []
+
+        filled_order = Order(
+            strategy="Strategy",
+            asset=Asset("ESZ5", asset_type=Asset.AssetType.FUTURE),
+            quantity=2,
+            side="sell",
+            order_type=Order.OrderType.MARKET,
+        )
+        filled_order.set_identifier("321")
+        filled_order.status = Order.OrderStatus.FILLED
+
+        with patch.object(broker, "sync_positions", return_value=None), \
+             patch.object(broker, "_pull_broker_all_orders", return_value=[{"id": "321"}]), \
+             patch.object(broker, "_parse_broker_order", return_value=filled_order), \
+             patch.object(broker, "_extract_fill_details", return_value=(100.0, 2)):
+            broker.do_polling()
+
+        events = broker._dispatched
+        assert any(event == broker.FILLED_ORDER for event, _ in events)
+
+    def test_cancel_order_dispatches_cancel_event(self):
+        from lumibot.entities import Asset, Order
+
+        broker = self._make_broker()
+        dispatched = []
+        broker.stream = SimpleNamespace(dispatch=lambda event, **payload: dispatched.append((event, payload)))
+
+        order = Order(
+            strategy="Strategy",
+            asset=Asset("ESZ5", asset_type=Asset.AssetType.FUTURE),
+            quantity=1,
+            side="sell",
+            order_type=Order.OrderType.MARKET,
+        )
+        order.set_identifier("654")
+
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {}
+
+        with patch.object(broker, "_request", return_value=mock_response):
+            broker.cancel_order(order)
+
+        assert any(event == broker.CANCELED_ORDER for event, _ in dispatched)
+
+    def test_pull_all_orders_skips_first_iteration(self):
+        broker = self._make_broker()
+        broker._first_iteration = True
+        result = broker._pull_all_orders("Strategy", None)
+        assert result == []
+
+        broker._first_iteration = False
+        with patch("lumibot.brokers.broker.Broker._pull_all_orders", return_value=["order"]) as mock_super:
+            result = broker._pull_all_orders("Strategy", None)
+            mock_super.assert_called_once()
+        assert result == ["order"]
+
+    def test_do_polling_dispatches_new_for_active_order(self):
+        from lumibot.entities import Asset, Order
+
+        broker = self._make_broker()
+        broker.stream = SimpleNamespace(dispatch=lambda event, **payload: broker._dispatched.append((event, payload)))
+        broker._dispatched = []
+
+        active_order = Order(
+            strategy="Strategy",
+            asset=Asset("ESZ5", asset_type=Asset.AssetType.FUTURE),
+            quantity=1,
+            side="buy",
+            order_type=Order.OrderType.MARKET,
+        )
+        active_order.set_identifier("999")
+        active_order.status = Order.OrderStatus.NEW
+
+        with patch.object(broker, "sync_positions", return_value=None), \
+             patch.object(broker, "_pull_broker_all_orders", return_value=[{"id": "999"}]), \
+             patch.object(broker, "_parse_broker_order", return_value=active_order), \
+             patch.object(broker, "_extract_fill_details", return_value=(None, None)):
+            broker.do_polling()
+
+        events = broker._dispatched
+        assert any(event == broker.NEW_ORDER for event, _ in events)
+
+    def test_do_polling_skips_new_for_closed_order_even_after_startup(self):
+        from lumibot.entities import Asset, Order
+
+        broker = self._make_broker()
+        broker.stream = SimpleNamespace(dispatch=lambda event, **payload: broker._dispatched.append((event, payload)))
+        broker._dispatched = []
+
+        closed_order = Order(
+            strategy="Strategy",
+            asset=Asset("ESZ5", asset_type=Asset.AssetType.FUTURE),
+            quantity=1,
+            side="sell",
+            order_type=Order.OrderType.MARKET,
+        )
+        closed_order.set_identifier("777")
+        closed_order.status = Order.OrderStatus.FILLED
+
+        broker._first_iteration = False
+
+        with patch.object(broker, "sync_positions", return_value=None), \
+             patch.object(broker, "_pull_broker_all_orders", return_value=[{"id": "777"}]), \
+             patch.object(broker, "_parse_broker_order", return_value=closed_order), \
+             patch.object(broker, "_extract_fill_details", return_value=(100.0, 1)):
+            broker.do_polling()
+
+        events = broker._dispatched
+        assert any(event == broker.FILLED_ORDER for event, _ in events)
+        assert not any(event == broker.NEW_ORDER for event, _ in events)
+
+    def test_extract_fill_details_uses_fill_list_fallback(self):
+        from lumibot.entities import Asset, Order
+
+        broker = self._make_broker()
+
+        raw_order = {"id": "900", "ordStatus": "Filled"}
+        parsed_order = Order(
+            strategy="Strategy",
+            asset=Asset("ESZ5", asset_type=Asset.AssetType.FUTURE),
+            quantity=0,
+            side="buy",
+            order_type=Order.OrderType.MARKET,
+        )
+        parsed_order.set_identifier("900")
+
+        with patch.object(broker, "_fetch_recent_fill_details", return_value=(6788.5, 1)):
+            price, qty = broker._extract_fill_details(raw_order, parsed_order)
+
+        assert qty == 1
+        assert price == 6788.5
+
+    def test_missing_order_reconciles_to_fill_instead_of_cancel(self):
+        from lumibot.entities import Asset, Order
+
+        broker = self._make_broker()
+        broker.stream = SimpleNamespace(dispatch=lambda event, **payload: broker._dispatched.append((event, payload)))
+        broker._dispatched = []
+
+        missing_order = Order(
+            strategy="Strategy",
+            asset=Asset("ESZ5", asset_type=Asset.AssetType.FUTURE),
+            quantity=1,
+            side="buy",
+            order_type=Order.OrderType.MARKET,
+        )
+        missing_order.set_identifier("555")
+        missing_order.status = Order.OrderStatus.NEW
+
+        quote = SimpleNamespace(last=6788.25)
+
+        with patch.object(broker, "sync_positions", return_value=None), \
+             patch.object(broker, "_pull_broker_all_orders", return_value=[]), \
+             patch.object(broker, "get_all_orders", return_value=[missing_order]), \
+             patch.object(broker, "_fetch_recent_fill_details", return_value=(6788.5, 1)), \
+             patch.object(broker, "get_quote", return_value=quote):
+            broker.do_polling()
+
+        events = broker._dispatched
+        assert any(event == broker.FILLED_ORDER for event, _ in events)
+        assert not any(event == broker.CANCELED_ORDER for event, _ in events)
+
+    def test_cancel_open_orders_prunes_stale_locals(self):
+        from lumibot.entities import Asset, Order
+
+        broker = self._make_broker()
+
+        stale_order = Order(
+            strategy="Strategy",
+            asset=Asset("ESZ5", asset_type=Asset.AssetType.FUTURE),
+            quantity=1,
+            side="buy",
+            order_type=Order.OrderType.MARKET,
+        )
+        stale_order.set_identifier("111")
+        stale_order.status = Order.OrderStatus.NEW
+
+        live_order = Order(
+            strategy="Strategy",
+            asset=Asset("ESZ5", asset_type=Asset.AssetType.FUTURE),
+            quantity=1,
+            side="sell",
+            order_type=Order.OrderType.MARKET,
+        )
+        live_order.set_identifier("222")
+        live_order.status = Order.OrderStatus.NEW
+
+        broker._new_orders.append(stale_order)
+        broker._new_orders.append(live_order)
+        broker._active_broker_identifiers = {"222"}
+
+        with patch.object(broker, "_refresh_active_identifiers_snapshot", return_value={"222"}) as mock_refresh, \
+             patch.object(broker, "cancel_orders") as mock_cancel:
+            broker.cancel_open_orders("Strategy")
+
+        mock_refresh.assert_not_called()
+        mock_cancel.assert_called_once()
+        args, _ = mock_cancel.call_args
+        assert args[0] == [live_order]
+        assert stale_order.status == broker.CANCELED_ORDER
+        assert not stale_order.is_active()
+
+    def test_cancel_open_orders_refreshes_cache_when_missing(self):
+        from lumibot.entities import Asset, Order
+
+        broker = self._make_broker()
+
+        live_order = Order(
+            strategy="Strategy",
+            asset=Asset("ESZ5", asset_type=Asset.AssetType.FUTURE),
+            quantity=1,
+            side="sell",
+            order_type=Order.OrderType.MARKET,
+        )
+        live_order.set_identifier("333")
+        live_order.status = Order.OrderStatus.NEW
+        broker._new_orders.append(live_order)
+        broker._active_broker_identifiers = None
+
+        with patch.object(broker, "_refresh_active_identifiers_snapshot", return_value={"333"}) as mock_refresh, \
+             patch.object(broker, "cancel_orders") as mock_cancel:
+            broker.cancel_open_orders("Strategy")
+
+        mock_refresh.assert_called_once()
+        mock_cancel.assert_called_once()
+
+
 class TestTradovateTokenRenewal:
     """Test the token renewal functionality."""