brief-rags-bench/tests/e2e/test_rag_backends_e2e.py

"""End-to-End tests for RAG backend interactions.

Tests environment-specific RAG backend communication, mTLS handling,
and query mode compatibility.
"""

import pytest


@pytest.mark.e2e
class TestRagBackendsE2E:
    """Test RAG backend communication across environments."""

    @pytest.mark.e2e_ift
    @pytest.mark.usefixtures("check_prerequisites")
    def test_ift_bench_mode_query(
        self,
        e2e_client,
        e2e_auth_headers,
        setup_test_settings,
        cleanup_test_sessions
    ):
        """Test IFT RAG backend with bench mode queries."""
        query_data = {
            "environment": "ift",
            "questions": [
                {"body": "Тест IFT bench режима вопрос 1", "with_docs": True},
                {"body": "Тест IFT bench режима вопрос 2", "with_docs": False},
                {"body": "Тест IFT bench режима вопрос 3", "with_docs": True}
            ]
        }

        response = e2e_client.post(
            "/api/v1/query/bench",
            json=query_data,
            headers=e2e_auth_headers,
            timeout=120.0
        )

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

        # Verify response structure
        assert result["environment"] == "ift"
        assert "request_id" in result
        assert "response" in result
        assert "timestamp" in result

        # Response should contain answers for all questions
        assert isinstance(result["response"], (dict, list))

    @pytest.mark.e2e_psi
    @pytest.mark.usefixtures("check_prerequisites")
    def test_psi_backend_mode_query(
        self,
        e2e_client,
        e2e_auth_headers,
        setup_test_settings,
        cleanup_test_sessions
    ):
        """Test PSI RAG backend with backend mode queries."""
        query_data = {
            "environment": "psi",
            "questions": [
                {"body": "Тест PSI backend режима", "with_docs": True}
            ],
            "reset_session": False
        }

        response = e2e_client.post(
            "/api/v1/query/backend",
            json=query_data,
            headers=e2e_auth_headers,
            timeout=120.0
        )

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

        assert result["environment"] == "psi"
        assert "response" in result

    @pytest.mark.e2e_psi
    @pytest.mark.usefixtures("check_prerequisites")
    def test_psi_backend_mode_with_session_reset(
        self,
        e2e_client,
        e2e_auth_headers,
        setup_test_settings,
        cleanup_test_sessions
    ):
        """Test PSI backend mode with session reset."""
        # First query
        query_data_1 = {
            "environment": "psi",
            "questions": [{"body": "Первый вопрос с контекстом", "with_docs": True}],
            "reset_session": False
        }

        response_1 = e2e_client.post(
            "/api/v1/query/backend",
            json=query_data_1,
            headers=e2e_auth_headers,
            timeout=120.0
        )
        assert response_1.status_code == 200

        # Second query with reset
        query_data_2 = {
            "environment": "psi",
            "questions": [{"body": "Второй вопрос после сброса", "with_docs": True}],
            "reset_session": True
        }

        response_2 = e2e_client.post(
            "/api/v1/query/backend",
            json=query_data_2,
            headers=e2e_auth_headers,
            timeout=120.0
        )
        assert response_2.status_code == 200

    @pytest.mark.e2e_prod
    @pytest.mark.usefixtures("check_prerequisites")
    def test_prod_bench_mode_query(
        self,
        e2e_client,
        e2e_auth_headers,
        setup_test_settings,
        cleanup_test_sessions
    ):
        """Test PROD RAG backend with bench mode queries."""
        query_data = {
            "environment": "prod",
            "questions": [
                {"body": "Тест PROD окружения", "with_docs": True}
            ]
        }

        response = e2e_client.post(
            "/api/v1/query/bench",
            json=query_data,
            headers=e2e_auth_headers,
            timeout=120.0
        )

        assert response.status_code == 200
        result = response.json()
        assert result["environment"] == "prod"

    @pytest.mark.e2e
    @pytest.mark.usefixtures("check_prerequisites")
    def test_query_with_docs_parameter(
        self,
        e2e_client,
        e2e_auth_headers,
        setup_test_settings,
        cleanup_test_sessions
    ):
        """Test that with_docs parameter is properly handled."""
        query_data = {
            "environment": "ift",
            "questions": [
                {"body": "Вопрос с документами", "with_docs": True},
                {"body": "Вопрос без документов", "with_docs": False}
            ]
        }

        response = e2e_client.post(
            "/api/v1/query/bench",
            json=query_data,
            headers=e2e_auth_headers,
            timeout=120.0
        )

        assert response.status_code == 200

    @pytest.mark.e2e
    @pytest.mark.usefixtures("check_prerequisites")
    def test_multiple_sequential_queries(
        self,
        e2e_client,
        e2e_auth_headers,
        setup_test_settings,
        cleanup_test_sessions
    ):
        """Test multiple sequential queries to same environment."""
        for i in range(3):
            query_data = {
                "environment": "ift",
                "questions": [
                    {"body": f"Последовательный запрос #{i+1}", "with_docs": True}
                ]
            }

            response = e2e_client.post(
                "/api/v1/query/bench",
                json=query_data,
                headers=e2e_auth_headers,
                timeout=120.0
            )

            assert response.status_code == 200
            result = response.json()
            assert "request_id" in result

    @pytest.mark.e2e
    @pytest.mark.usefixtures("check_prerequisites")
    def test_cross_environment_queries(
        self,
        e2e_client,
        e2e_auth_headers,
        setup_test_settings,
        cleanup_test_sessions
    ):
        """Test queries to different environments in sequence."""
        environments = ["ift", "prod"]  # PSI uses backend mode, skip for this test

        for env in environments:
            query_data = {
                "environment": env,
                "questions": [
                    {"body": f"Тест окружения {env.upper()}", "with_docs": True}
                ]
            }

            response = e2e_client.post(
                "/api/v1/query/bench",
                json=query_data,
                headers=e2e_auth_headers,
                timeout=120.0
            )

            assert response.status_code == 200
            result = response.json()
            assert result["environment"] == env