clean up testing

Author: TexasCoding

tests/test_async_client.py

@@ -7,11 +7,11 @@
 import pytest
 
 from project_x_py import (
-    AsyncProjectX,
+    ProjectX,
     ProjectXConfig,
     ProjectXConnectionError,
+    RateLimiter,
 )
-from project_x_py.async_client import AsyncRateLimiter
 
 
 @pytest.fixture
@@ -24,7 +24,7 @@ def mock_env_vars(monkeypatch):
 @pytest.mark.asyncio
 async def test_async_client_creation():
     """Test async client can be created."""
-    client = AsyncProjectX(
+    client = ProjectX(
         username="test_user",
         api_key="test_key",
     )
@@ -37,7 +37,7 @@ async def test_async_client_creation():
 @pytest.mark.asyncio
 async def test_async_client_from_env(mock_env_vars):
     """Test creating async client from environment variables."""
-    async with AsyncProjectX.from_env() as client:
+    async with ProjectX.from_env() as client:
         assert client.username == "test_username"
         assert client.api_key == "test_api_key"
         assert client._client is not None  # Client should be initialized
@@ -46,7 +46,7 @@ async def test_async_client_from_env(mock_env_vars):
 @pytest.mark.asyncio
 async def test_async_context_manager():
     """Test async client works as context manager."""
-    client = AsyncProjectX(username="test", api_key="key")
+    client = ProjectX(username="test", api_key="key")
 
     # Client should not be initialized yet
     assert client._client is None
@@ -63,7 +63,7 @@ async def test_async_context_manager():
 @pytest.mark.asyncio
 async def test_http2_support():
     """Test that HTTP/2 is enabled."""
-    client = AsyncProjectX(username="test", api_key="key")
+    client = ProjectX(username="test", api_key="key")
 
     async with client:
         # Check HTTP/2 is enabled
@@ -73,7 +73,7 @@ async def test_http2_support():
 @pytest.mark.asyncio
 async def test_authentication_flow():
     """Test authentication flow with mocked responses."""
-    client = AsyncProjectX(username="test", api_key="key")
+    client = ProjectX(username="test", api_key="key")
 
     # Mock responses
     mock_login_response = {
@@ -113,7 +113,7 @@ async def test_authentication_flow():
 @pytest.mark.asyncio
 async def test_concurrent_requests():
     """Test that async client can handle concurrent requests."""
-    client = AsyncProjectX(username="test", api_key="key")
+    client = ProjectX(username="test", api_key="key")
 
     # Mock responses
     positions_response = [
@@ -175,7 +175,7 @@ async def mock_make_request(method, endpoint, **kwargs):
 @pytest.mark.asyncio
 async def test_cache_functionality():
     """Test that caching works for instruments."""
-    client = AsyncProjectX(username="test", api_key="key")
+    client = ProjectX(username="test", api_key="key")
 
     instrument_response = [
         {
@@ -222,7 +222,7 @@ async def mock_make_request(method, endpoint, **kwargs):
 @pytest.mark.asyncio
 async def test_error_handling():
     """Test error handling and retries."""
-    client = AsyncProjectX(username="test", api_key="key")
+    client = ProjectX(username="test", api_key="key")
 
     async with client:
         # Test connection error with retries
@@ -240,7 +240,7 @@ async def test_error_handling():
 @pytest.mark.asyncio
 async def test_health_status():
     """Test health status reporting."""
-    client = AsyncProjectX(username="test", api_key="key")
+    client = ProjectX(username="test", api_key="key")
     client.account_info = MagicMock()
     client.account_info.name = "Test Account"
 
@@ -269,7 +269,7 @@ async def test_health_status():
 @pytest.mark.asyncio
 async def test_list_accounts():
     """Test listing accounts."""
-    client = AsyncProjectX(username="test", api_key="key")
+    client = ProjectX(username="test", api_key="key")
 
     mock_accounts = [
         {
@@ -307,7 +307,7 @@ async def test_list_accounts():
 @pytest.mark.asyncio
 async def test_search_instruments():
     """Test searching for instruments."""
-    client = AsyncProjectX(username="test", api_key="key")
+    client = ProjectX(username="test", api_key="key")
 
     mock_instruments = [
         {
@@ -349,7 +349,7 @@ async def test_search_instruments():
 @pytest.mark.asyncio
 async def test_get_bars():
     """Test getting market data bars."""
-    client = AsyncProjectX(username="test", api_key="key")
+    client = ProjectX(username="test", api_key="key")
     client.account_info = MagicMock()
     client.account_info.id = 123
 
@@ -399,7 +399,7 @@ async def test_get_bars():
 @pytest.mark.asyncio
 async def test_search_trades():
     """Test searching trade history."""
-    client = AsyncProjectX(username="test", api_key="key")
+    client = ProjectX(username="test", api_key="key")
     client.account_info = MagicMock()
     client.account_info.id = 123
 
@@ -452,9 +452,10 @@ async def test_rate_limiting():
     """Test rate limiting functionality."""
     import time
 
-    client = AsyncProjectX(username="test", api_key="key")
+    client = ProjectX(username="test", api_key="key")
     # Set aggressive rate limit for testing
-    client.rate_limiter = AsyncRateLimiter(max_requests=2, window_seconds=1)
+    rate_limiter = RateLimiter(requests_per_minute=2)
+    client.rate_limiter = rate_limiter
 
     async with client:
         with patch.object(

tests/test_async_comprehensive.py

@@ -11,7 +11,6 @@
 import pytest
 
 from project_x_py import (
-    AsyncProjectX,
     ProjectX,
     ProjectXAuthenticationError,
     ProjectXConfig,
@@ -24,7 +23,7 @@ class TestAsyncProjectXClient:
     @pytest.mark.asyncio
     async def test_async_init_with_credentials(self):
         """Test async client initialization with explicit credentials."""
-        client = AsyncProjectX(username="test_user", api_key="test_key")
+        client = ProjectX(username="test_user", api_key="test_key")
 
         assert client.username == "test_user"
         assert client.api_key == "test_key"
@@ -36,7 +35,7 @@ async def test_async_init_with_config(self):
         """Test async client initialization with custom configuration."""
         config = ProjectXConfig(timeout_seconds=60, retry_attempts=5)
 
-        client = AsyncProjectX(username="test_user", api_key="test_key", config=config)
+        client = ProjectX(username="test_user", api_key="test_key", config=config)
 
         assert client.config.timeout_seconds == 60
         assert client.config.retry_attempts == 5
@@ -45,8 +44,8 @@ async def test_async_init_with_config(self):
     async def test_async_init_missing_credentials(self):
         """Test async client initialization with missing credentials."""
         # AsyncProjectX doesn't validate credentials at init time
-        client1 = AsyncProjectX(username="", api_key="test_key")
-        client2 = AsyncProjectX(username="test_user", api_key="")
+        client1 = ProjectX(username="", api_key="test_key")
+        client2 = ProjectX(username="test_user", api_key="")
 
         # Validation happens during authentication
         assert client1.username == ""
@@ -69,9 +68,7 @@ async def test_async_authenticate_success(self):
             mock_response.raise_for_status.return_value = None
             mock_client.post.return_value = mock_response
 
-            async with AsyncProjectX(
-                username="test_user", api_key="test_key"
-            ) as client:
+            async with ProjectX(username="test_user", api_key="test_key") as client:
                 await client.authenticate()
 
                 assert client.session_token == "test_jwt_token"
@@ -98,9 +95,7 @@ async def test_async_authenticate_failure(self):
             )
             mock_client.post.return_value = mock_response
 
-            async with AsyncProjectX(
-                username="test_user", api_key="test_key"
-            ) as client:
+            async with ProjectX(username="test_user", api_key="test_key") as client:
                 with pytest.raises(ProjectXAuthenticationError):
                     await client.authenticate()
 
@@ -167,9 +162,7 @@ async def mock_response_func(url, **kwargs):
             mock_client.post = mock_response_func
             mock_client.get = mock_response_func
 
-            async with AsyncProjectX(
-                username="test_user", api_key="test_key"
-            ) as client:
+            async with ProjectX(username="test_user", api_key="test_key") as client:
                 await client.authenticate()
 
                 # Test concurrent operations
@@ -203,9 +196,7 @@ async def post(self, *args, **kwargs):
                 return response
 
         with patch("httpx.AsyncClient", MockAsyncClient):
-            async with AsyncProjectX(
-                username="test_user", api_key="test_key"
-            ) as client:
+            async with ProjectX(username="test_user", api_key="test_key") as client:
                 pass
 
         assert cleanup_called
@@ -240,9 +231,7 @@ async def mock_get(url, **kwargs):
 
             mock_client.get = mock_get
 
-            async with AsyncProjectX(
-                username="test_user", api_key="test_key"
-            ) as client:
+            async with ProjectX(username="test_user", api_key="test_key") as client:
                 await client.authenticate()
 
                 # Use gather with return_exceptions=True
@@ -315,7 +304,7 @@ async def mock_async_client():
         mock_client.post.return_value = auth_response
         mock_client.get.return_value = account_response
 
-        client = AsyncProjectX(username="test_user", api_key="test_key")
+        client = ProjectX(username="test_user", api_key="test_key")
         # Simulate authentication
         client.session_token = "test_token"
         client.account_info = Mock(id="12345", name="Test Account")
@@ -335,9 +324,9 @@ async def test_authenticated_async_client_operations(self, mock_async_client):
     @pytest.mark.asyncio
     async def test_async_rate_limiting(self):
         """Test async rate limiting functionality."""
-        from project_x_py.utils import AsyncRateLimiter
+        from project_x_py import RateLimiter
 
-        rate_limiter = AsyncRateLimiter(requests_per_minute=120)  # 2 per second
+        rate_limiter = RateLimiter(requests_per_minute=120)  # 2 per second
 
         request_count = 0
 
@@ -369,7 +358,7 @@ def test_config_compatibility(self):
         assert sync_client.config.timeout_seconds == 45
 
         # Test with async client
-        async_client = AsyncProjectX(username="test", api_key="test", config=config)
+        async_client = ProjectX(username="test", api_key="test", config=config)
         assert async_client.config.timeout_seconds == 45
 
     @pytest.mark.asyncio

tests/test_async_integration.py

@@ -13,10 +13,10 @@
 import pytest
 
 from project_x_py import (
-    AsyncProjectX,
-    create_async_order_manager,
-    create_async_position_manager,
-    create_async_trading_suite,
+    ProjectX,
+    create_order_manager,
+    create_position_manager,
+    create_trading_suite,
 )
 from project_x_py.models import Account, Instrument
 
@@ -81,7 +81,7 @@ async def delayed_response(delay=0.1):
             delayed_response(),
         ]
 
-        async with AsyncProjectX("test_user", "test_key") as client:
+        async with ProjectX("test_user", "test_key") as client:
             client.account_info = mock_account
 
             # Sequential calls
@@ -114,15 +114,15 @@ async def delayed_response(delay=0.1):
 @pytest.mark.asyncio
 async def test_trading_suite_integration():
     """Test complete trading suite with all components integrated."""
-    with patch("project_x_py.AsyncProjectX") as mock_client_class:
+    with patch("project_x_py.ProjectX") as mock_client_class:
         # Create mock client
-        mock_client = AsyncMock(spec=AsyncProjectX)
-        mock_client.jwt_token = "test_jwt"
+        mock_client = AsyncMock(spec=ProjectX)
+        mock_client.session_token = "test_jwt"
         mock_client.account_info = MagicMock(id="12345")
         mock_client_class.return_value = mock_client
 
         # Create trading suite
-        suite = await create_async_trading_suite(
+        suite = await create_trading_suite(
             instrument="MGC",
             project_x=mock_client,
             jwt_token="test_jwt",
@@ -150,13 +150,13 @@ async def test_trading_suite_integration():
 @pytest.mark.asyncio
 async def test_concurrent_order_placement():
     """Test placing multiple orders concurrently."""
-    with patch("project_x_py.AsyncProjectX") as mock_client_class:
-        mock_client = AsyncMock(spec=AsyncProjectX)
+    with patch("project_x_py.ProjectX") as mock_client_class:
+        mock_client = AsyncMock(spec=ProjectX)
         mock_client.place_order = AsyncMock(
             side_effect=[MagicMock(success=True, orderId=f"ORD{i}") for i in range(5)]
         )
 
-        order_manager = create_async_order_manager(mock_client)
+        order_manager = create_order_manager(mock_client)
         await order_manager.initialize()
 
         # Place 5 orders concurrently
@@ -193,13 +193,13 @@ async def mock_add_callback(event_type, callback):
     realtime_client.add_callback = mock_add_callback
 
     # Create managers with shared realtime client
-    with patch("project_x_py.AsyncProjectX") as mock_client_class:
+    with patch("project_x_py.ProjectX") as mock_client_class:
         mock_client = AsyncMock()
 
-        order_manager = create_async_order_manager(mock_client, realtime_client)
+        order_manager = create_order_manager(mock_client, realtime_client)
         await order_manager.initialize()
 
-        position_manager = create_async_position_manager(mock_client, realtime_client)
+        position_manager = create_position_manager(mock_client, realtime_client)
         await position_manager.initialize()
 
         # Verify callbacks are registered
@@ -211,7 +211,7 @@ async def mock_add_callback(event_type, callback):
 @pytest.mark.asyncio
 async def test_concurrent_data_analysis():
     """Test analyzing multiple timeframes concurrently."""
-    with patch("project_x_py.AsyncProjectX") as mock_client_class:
+    with patch("project_x_py.ProjectX") as mock_client_class:
         mock_client = AsyncMock()
 
         # Mock data retrieval with different delays
@@ -249,7 +249,7 @@ async def get_data(symbol, days, interval):
 @pytest.mark.asyncio
 async def test_error_handling_in_concurrent_operations():
     """Test that errors in concurrent operations are handled properly."""
-    with patch("project_x_py.AsyncProjectX") as mock_client_class:
+    with patch("project_x_py.ProjectX") as mock_client_class:
         mock_client = AsyncMock()
 
         # Mix successful and failing operations
@@ -330,16 +330,15 @@ async def main_logic():
 @pytest.mark.asyncio
 async def test_rate_limiting_with_concurrent_requests():
     """Test that rate limiting works correctly with concurrent requests."""
-    from project_x_py.utils import AsyncRateLimiter
+    from project_x_py import RateLimiter
 
-    rate_limiter = AsyncRateLimiter(requests_per_minute=60)  # 1 per second
+    rate_limiter = RateLimiter(requests_per_minute=60)  # 1 per second
 
     request_times = []
 
     async def make_request(i):
-        async with rate_limiter:
-            request_times.append(time.time())
-            await asyncio.sleep(0.01)  # Simulate work
+        request_times.append(time.time())
+        await asyncio.sleep(0.01)  # Simulate work
 
     # Try to make 5 requests concurrently
     start_time = time.time()