roa2web-service-auto/reports-app/backend/tests/test_cache_real.py

# reports-app/backend/tests/test_cache_real.py
"""
Tests for cache system with REAL Oracle database.
Requires SSH tunnel and valid Oracle credentials.
"""
import pytest
import time


@pytest.mark.oracle
@pytest.mark.cache
@pytest.mark.asyncio
class TestCacheSystemReal:
    """Tests for hybrid cache system (L1 Memory + L2 SQLite)"""

    async def test_cache_stores_and_retrieves_result(self, async_client, auth_headers, test_company_id, oracle_available, cache_initialized):
        """Verify cache stores result and subsequent requests are faster"""
        # First request - likely cache miss
        start1 = time.time()
        response1 = await async_client.get(
            f"/api/dashboard/summary?company={test_company_id}",
            headers=auth_headers
        )
        time1 = time.time() - start1

        assert response1.status_code == 200

        # Second request - should be cache hit (faster)
        start2 = time.time()
        response2 = await async_client.get(
            f"/api/dashboard/summary?company={test_company_id}",
            headers=auth_headers
        )
        time2 = time.time() - start2

        assert response2.status_code == 200

        # Both should return same data
        data1 = response1.json()
        data2 = response2.json()

        # Note: Cache hit is usually faster, but not guaranteed
        print(f"First request: {time1:.3f}s, Second request: {time2:.3f}s")

    async def test_cache_metadata_header(self, async_client, auth_headers, test_company_id, oracle_available, cache_initialized):
        """Verify cache metadata is returned when requested"""
        headers = {**auth_headers, "X-Include-Cache-Metadata": "true"}

        # Make two requests to ensure second is cache hit
        await async_client.get(
            f"/api/dashboard/summary?company={test_company_id}",
            headers=headers
        )

        response = await async_client.get(
            f"/api/dashboard/summary?company={test_company_id}",
            headers=headers
        )

        assert response.status_code == 200
        data = response.json()

        # Check if cache metadata is included
        if 'cache_hit' in data:
            assert isinstance(data['cache_hit'], bool)
        if 'cache_source' in data:
            # cache_source can be 'L1', 'L2', or None (uppercase)
            assert data['cache_source'] in ['L1', 'L2', 'l1', 'l2', None]

    async def test_cache_endpoint_stats(self, async_client, auth_headers, oracle_available, cache_initialized):
        """Verify cache stats endpoint works"""
        response = await async_client.get(
            "/api/cache/stats",
            headers=auth_headers
        )

        # May return 200, 404 (not found), or 500 (cache not initialized in test context)
        assert response.status_code in [200, 404, 500]

        if response.status_code == 200:
            data = response.json()
            assert isinstance(data, dict)

    async def test_cache_invalidation(self, async_client, auth_headers, test_company_id, oracle_available, cache_initialized):
        """Verify cache invalidation works"""
        # First, make a request to populate cache
        await async_client.get(
            f"/api/dashboard/summary?company={test_company_id}",
            headers=auth_headers
        )

        # Try to invalidate cache
        response = await async_client.post(
            "/api/cache/invalidate",
            headers=auth_headers,
            json={"company_id": test_company_id, "cache_type": "dashboard"}
        )

        # May return various status codes depending on implementation
        assert response.status_code in [200, 204, 404, 422]


@pytest.mark.oracle
@pytest.mark.cache
@pytest.mark.asyncio
class TestCachePerformanceReal:
    """Performance tests for cache system"""

    @pytest.mark.slow
    async def test_multiple_concurrent_requests(self, async_client, auth_headers, test_company_id, oracle_available, cache_initialized):
        """Test multiple concurrent requests benefit from cache"""
        import asyncio

        async def make_request():
            return await async_client.get(
                f"/api/dashboard/summary?company={test_company_id}",
                headers=auth_headers
            )

        # Make 5 concurrent requests
        start = time.time()
        responses = await asyncio.gather(*[make_request() for _ in range(5)])
        total_time = time.time() - start

        # All should succeed
        for response in responses:
            assert response.status_code == 200

        print(f"5 concurrent requests completed in {total_time:.3f}s")

    @pytest.mark.slow
    async def test_cache_hit_rate(self, async_client, auth_headers, test_company_id, oracle_available, cache_initialized):
        """Test cache hit rate over multiple requests"""
        num_requests = 10
        times = []

        for i in range(num_requests):
            start = time.time()
            response = await async_client.get(
                f"/api/dashboard/summary?company={test_company_id}",
                headers=auth_headers
            )
            elapsed = time.time() - start
            times.append(elapsed)
            assert response.status_code == 200

        # Calculate statistics
        avg_time = sum(times) / len(times)
        first_time = times[0]
        avg_cached_time = sum(times[1:]) / (len(times) - 1) if len(times) > 1 else 0

        print(f"First request: {first_time:.3f}s")
        print(f"Average cached: {avg_cached_time:.3f}s")
        print(f"Overall average: {avg_time:.3f}s")


@pytest.mark.oracle
@pytest.mark.cache
@pytest.mark.asyncio
class TestCacheDifferentEndpoints:
    """Test cache works across different endpoints"""

    async def test_invoices_caching(self, async_client, auth_headers, test_company_id, oracle_available, cache_initialized):
        """Verify invoices endpoint benefits from caching"""
        # First request
        start1 = time.time()
        response1 = await async_client.get(
            f"/api/invoices/?company={test_company_id}&page=1&page_size=10",
            headers=auth_headers
        )
        time1 = time.time() - start1

        # Second request (same parameters)
        start2 = time.time()
        response2 = await async_client.get(
            f"/api/invoices/?company={test_company_id}&page=1&page_size=10",
            headers=auth_headers
        )
        time2 = time.time() - start2

        assert response1.status_code == 200
        assert response2.status_code == 200

        print(f"Invoices - First: {time1:.3f}s, Second: {time2:.3f}s")

    async def test_treasury_caching(self, async_client, auth_headers, test_company_id, oracle_available, cache_initialized):
        """Verify treasury endpoint benefits from caching"""
        # First request
        start1 = time.time()
        response1 = await async_client.get(
            f"/api/treasury/bank-cash-register?company={test_company_id}",
            headers=auth_headers
        )
        time1 = time.time() - start1

        # Second request
        start2 = time.time()
        response2 = await async_client.get(
            f"/api/treasury/bank-cash-register?company={test_company_id}",
            headers=auth_headers
        )
        time2 = time.time() - start2

        assert response1.status_code == 200
        assert response2.status_code == 200

        print(f"Treasury - First: {time1:.3f}s, Second: {time2:.3f}s")