diff --git a/tests/integration/test_wallet_authentication.py b/tests/integration/test_wallet_authentication.py index 21a26f3b..eafc3666 100644 --- a/tests/integration/test_wallet_authentication.py +++ b/tests/integration/test_wallet_authentication.py @@ -15,7 +15,6 @@ from routstr.core.db import ApiKey from .utils import ( CashuTokenGenerator, - ConcurrencyTester, ResponseValidator, ) @@ -389,69 +388,6 @@ async def test_api_key_with_expiry_time( # The expiry time and refund address functionality is tested elsewhere -@pytest.mark.integration -@pytest.mark.asyncio -async def test_concurrent_token_submissions( - integration_client: AsyncClient, testmint_wallet: Any, integration_session: Any -) -> None: - """Test concurrent submissions of different tokens""" - - # Generate multiple unique tokens with known amounts - num_tokens = 10 - tokens = [] - expected_balances = {} - - for i in range(num_tokens): - amount = 100 + i * 10 - token = await testmint_wallet.mint_tokens(amount) - tokens.append(token) - # Store expected balance by token hash - hashed_key = hashlib.sha256(token.encode()).hexdigest() - expected_balances[hashed_key] = amount * 1000 # msats - - # Create concurrent requests - requests = [ - { - "method": "GET", - "url": "/v1/wallet/info", - "headers": {"Authorization": f"Bearer {token}"}, - } - for token in tokens - ] - - # Execute concurrently - tester = ConcurrencyTester() - responses = await tester.run_concurrent_requests( - integration_client, requests, max_concurrent=5 - ) - - # All should succeed - assert len(responses) == num_tokens - api_keys = set() - - for response in responses: - assert response.status_code == 200 - data = response.json() - api_key = data["api_key"] - api_keys.add(api_key) - - # Verify balance matches the expected amount - hashed_key = api_key[3:] # Remove "sk-" prefix - assert data["balance"] == expected_balances[hashed_key] - - # Should have created unique API keys - assert len(api_keys) == num_tokens - - # Verify all keys exist in database - for api_key in api_keys: - hashed_key = api_key[3:] # Remove "sk-" prefix - result = await integration_session.execute( - select(ApiKey).where(ApiKey.hashed_key == hashed_key) # type: ignore[arg-type] - ) - db_key = result.scalar_one() - assert db_key.balance == expected_balances[hashed_key] - - @pytest.mark.integration @pytest.mark.asyncio async def test_authorization_with_cashu_token_directly( @@ -504,48 +440,6 @@ async def test_x_cashu_header_support( assert response.status_code == 200 -@pytest.mark.integration -@pytest.mark.asyncio -@pytest.mark.slow -async def test_api_key_consistency_under_load( - integration_client: AsyncClient, testmint_wallet: Any, integration_session: Any -) -> None: - """Test API key generation consistency under concurrent load""" - - # Generate a single token - token = await testmint_wallet.mint_tokens(1000) - - # First request to create the API key - integration_client.headers["Authorization"] = f"Bearer {token}" - initial_response = await integration_client.get("/v1/wallet/info") - assert initial_response.status_code == 200 - expected_api_key = initial_response.json()["api_key"] - expected_balance = initial_response.json()["balance"] - - # Try to use the same token concurrently multiple times - # All should return the same API key since it's already created - requests = [ - { - "method": "GET", - "url": "/v1/wallet/info", - "headers": {"Authorization": f"Bearer {token}"}, - } - for _ in range(20) # 20 concurrent attempts - ] - - tester = ConcurrencyTester() - responses = await tester.run_concurrent_requests( - integration_client, requests, max_concurrent=10 - ) - - # All should succeed and return the same API key - for response in responses: - assert response.status_code == 200 - data = response.json() - assert data["api_key"] == expected_api_key - assert data["balance"] == expected_balance - - @pytest.mark.integration @pytest.mark.asyncio async def test_database_timestamp_accuracy( diff --git a/tests/integration/test_wallet_information.py b/tests/integration/test_wallet_information.py index 6f24e895..78dacf63 100644 --- a/tests/integration/test_wallet_information.py +++ b/tests/integration/test_wallet_information.py @@ -13,7 +13,7 @@ from sqlmodel import select, update from routstr.core.db import ApiKey -from .utils import ConcurrencyTester, ResponseValidator +from .utils import ResponseValidator @pytest.mark.integration @@ -204,45 +204,6 @@ async def test_expired_api_key_behavior( assert db_key.refund_address == "test@lightning.address" -@pytest.mark.integration -@pytest.mark.asyncio -async def test_concurrent_access_same_api_key( - integration_client: AsyncClient, authenticated_client: AsyncClient -) -> None: - """Test concurrent access with the same API key""" - - # Get the API key from authenticated client - response = await authenticated_client.get("/v1/wallet/") - api_key = response.json()["api_key"] - initial_balance = response.json()["balance"] - - # Create multiple concurrent requests - requests = [] - for i in range(20): - # Alternate between both endpoints - endpoint = "/v1/wallet/" if i % 2 == 0 else "/v1/wallet/info" - requests.append( - { - "method": "GET", - "url": endpoint, - "headers": {"Authorization": f"Bearer {api_key}"}, - } - ) - - # Execute concurrently - tester = ConcurrencyTester() - responses = await tester.run_concurrent_requests( - integration_client, requests, max_concurrent=10 - ) - - # All should succeed with consistent data - for response in responses: - assert response.status_code == 200 - data = response.json() - assert data["api_key"] == api_key - assert data["balance"] == initial_balance - - @pytest.mark.integration @pytest.mark.asyncio async def test_wallet_info_data_consistency( diff --git a/tests/integration/test_wallet_topup.py b/tests/integration/test_wallet_topup.py index 6f4d5c29..06d66a6c 100644 --- a/tests/integration/test_wallet_topup.py +++ b/tests/integration/test_wallet_topup.py @@ -15,7 +15,6 @@ from routstr.core.db import ApiKey from .utils import ( CashuTokenGenerator, - ConcurrencyTester, ResponseValidator, ) @@ -284,60 +283,6 @@ async def test_transaction_history_tracking( # type: ignore[no-untyped-def] assert response.status_code == 400 -@pytest.mark.integration -@pytest.mark.asyncio -async def test_concurrent_topups_same_api_key( # type: ignore[no-untyped-def] - integration_client: AsyncClient, - authenticated_client: AsyncClient, - testmint_wallet: Any, -) -> None: - """Test concurrent top-ups to the same API key""" - - # Get API key - response = await authenticated_client.get("/v1/wallet/") - api_key = response.json()["api_key"] - initial_balance = response.json()["balance"] - - # Generate multiple unique tokens - num_tokens = 10 - tokens = [] - total_amount = 0 - - for i in range(num_tokens): - amount = 100 + i * 10 # Different amounts - token = await testmint_wallet.mint_tokens(amount) - tokens.append(token) - total_amount += amount - - # Create concurrent top-up requests - requests = [ - { - "method": "POST", - "url": "/v1/wallet/topup", - "params": {"cashu_token": token}, - "headers": {"Authorization": f"Bearer {api_key}"}, - } - for token in tokens - ] - - # Execute concurrently - tester = ConcurrencyTester() - responses = await tester.run_concurrent_requests( - integration_client, requests, max_concurrent=5 - ) - - # All should succeed - for response in responses: - assert response.status_code == 200 - assert "msats" in response.json() - - # Verify final balance is correct - final_response = await authenticated_client.get("/v1/wallet/") - final_balance = final_response.json()["balance"] - expected_balance = initial_balance + (total_amount * 1000) - assert final_balance == expected_balance - - @pytest.mark.integration @pytest.mark.asyncio async def test_topup_during_active_proxy_request( # type: ignore[no-untyped-def]