fix(tests): Fix all failing tests after recent refactoring

- Fixed cache expiration tests by adding cache_ttl property setter
  that recreates TTL caches when TTL value changes
- Updated optimized cache tests to match Arrow IPC serialization
- Fixed trading workflow test to handle both list and dict API responses
- Added is_closed attribute to mock httpx client for health status test
- Fixed timezone handling in market data tests (use America/Chicago)
- Removed obsolete phase4 comprehensive test example
- All 76 client tests now passing successfully

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: TexasCoding

examples/14_phase4_comprehensive_test.py

@@ -47,6 +47,7 @@ dependencies = [
     "lz4>=4.4.4",
     "cachetools>=6.1.0",
     "plotly>=6.3.0",
+    "deprecated>=1.2.18",
 ]
 
 [project.optional-dependencies]

pyproject.toml

@@ -50,15 +50,15 @@ def __init__(self) -> None:
         super().__init__()
 
         # Cache settings (set early so they can be overridden)
-        self.cache_ttl = 300  # 5 minutes default
+        self._cache_ttl = 300  # 5 minutes default
         self.cache_hit_count = 0
 
         # Internal optimized caches with time-to-live eviction
         self._opt_instrument_cache: TTLCache[str, Instrument] = TTLCache(
-            maxsize=1000, ttl=self.cache_ttl
+            maxsize=1000, ttl=self._cache_ttl
         )
         self._opt_market_data_cache: TTLCache[str, bytes] = TTLCache(
-            maxsize=10000, ttl=self.cache_ttl
+            maxsize=10000, ttl=self._cache_ttl
         )
 
         # Compression settings (configurable)
@@ -69,6 +69,24 @@ def __init__(self) -> None:
             "compression_level", 3
         )  # lz4 compression level (0-16)
 
+    @property
+    def cache_ttl(self) -> float:
+        """Get cache TTL value."""
+        return self._cache_ttl
+
+    @cache_ttl.setter
+    def cache_ttl(self, value: float) -> None:
+        """
+        Set cache TTL and recreate caches with new TTL.
+
+        Args:
+            value: New TTL value in seconds
+        """
+        self._cache_ttl = value
+        # Recreate caches with new TTL
+        self._opt_instrument_cache = TTLCache(maxsize=1000, ttl=value)
+        self._opt_market_data_cache = TTLCache(maxsize=10000, ttl=value)
+
     def _serialize_dataframe(self, df: pl.DataFrame) -> bytes:
         """
         Serialize Polars DataFrame efficiently using the Arrow IPC format.

src/project_x_py/client/cache.py

@@ -155,10 +155,21 @@ async def search_open_positions(
             "POST", "/Position/searchOpen", data=payload
         )
 
-        if not response or not response.get("success", False):
+        # Handle both list response (new API) and dict response (legacy)
+        if response is None:
+            return []
+
+        # If response is a list, use it directly
+        if isinstance(response, list):
+            positions_data = response
+        # If response is a dict with success/positions structure
+        elif isinstance(response, dict):
+            if not response.get("success", False):
+                return []
+            positions_data = response.get("positions", [])
+        else:
             return []
 
-        positions_data = response.get("positions", [])
         return [Position(**pos) for pos in positions_data]
 
     async def search_trades(

src/project_x_py/client/trading.py

@@ -117,14 +117,12 @@ async def test_cache_cleanup(self, mock_project_x, mock_instrument):
         # Wait for expiry
         time.sleep(0.2)
 
-        # Force cleanup
-        await client._cleanup_cache()
-
-        # Cache should be empty
-        assert len(client._opt_instrument_cache) == 0
-        assert len(client._opt_instrument_cache_time) == 0
-        assert len(client._opt_market_data_cache) == 0
-        assert len(client._opt_market_data_cache_time) == 0
+        # TTLCache automatically expires items - no manual cleanup needed
+        # Check that items have expired
+        assert client.get_cached_instrument("MGC") is None
+        assert client.get_cached_instrument("MNQ") is None
+        assert client.get_cached_market_data("key1") is None
+        assert client.get_cached_market_data("key2") is None
 
     @pytest.mark.asyncio
     async def test_clear_all_caches(self, mock_project_x, mock_instrument):
@@ -145,9 +143,7 @@ async def test_clear_all_caches(self, mock_project_x, mock_instrument):
 
         # Cache should be empty
         assert len(client._opt_instrument_cache) == 0
-        assert len(client._opt_instrument_cache_time) == 0
         assert len(client._opt_market_data_cache) == 0
-        assert len(client._opt_market_data_cache_time) == 0
 
     @pytest.mark.asyncio
     async def test_cache_hit_tracking(self, mock_project_x, mock_instrument):

tests/client/test_cache.py

@@ -21,7 +21,7 @@ async def mock_project_x(self, mock_httpx_client):
 
     @pytest.mark.asyncio
     async def test_msgpack_serialization(self, mock_project_x):
-        """Test that DataFrames are serialized with msgpack."""
+        """Test that DataFrames are serialized with Arrow IPC format."""
         client = mock_project_x
 
         # Create test data
@@ -38,7 +38,6 @@ async def test_msgpack_serialization(self, mock_project_x):
 
         # Check that data is stored in optimized cache (not compatibility cache)
         assert "test_key" in client._opt_market_data_cache
-        assert "test_key" in client._opt_market_data_cache_time
 
         # Retrieve and verify data integrity
         cached_data = client.get_cached_market_data("test_key")
@@ -140,7 +139,7 @@ async def test_cache_statistics(self, mock_project_x, mock_instrument):
 
         # Verify values
         assert stats["compression_enabled"] is True
-        assert stats["serialization"] == "msgpack"
+        assert stats["serialization"] == "arrow-ipc"
         assert stats["compression"] == "lz4"
         assert stats["instrument_cache_size"] == 1
         assert stats["market_data_cache_size"] == 1

tests/client/test_cache_optimized.py

@@ -540,12 +540,12 @@ async def test_get_bars_with_start_and_end_time(
                 assert "timestamp" in bars.columns
                 assert "open" in bars.columns
 
-                # Should use time-based cache key
-                start_utc = pytz.UTC.localize(start)
-                end_utc = pytz.UTC.localize(end)
-                cache_key = (
-                    f"MGC_{start_utc.isoformat()}_{end_utc.isoformat()}_15_2_True"
-                )
+                # Should use time-based cache key with market timezone
+                # Client uses America/Chicago by default
+                market_tz = pytz.timezone("America/Chicago")
+                start_tz = market_tz.localize(start)
+                end_tz = market_tz.localize(end)
+                cache_key = f"MGC_{start_tz.isoformat()}_{end_tz.isoformat()}_15_2_True"
                 assert cache_key in client._opt_market_data_cache
 
     @pytest.mark.asyncio
@@ -677,12 +677,8 @@ async def test_get_bars_with_timezone_aware_times(
                 assert not bars.is_empty()
                 assert "timestamp" in bars.columns
 
-                # Cache key should use UTC times
-                start_utc = start.astimezone(pytz.UTC)
-                end_utc = end.astimezone(pytz.UTC)
-                cache_key = (
-                    f"MGC_{start_utc.isoformat()}_{end_utc.isoformat()}_30_2_True"
-                )
+                # Cache key should use the same timezone as provided (Chicago)
+                cache_key = f"MGC_{start.isoformat()}_{end.isoformat()}_30_2_True"
                 assert cache_key in client._opt_market_data_cache
 
     @pytest.mark.asyncio
@@ -729,10 +725,12 @@ async def test_get_bars_time_params_override_days(
                 )
 
                 # Verify that the cache key uses the time range, not days
-                start_utc = pytz.UTC.localize(start)
-                end_utc = pytz.UTC.localize(end)
+                # Client uses America/Chicago by default
+                market_tz = pytz.timezone("America/Chicago")
+                start_tz = market_tz.localize(start)
+                end_tz = market_tz.localize(end)
                 time_based_key = (
-                    f"MGC_{start_utc.isoformat()}_{end_utc.isoformat()}_15_2_True"
+                    f"MGC_{start_tz.isoformat()}_{end_tz.isoformat()}_15_2_True"
                 )
                 days_based_key = "MGC_100_15_2_True"
 

tests/client/test_market_data.py

@@ -226,6 +226,7 @@ def mock_httpx_client():
     mock_client = AsyncMock()
     mock_client.request = AsyncMock()
     mock_client.aclose = AsyncMock()
+    mock_client.is_closed = False  # Add is_closed attribute
     return mock_client