lumibot 4.0.22__py3-none-any.whl → 4.1.0__py3-none-any.whl

tests/test_backtesting_data_source_env.py

@@ -0,0 +1,249 @@
+"""
+Test for BACKTESTING_DATA_SOURCE environment variable handling.
+Ensures that datasource_class=None correctly auto-selects from the env var.
+"""
+import os
+from datetime import datetime
+from unittest.mock import patch, MagicMock
+import pytest
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+from lumibot.strategies import Strategy
+from lumibot.backtesting import (
+    PolygonDataBacktesting,
+    ThetaDataBacktesting,
+    YahooDataBacktesting,
+    AlpacaBacktesting,
+)
+
+
+@pytest.fixture
+def restore_theta_credentials():
+    """Save and restore ThetaData credentials file after test."""
+    creds_path = "/Users/robertgrzesik/ThetaData/ThetaTerminal/creds.txt"
+    original = None
+
+    # Save original credentials if file exists
+    if os.path.exists(creds_path):
+        with open(creds_path, 'r') as f:
+            original = f.read()
+
+    yield
+
+    # Restore original credentials
+    if original is not None:
+        with open(creds_path, 'w') as f:
+            f.write(original)
+    elif os.path.exists(creds_path):
+        # File didn't exist before, remove it
+        os.remove(creds_path)
+
+
+@pytest.fixture
+def clean_environment():
+    """Save and restore environment variables after test."""
+    original_env = os.environ.copy()
+
+    yield
+
+    # Restore original environment completely
+    os.environ.clear()
+    os.environ.update(original_env)
+
+
+class SimpleTestStrategy(Strategy):
+    """Minimal strategy for testing datasource auto-selection."""
+
+    def initialize(self):
+        self.sleeptime = "1D"
+
+    def on_trading_iteration(self):
+        if self.first_iteration:
+            # Just buy one share to have some activity
+            order = self.create_order("SPY", quantity=1, side="buy")
+            self.submit_order(order)
+
+
+class TestBacktestingDataSourceEnv:
+    """Test BACKTESTING_DATA_SOURCE environment variable."""
+
+    def test_auto_select_polygon_case_insensitive(self, clean_environment, restore_theta_credentials, caplog):
+        """Test that BACKTESTING_DATA_SOURCE=polygon (lowercase) selects PolygonDataBacktesting."""
+        # Configure caplog to capture INFO level logs from lumibot.strategies._strategy
+        import logging
+        caplog.set_level(logging.INFO, logger='lumibot.strategies._strategy')
+
+        with patch.dict(os.environ, {'BACKTESTING_DATA_SOURCE': 'polygon'}):
+            # Re-import credentials to pick up env change
+            from importlib import reload
+            import lumibot.credentials
+            reload(lumibot.credentials)
+
+            backtesting_start = datetime(2023, 1, 1)
+            backtesting_end = datetime(2023, 1, 10)  # Shorter backtest for speed
+
+            # Run a short backtest to verify env var is read
+            SimpleTestStrategy.run_backtest(
+                None,  # Auto-select from env var
+                backtesting_start=backtesting_start,
+                backtesting_end=backtesting_end,
+                polygon_api_key="test_key",
+                show_plot=False,
+                show_tearsheet=False,
+                show_indicators=False,
+                show_progress_bar=False,
+            )
+
+            # Verify the log message shows polygon was selected
+            assert any("Auto-selected backtesting data source from BACKTESTING_DATA_SOURCE env var: polygon" in record.message
+                      for record in caplog.records)
+
+    def test_auto_select_thetadata_case_insensitive(self, clean_environment, restore_theta_credentials, caplog):
+        """Test that BACKTESTING_DATA_SOURCE=THETADATA (uppercase) selects ThetaDataBacktesting."""
+        with patch.dict(os.environ, {'BACKTESTING_DATA_SOURCE': 'THETADATA'}):
+            # Re-import credentials to pick up env change
+            from importlib import reload
+            import lumibot.credentials
+            reload(lumibot.credentials)
+
+            backtesting_start = datetime(2023, 1, 1)
+            backtesting_end = datetime(2023, 1, 10)  # Shorter backtest for speed
+
+            # Try to run backtest - may fail due to test credentials, but that's okay
+            try:
+                SimpleTestStrategy.run_backtest(
+                    None,  # Auto-select from env var
+                    backtesting_start=backtesting_start,
+                    backtesting_end=backtesting_end,
+                    thetadata_username="test_user",
+                    thetadata_password="test_pass",
+                    show_plot=False,
+                    show_tearsheet=False,
+                    show_indicators=False,
+                    show_progress_bar=False,
+                )
+            except Exception:
+                # Expected to fail with test credentials - that's okay
+                pass
+
+            # Verify the log message shows thetadata was selected OR check for ThetaData error
+            thetadata_selected = any("Auto-selected backtesting data source from BACKTESTING_DATA_SOURCE env var: THETADATA" in record.message
+                                    for record in caplog.records)
+            thetadata_attempted = any("Cannot connect to Theta Data" in record.message or "ThetaData" in record.message
+                                     for record in caplog.records)
+            assert thetadata_selected or thetadata_attempted, "ThetaData was not selected from env var"
+
+    def test_auto_select_yahoo(self, clean_environment, restore_theta_credentials, caplog):
+        """Test that BACKTESTING_DATA_SOURCE=Yahoo selects YahooDataBacktesting."""
+        with patch.dict(os.environ, {'BACKTESTING_DATA_SOURCE': 'Yahoo'}):
+            # Re-import credentials to pick up env change
+            from importlib import reload
+            import lumibot.credentials
+            reload(lumibot.credentials)
+
+            backtesting_start = datetime(2023, 1, 1)
+            backtesting_end = datetime(2023, 1, 10)  # Shorter backtest for speed
+
+            # Run a short backtest to verify env var is read
+            # If this completes without error, Yahoo was successfully selected
+            SimpleTestStrategy.run_backtest(
+                None,  # Auto-select from env var
+                backtesting_start=backtesting_start,
+                backtesting_end=backtesting_end,
+                show_plot=False,
+                show_tearsheet=False,
+                show_indicators=False,
+                show_progress_bar=False,
+            )
+
+            # If we got here without exception, Yahoo was successfully used
+            # (No explicit verification needed - successful backtest is the proof)
+
+    def test_invalid_data_source_raises_error(self, clean_environment, restore_theta_credentials):
+        """Test that invalid BACKTESTING_DATA_SOURCE raises ValueError."""
+        with patch.dict(os.environ, {'BACKTESTING_DATA_SOURCE': 'InvalidSource'}):
+            # Re-import credentials to pick up env change
+            from importlib import reload
+            import lumibot.credentials
+            reload(lumibot.credentials)
+
+            backtesting_start = datetime(2023, 1, 1)
+            backtesting_end = datetime(2023, 1, 31)
+
+            with pytest.raises(ValueError, match="Unknown BACKTESTING_DATA_SOURCE"):
+                SimpleTestStrategy.run_backtest(
+                    None,  # Auto-select from env var
+                    backtesting_start=backtesting_start,
+                    backtesting_end=backtesting_end,
+                    show_plot=False,
+                    show_tearsheet=False,
+                    show_indicators=False,
+                )
+
+    def test_explicit_datasource_overrides_env(self, clean_environment, restore_theta_credentials, caplog):
+        """Test that explicit datasource_class overrides BACKTESTING_DATA_SOURCE env var."""
+        with patch.dict(os.environ, {'BACKTESTING_DATA_SOURCE': 'polygon'}):
+            # Re-import credentials to pick up env change
+            from importlib import reload
+            import lumibot.credentials
+            reload(lumibot.credentials)
+
+            backtesting_start = datetime(2023, 1, 1)
+            backtesting_end = datetime(2023, 1, 10)  # Shorter backtest for speed
+
+            # Run backtest with explicit Yahoo datasource despite env saying polygon
+            SimpleTestStrategy.run_backtest(
+                YahooDataBacktesting,  # Explicit override
+                backtesting_start=backtesting_start,
+                backtesting_end=backtesting_end,
+                show_plot=False,
+                show_tearsheet=False,
+                show_indicators=False,
+                show_progress_bar=False,
+            )
+
+            # Verify the auto-select message was NOT logged (explicit datasource was used)
+            assert not any("Auto-selected backtesting data source" in record.message
+                          for record in caplog.records)
+
+    def test_default_thetadata_when_no_env_set(self, clean_environment, restore_theta_credentials, caplog):
+        """Test that ThetaData is the default when BACKTESTING_DATA_SOURCE is not set."""
+        # Remove BACKTESTING_DATA_SOURCE from env
+        env_without_datasource = {k: v for k, v in os.environ.items() if k != 'BACKTESTING_DATA_SOURCE'}
+
+        with patch.dict(os.environ, env_without_datasource, clear=True):
+            # Re-import credentials to pick up env change
+            from importlib import reload
+            import lumibot.credentials
+            reload(lumibot.credentials)
+
+            backtesting_start = datetime(2023, 1, 1)
+            backtesting_end = datetime(2023, 1, 10)  # Shorter backtest for speed
+
+            # Try to run backtest - may fail due to test credentials, but that's okay
+            try:
+                SimpleTestStrategy.run_backtest(
+                    None,  # Auto-select from env var (should default to ThetaData)
+                    backtesting_start=backtesting_start,
+                    backtesting_end=backtesting_end,
+                    thetadata_username="test_user",
+                    thetadata_password="test_pass",
+                    show_plot=False,
+                    show_tearsheet=False,
+                    show_indicators=False,
+                    show_progress_bar=False,
+                )
+            except Exception:
+                # Expected to fail with test credentials - that's okay
+                pass
+
+            # Verify ThetaData was attempted (no auto-select message since it's the default)
+            assert any("Cannot connect to Theta Data" in record.message or "ThetaData" in record.message
+                      for record in caplog.records), "ThetaData was not used as default"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

tests/test_backtesting_quiet_logs_complete.py

@@ -203,13 +203,12 @@ def test_quiet_logs_false_shows_all_info_plus(clean_environment, temp_logfile):
             handler.flush()
     
     console_output = captured_console.getvalue()
-    
-    # During backtesting, console should ALWAYS be ERROR+ only (regardless of BACKTESTING_QUIET_LOGS)
-    # BACKTESTING_QUIET_LOGS only controls file logging
+
+    # When BACKTESTING_QUIET_LOGS=false, console should show INFO+ during backtesting
     assert "DEBUG should not appear" not in console_output
-    assert "INFO should appear" not in console_output  # Console should NOT show INFO during backtesting
-    assert "WARNING should appear" not in console_output  # Console should NOT show WARNING during backtesting
-    assert "ERROR should appear" in console_output  # Console SHOULD show ERROR during backtesting
+    assert "INFO should appear" in console_output  # Console SHOULD show INFO when quiet_logs=false
+    assert "WARNING should appear" in console_output  # Console SHOULD show WARNING when quiet_logs=false
+    assert "ERROR should appear" in console_output  # Console SHOULD show ERROR when quiet_logs=false
     
     # Read file content
     with open(temp_logfile, 'r') as f:
@@ -331,11 +330,11 @@ def test_bot_manager_compatibility(clean_environment, temp_logfile):
             handler.flush()
     
     console_output = captured_console.getvalue()
-    
-    # Bot Manager only reads from CloudWatch/file logs, not console
-    # Console should still be ERROR+ only during backtesting
-    assert "Bot Manager should see this INFO" not in console_output
-    assert "Bot Manager should see this WARNING" not in console_output
+
+    # When BACKTESTING_QUIET_LOGS=False, console should show INFO+ during backtesting
+    # Bot Manager can read from either CloudWatch/file logs or console
+    assert "Bot Manager should see this INFO" in console_output
+    assert "Bot Manager should see this WARNING" in console_output
     assert "Bot Manager should see this ERROR" in console_output
     
     # Read file content

tests/test_databento_helper.py

@@ -41,10 +41,13 @@ class TestDataBentoHelper(unittest.TestCase):
         result = databento_helper._format_futures_symbol_for_databento(mes_continuous, reference_date)
         self.assertIn("MESH5", result)
         
-        # Test regular future (no expiration) - should return raw symbol
+        # Test regular future (no expiration) - should auto-resolve via idiot-proofing
+        # Idiot-proofing: futures without expiration are auto-treated as continuous and resolved
         regular_future = Asset(symbol="ES", asset_type="future")
         result = databento_helper._format_futures_symbol_for_databento(regular_future)
-        self.assertEqual(result, "ES")
+        # Should resolve to a contract month (e.g., ESZ5 for Dec 2025)
+        self.assertIn("ES", result)
+        self.assertRegex(result, r"ES[FGHJKMNQUVXZ]\d", "Should auto-resolve to contract format like ESZ5")
         
         # Test specific contract with expiration (March 2025 = H25)
         result = databento_helper._format_futures_symbol_for_databento(self.test_asset_future)
@@ -129,45 +132,42 @@ class TestDataBentoHelper(unittest.TestCase):
         self.assertEqual(client.timeout, 30)
         self.assertEqual(client.max_retries, 3)
 
-    @patch('lumibot.tools.databento_helper.DATABENTO_AVAILABLE', True)
-    @patch('lumibot.tools.databento_helper.DataBentoClient')
-    def test_get_price_data_from_databento_success(self, mock_client_class):
-        """Test successful data retrieval"""
-        # Mock client and response
-        mock_client_instance = Mock()
-        mock_client_class.return_value = mock_client_instance
-        
-        # Create mock DataFrame response
-        mock_df = pd.DataFrame({
-            'ts_event': pd.to_datetime(['2025-01-01 09:30:00', '2025-01-01 09:31:00']),
-            'open': [100.0, 101.0],
-            'high': [102.0, 103.0],
-            'low': [99.0, 100.0],
-            'close': [101.0, 102.0],
-            'volume': [1000, 1100]
-        })
-        
-        mock_client_instance.get_historical_data.return_value = mock_df
-        
-        # Mock cache functions
-        with patch('lumibot.tools.databento_helper._load_cache', return_value=None), \
-             patch('lumibot.tools.databento_helper._save_cache') as mock_save:
-            
-            result = databento_helper.get_price_data_from_databento(
-                api_key=self.api_key,
-                asset=self.test_asset_future,
-                start=self.start_date,
-                end=self.end_date,
-                timestep="minute"
-            )
-            
-            # Verify result
-            self.assertIsNotNone(result)
-            self.assertIsInstance(result, pd.DataFrame)
-            self.assertEqual(len(result), 2)
-            
-            # Verify cache was called
-            mock_save.assert_called_once()
+    def test_get_price_data_from_databento_success(self):
+        """Test successful data retrieval using real DataBento API"""
+        import os
+
+        # Use real API key from environment
+        api_key = os.environ.get("DATABENTO_API_KEY")
+        if not api_key:
+            self.skipTest("DATABENTO_API_KEY not found in environment")
+
+        # Use Aug 2024 dates (past data that definitely exists)
+        start_date = datetime(2024, 8, 20)
+        end_date = datetime(2024, 8, 21)
+
+        # Test with ES continuous futures (will resolve to appropriate contract)
+        es_asset = Asset(
+            symbol="ES",
+            asset_type=Asset.AssetType.CONT_FUTURE
+        )
+
+        result = databento_helper.get_price_data_from_databento(
+            api_key=api_key,
+            asset=es_asset,
+            start=start_date,
+            end=end_date,
+            timestep="minute"
+        )
+
+        # Verify result
+        self.assertIsNotNone(result, "Should return data from DataBento API")
+        self.assertIsInstance(result, pd.DataFrame)
+        self.assertGreater(len(result), 0, "Should have at least some data rows")
+
+        # Verify DataFrame has expected columns
+        expected_columns = ['open', 'high', 'low', 'close', 'volume']
+        for col in expected_columns:
+            self.assertIn(col, result.columns, f"DataFrame should have {col} column")
 
     @patch('lumibot.tools.databento_helper.DATABENTO_AVAILABLE', False)
     def test_get_price_data_databento_unavailable(self):
@@ -221,51 +221,38 @@ class TestDataBentoHelper(unittest.TestCase):
         expected_name = "ES_20250315_minute_20250101_20250131.parquet"
         self.assertEqual(filename.name, expected_name)
 
-    @patch('lumibot.tools.databento_helper.DATABENTO_AVAILABLE', True)
-    @patch('lumibot.tools.databento_helper.DataBentoClient')
-    def test_no_retry_logic_for_correct_symbol(self, mock_client_class):
-        """Test that the function uses correct symbol/dataset without retry logic"""
-        # Mock client and response
-        mock_client_instance = Mock()
-        mock_client_class.return_value = mock_client_instance
-        
-        # Create mock DataFrame response
-        mock_df = pd.DataFrame({
-            'ts_event': pd.to_datetime(['2025-01-01 09:30:00', '2025-01-01 09:31:00']),
-            'open': [100.0, 101.0],
-            'high': [102.0, 103.0],
-            'low': [99.0, 100.0],
-            'close': [101.0, 102.0],
-            'volume': [1000, 1100]
-        })
-        
-        mock_client_instance.get_historical_data.return_value = mock_df
-        
-        # Mock cache functions
-        with patch('lumibot.tools.databento_helper._load_cache', return_value=None), \
-             patch('lumibot.tools.databento_helper._save_cache'):
-            
-            # Test with MES continuous futures
-            mes_asset = Asset(symbol="MES", asset_type="future")
-            result = databento_helper.get_price_data_from_databento(
-                api_key=self.api_key,
-                asset=mes_asset,
-                start=self.start_date,
-                end=self.end_date,
-                timestep="minute"
-            )
-            
-            # Verify result
-            self.assertIsNotNone(result)
-            
-            # Verify that get_historical_data was called exactly once with correct parameters
-            mock_client_instance.get_historical_data.assert_called_once()
-            call_args = mock_client_instance.get_historical_data.call_args
-            
-            # Check that it was called with the correct symbol (MES) and dataset (GLBX.MDP3)
-            self.assertEqual(call_args[1]['symbols'], 'MES')
-            self.assertEqual(call_args[1]['dataset'], 'GLBX.MDP3')
-            self.assertEqual(call_args[1]['schema'], 'ohlcv-1m')
+    def test_no_retry_logic_for_correct_symbol(self):
+        """Test that the function uses correct symbol/dataset without retry logic - using real API"""
+        import os
+
+        # Use real API key from environment
+        api_key = os.environ.get("DATABENTO_API_KEY")
+        if not api_key:
+            self.skipTest("DATABENTO_API_KEY not found in environment")
+
+        # Use recent dates that should have data
+        start_date = datetime(2025, 1, 2)
+        end_date = datetime(2025, 1, 3)
+
+        # Test with MES continuous futures
+        mes_asset = Asset(symbol="MES", asset_type="future")
+        result = databento_helper.get_price_data_from_databento(
+            api_key=api_key,
+            asset=mes_asset,
+            start=start_date,
+            end=end_date,
+            timestep="minute"
+        )
+
+        # Verify result
+        self.assertIsNotNone(result, "Should return data for MES futures")
+        self.assertIsInstance(result, pd.DataFrame)
+        self.assertGreater(len(result), 0, "Should have data rows for MES")
+
+        # Verify DataFrame structure
+        expected_columns = ['open', 'high', 'low', 'close', 'volume']
+        for col in expected_columns:
+            self.assertIn(col, result.columns, f"DataFrame should have {col} column")
 
     def test_continuous_futures_integration_edge_cases(self):
         """Test edge cases for continuous futures integration with Asset class"""

tests/test_databento_live.py

@@ -27,13 +27,13 @@ load_dotenv()
 def test_symbol_resolution():
     """Test that symbols are properly resolved to contract codes"""
     from lumibot.entities import Asset
-    from lumibot.data_sources.databento_data_polars import DataBentoDataPolars
+    from lumibot.data_sources.databento_data_polars_live import DataBentoDataPolarsLive
     
     print("\n" + "="*60)
     print("TEST 1: Symbol Resolution")
     print("="*60)
     
-    data_source = DataBentoDataPolars(
+    data_source = DataBentoDataPolarsLive(
         api_key=os.getenv('DATABENTO_API_KEY'),
         has_paid_subscription=True,
         enable_live_stream=False  # Don't need streaming for this test
@@ -97,14 +97,14 @@ def test_live_api_connection():
 def test_minute_bar_aggregation():
     """Test minute bar aggregation with <1 minute lag"""
     from lumibot.entities import Asset
-    from lumibot.data_sources.databento_data_polars import DataBentoDataPolars
+    from lumibot.data_sources.databento_data_polars_live import DataBentoDataPolarsLive
     
     print("\n" + "="*60)
     print("TEST 3: Minute Bar Aggregation & Latency")
     print("="*60)
     
     # Initialize with Live API
-    data_source = DataBentoDataPolars(
+    data_source = DataBentoDataPolarsLive(
         api_key=os.getenv('DATABENTO_API_KEY'),
         has_paid_subscription=True,
         enable_live_stream=True
@@ -175,13 +175,13 @@ def test_minute_bar_aggregation():
 )
 def test_api_routing():
     """Test that correct API is used based on time range"""
-    from lumibot.data_sources.databento_data_polars import DataBentoDataPolars
+    from lumibot.data_sources.databento_data_polars_live import DataBentoDataPolarsLive
     
     print("\n" + "="*60)
     print("TEST 4: API Routing (Live vs Historical)")
     print("="*60)
     
-    data_source = DataBentoDataPolars(
+    data_source = DataBentoDataPolarsLive(
         api_key=os.getenv('DATABENTO_API_KEY'),
         has_paid_subscription=True,
         enable_live_stream=True
@@ -219,13 +219,13 @@ def test_api_routing():
 def test_long_time_periods():
     """Test different time periods including long periods (500+ bars)"""
     from lumibot.entities import Asset
-    from lumibot.data_sources.databento_data_polars import DataBentoDataPolars
+    from lumibot.data_sources.databento_data_polars_live import DataBentoDataPolarsLive
     
     print("\n" + "="*60)
     print("TEST 5: Long Time Period Handling (500+ bars)")
     print("="*60)
     
-    data_source = DataBentoDataPolars(
+    data_source = DataBentoDataPolarsLive(
         api_key=os.getenv('DATABENTO_API_KEY'),
         has_paid_subscription=True,
         enable_live_stream=True
@@ -324,14 +324,14 @@ def test_long_time_periods():
 def test_continuous_latency_monitoring():
     """Run continuous tests to verify consistent <1 minute lag"""
     from lumibot.entities import Asset
-    from lumibot.data_sources.databento_data_polars import DataBentoDataPolars
+    from lumibot.data_sources.databento_data_polars_live import DataBentoDataPolarsLive
     
     print("\n" + "="*60)
     print("TEST 6: Continuous Latency Monitoring")
     print("="*60)
     print("Running 5 consecutive tests to verify consistent low latency...")
     
-    data_source = DataBentoDataPolars(
+    data_source = DataBentoDataPolarsLive(
         api_key=os.getenv('DATABENTO_API_KEY'),
         has_paid_subscription=True,
         enable_live_stream=True

tests/test_databento_timezone_fixes.py

@@ -273,10 +273,27 @@ def test_databento_api_integration(api_key_available):
     """Test DataBento API integration when API key is available"""
     if not api_key_available:
         pytest.skip("DataBento API key not available")
-    
-    # This test would run with real API key if available
-    # For now, we skip to avoid API calls in unit tests
-    pass
+
+    # Test actual DataBento API integration with real credentials
+    from lumibot.credentials import DATABENTO_CONFIG
+
+    # Verify credentials are available
+    api_key = DATABENTO_CONFIG.get('API_KEY')
+    if not api_key or api_key == '<your key here>':
+        pytest.skip("Valid DataBento API key not configured")
+
+    # Initialize DataBento data source with real API key
+    data_source = DataBentoData(api_key=api_key)
+
+    # Verify initialization succeeded
+    assert data_source is not None
+    assert data_source.SOURCE == "DATABENTO"
+    assert data_source._api_key == api_key  # Note: private attribute
+
+    # Verify the data source is a live data source (not backtesting)
+    assert hasattr(data_source, 'get_last_price') or hasattr(data_source, 'get_quote')
+
+    print(f"✓ DataBento API integration successful with key: {api_key[:10]}...")
 
 
 if __name__ == "__main__":

tests/test_get_historical_prices.py

@@ -128,10 +128,10 @@ class TestBacktestingDataSources:
         timestep = "day"
         tzinfo = pytz.timezone('America/New_York')
 
-        datetime_start = tzinfo.localize(datetime(2019, 1, 2))
-        datetime_end = tzinfo.localize(datetime(2019, 12, 31))
+        datetime_start = tzinfo.localize(datetime(2025, 1, 2))
+        datetime_end = tzinfo.localize(datetime(2025, 12, 31))
         # First trading day after MLK day
-        now = tzinfo.localize(datetime(2019, 1, 22)).replace(hour=9, minute=30)
+        now = tzinfo.localize(datetime(2025, 1, 21)).replace(hour=9, minute=30)
         data_source = PolygonDataBacktesting(
             datetime_start,
             datetime_end,
@@ -162,10 +162,10 @@ class TestBacktestingDataSources:
         timestep = "day"
         tzinfo = pytz.timezone('America/New_York')
 
-        datetime_start = tzinfo.localize(datetime(2019, 1, 2))
-        datetime_end = tzinfo.localize(datetime(2019, 12, 31))
+        datetime_start = tzinfo.localize(datetime(2025, 1, 2))
+        datetime_end = tzinfo.localize(datetime(2025, 12, 31))
         # First trading day after MLK day
-        now = tzinfo.localize(datetime(2019, 1, 22)).replace(hour=9, minute=30)
+        now = tzinfo.localize(datetime(2025, 1, 21)).replace(hour=9, minute=30)
 
         length = 10
         data_source = PolygonDataBacktesting(