From 50eabafa57e776b8f82c3d937a54203f377085b1 Mon Sep 17 00:00:00 2001 From: Shroominic Date: Mon, 5 Jan 2026 12:12:04 +0100 Subject: [PATCH] remove performance tests due to unpredictable behaviour --- tests/integration/test_example.py | 24 --------- tests/integration/test_provider_management.py | 42 +--------------- tests/integration/test_proxy_get_endpoints.py | 33 ------------- .../integration/test_proxy_post_endpoints.py | 49 ------------------- tests/integration/test_wallet_information.py | 28 +---------- tests/integration/test_wallet_refund.py | 38 -------------- 6 files changed, 2 insertions(+), 212 deletions(-) diff --git a/tests/integration/test_example.py b/tests/integration/test_example.py index 6657517c..030f7bcb 100644 --- a/tests/integration/test_example.py +++ b/tests/integration/test_example.py @@ -10,7 +10,6 @@ from httpx import AsyncClient from .utils import ( CashuTokenGenerator, - PerformanceValidator, ResponseValidator, ) @@ -159,30 +158,7 @@ async def test_error_handling( assert response.status_code == 401 -@pytest.mark.integration -@pytest.mark.asyncio -async def test_performance_requirements(integration_client: AsyncClient) -> None: - """Test that endpoints meet performance requirements""" - validator = PerformanceValidator() - - # Test info endpoint performance - for i in range(50): - start = validator.start_timing("info_endpoint") - response = await integration_client.get("/") - validator.end_timing("info_endpoint", start) - assert response.status_code == 200 - - # Validate 95th percentile is under 500ms - result = validator.validate_response_time( - "info_endpoint", max_duration=0.5, percentile=0.95 - ) - - assert result["valid"], ( - f"Performance requirement failed: " - f"95th percentile was {result['percentile_time']:.3f}s " - f"(required < {result['max_allowed']}s)" - ) @pytest.mark.integration diff --git a/tests/integration/test_provider_management.py b/tests/integration/test_provider_management.py index 788ad768..cb0417dc 100644 --- a/tests/integration/test_provider_management.py +++ b/tests/integration/test_provider_management.py @@ -11,7 +11,7 @@ from httpx import AsyncClient from routstr.discovery import _PROVIDERS_CACHE -from .utils import PerformanceValidator, ResponseValidator +from .utils import ResponseValidator @pytest.fixture(autouse=True) @@ -518,46 +518,6 @@ async def test_providers_endpoint_response_format( assert isinstance(data_json["providers"], list) -@pytest.mark.integration -@pytest.mark.asyncio -async def test_providers_endpoint_performance(integration_client: AsyncClient) -> None: - """Test providers endpoint meets performance requirements""" - - # Mock quick responses to avoid network delays - mock_events: list[dict[str, Any]] = [ - { - "id": f"event{i}", - "content": f"Provider: http://provider{i}.onion", - "created_at": 1234567890 + i, - } - for i in range(5) - ] - - validator = PerformanceValidator() - - with patch( - "routstr.discovery.query_nostr_relay_for_providers", return_value=mock_events - ): - with patch("routstr.discovery.fetch_provider_health") as mock_fetch: - mock_fetch.return_value = {"status_code": 200, "json": {"status": "online"}} - - # Test multiple requests - for i in range(10): - start = validator.start_timing("providers_endpoint") - response = await integration_client.get("/v1/providers/") - validator.end_timing("providers_endpoint", start) - - assert response.status_code == 200 - - # Validate performance (should be fast with mocked dependencies) - perf_result = validator.validate_response_time( - "providers_endpoint", - max_duration=2.0, # Allow more time since it involves multiple operations - percentile=0.95, - ) - assert perf_result["valid"], f"Performance requirement failed: {perf_result}" - - @pytest.mark.integration @pytest.mark.asyncio async def test_providers_endpoint_concurrent_requests( diff --git a/tests/integration/test_proxy_get_endpoints.py b/tests/integration/test_proxy_get_endpoints.py index ff745d8d..9621e57d 100644 --- a/tests/integration/test_proxy_get_endpoints.py +++ b/tests/integration/test_proxy_get_endpoints.py @@ -18,7 +18,6 @@ from routstr.core.db import ApiKey from .utils import ( ConcurrencyTester, - PerformanceValidator, ) @@ -551,39 +550,7 @@ async def test_proxy_get_concurrent_requests( assert response.status_code == 200 -@pytest.mark.integration -@pytest.mark.asyncio -async def test_proxy_get_performance_requirements( - integration_client: AsyncClient, authenticated_client: AsyncClient -) -> None: - """Test that GET proxy requests meet performance requirements""" - validator = PerformanceValidator() - - with patch("httpx.AsyncClient.request") as mock_request: - mock_response = AsyncMock() - mock_response.status_code = 200 - mock_response.headers = {"content-type": "application/json"} - mock_response.json = MagicMock(return_value={"performance": "test"}) - mock_response.text = '{"performance": "test"}' - mock_response.iter_bytes = AsyncMock(return_value=[b'{"performance": "test"}']) - mock_request.return_value = mock_response - - # Test multiple requests for performance measurement - for i in range(20): - start = validator.start_timing("proxy_get") - response = await authenticated_client.get(f"/v1/perf-test-{i}") - validator.end_timing("proxy_get", start) - - assert response.status_code == 200 - - # Validate performance requirements - perf_result = validator.validate_response_time( - "proxy_get", - max_duration=1.0, # Should complete within 1 second - percentile=0.95, - ) - assert perf_result["valid"], f"Performance requirement failed: {perf_result}" @pytest.mark.integration diff --git a/tests/integration/test_proxy_post_endpoints.py b/tests/integration/test_proxy_post_endpoints.py index a6bc9d9f..8d5fab36 100644 --- a/tests/integration/test_proxy_post_endpoints.py +++ b/tests/integration/test_proxy_post_endpoints.py @@ -15,7 +15,6 @@ from httpx import ASGITransport, AsyncClient from .utils import ( ConcurrencyTester, - PerformanceValidator, ) @@ -290,55 +289,7 @@ async def test_proxy_post_unauthorized_access(integration_client: AsyncClient) - assert response.status_code in [400, 401] -@pytest.mark.integration -@pytest.mark.asyncio -async def test_proxy_post_performance( - integration_client: AsyncClient, authenticated_client: AsyncClient -) -> None: - """Test POST endpoint performance requirements""" - test_payload = { - "model": "gpt-3.5-turbo", - "messages": [{"role": "user", "content": "Performance test"}], - } - - validator = PerformanceValidator() - - with patch("httpx.AsyncClient.send") as mock_send: - # Mock fast responses - async def mock_iter_bytes(*args: Any, **kwargs: Any) -> Any: - yield b'{"choices": [{"message": {"content": "Fast"}}], "usage": {"total_tokens": 5}}' - - mock_response = AsyncMock() - mock_response.status_code = 200 - mock_response.headers = {"content-type": "application/json"} - response_data = { - "choices": [{"message": {"content": "Fast"}}], - "usage": {"total_tokens": 5}, - } - mock_response.text = json.dumps(response_data) - mock_response.json = AsyncMock(return_value=response_data) - mock_response.iter_bytes = mock_iter_bytes - mock_response.aiter_bytes = mock_iter_bytes - mock_send.return_value = mock_response - - # Run multiple requests for performance measurement - for i in range(20): - start = validator.start_timing("proxy_post") - response = await authenticated_client.post( - "/v1/chat/completions", json=test_payload - ) - validator.end_timing("proxy_post", start) - - assert response.status_code == 200 - - # Validate performance - perf_result = validator.validate_response_time( - "proxy_post", - max_duration=1.5, # Allow slightly more time for POST - percentile=0.95, - ) - assert perf_result["valid"], f"Performance requirement failed: {perf_result}" @pytest.mark.integration diff --git a/tests/integration/test_wallet_information.py b/tests/integration/test_wallet_information.py index 78dacf63..3a11f4ef 100644 --- a/tests/integration/test_wallet_information.py +++ b/tests/integration/test_wallet_information.py @@ -3,7 +3,7 @@ Integration tests for wallet information retrieval endpoints. Tests GET /v1/wallet/ and GET /v1/wallet/info endpoints with various scenarios. """ -import time + from datetime import datetime, timedelta from typing import Any @@ -367,30 +367,4 @@ async def test_wallet_info_with_special_characters_in_headers( # Note: Current implementation doesn't return refund_address in response -@pytest.mark.integration -@pytest.mark.asyncio -@pytest.mark.slow -async def test_wallet_endpoints_performance(authenticated_client: AsyncClient) -> None: - """Test wallet endpoints meet performance requirements""" - # Warm up - await authenticated_client.get("/v1/wallet/") - - # Measure response times - response_times = [] - - for _ in range(50): - start_time = time.time() - response = await authenticated_client.get("/v1/wallet/") - end_time = time.time() - - assert response.status_code == 200 - response_times.append(end_time - start_time) - - # Calculate statistics - avg_time = sum(response_times) / len(response_times) - max_time = max(response_times) - - # Performance assertions - assert avg_time < 0.1 # Average should be under 100ms - assert max_time < 0.5 # No request should take more than 500ms diff --git a/tests/integration/test_wallet_refund.py b/tests/integration/test_wallet_refund.py index c2461cae..9770ec7a 100644 --- a/tests/integration/test_wallet_refund.py +++ b/tests/integration/test_wallet_refund.py @@ -537,42 +537,4 @@ async def test_refund_with_expired_key( assert response.json()["recipient"] == "expired@ln.address" -@pytest.mark.integration -@pytest.mark.asyncio -@pytest.mark.slow -async def test_refund_performance( - integration_client: AsyncClient, testmint_wallet: Any -) -> None: - """Test refund endpoint performance""" - import time - - # Create multiple API keys - api_keys = [] - for i in range(10): - token = await testmint_wallet.mint_tokens(100 + i) - # Use cashu token as Bearer auth to create API key - integration_client.headers["Authorization"] = f"Bearer {token}" - response = await integration_client.get("/v1/wallet/info") - assert response.status_code == 200 - api_keys.append(response.json()["api_key"]) - - # Measure refund times - refund_times = [] - - for api_key in api_keys: - integration_client.headers["Authorization"] = f"Bearer {api_key}" - - start_time = time.time() - response = await integration_client.post("/v1/wallet/refund") - end_time = time.time() - - assert response.status_code == 200 - refund_times.append(end_time - start_time) - - # Performance assertions - avg_time = sum(refund_times) / len(refund_times) - max_time = max(refund_times) - - assert avg_time < 0.5 # Average under 500ms - assert max_time < 1.0 # No refund takes more than 1 second