brief-rags-bench/tests/integration/test_settings_integration.py

"""Integration tests for settings endpoints."""

import pytest


@pytest.mark.integration
class TestSettingsIntegration:
    """Integration tests for user settings management."""

    def test_get_settings_success(self, client, auth_headers):
        """Test getting user settings from real DB API."""
        response = client.get("/api/v1/settings", headers=auth_headers)

        # Should return 200 with settings or 404 if no settings yet
        assert response.status_code in [200, 404]

        if response.status_code == 200:
            data = response.json()
            assert "user_id" in data
            assert "settings" in data
            assert "updated_at" in data

            # Check settings structure
            settings = data["settings"]
            for env in ["ift", "psi", "prod"]:
                if env in settings:
                    env_settings = settings[env]
                    assert "apiMode" in env_settings
                    assert env_settings["apiMode"] in ["bench", "backend"]

    def test_update_settings_full(self, client, auth_headers):
        """Test updating settings for all environments."""
        update_data = {
            "settings": {
                "ift": {
                    "apiMode": "bench",
                    "bearerToken": "test-token-ift",
                    "systemPlatform": "test-platform",
                    "systemPlatformUser": "test-user",
                    "platformUserId": "user-123",
                    "platformId": "platform-123",
                    "withClassify": True,
                    "resetSessionMode": False
                },
                "psi": {
                    "apiMode": "backend",
                    "bearerToken": "test-token-psi",
                    "systemPlatform": "test-platform",
                    "systemPlatformUser": "test-user",
                    "platformUserId": "user-456",
                    "platformId": "platform-456",
                    "withClassify": False,
                    "resetSessionMode": True
                },
                "prod": {
                    "apiMode": "bench",
                    "bearerToken": "test-token-prod",
                    "systemPlatform": "test-platform",
                    "systemPlatformUser": "test-user",
                    "platformUserId": "user-789",
                    "platformId": "platform-789",
                    "withClassify": False,
                    "resetSessionMode": False
                }
            }
        }

        response = client.put(
            "/api/v1/settings",
            json=update_data,
            headers=auth_headers
        )

        assert response.status_code == 200

        data = response.json()
        assert "user_id" in data
        assert "settings" in data
        assert "updated_at" in data

        # Verify settings were updated
        assert data["settings"]["ift"]["apiMode"] == "bench"
        assert data["settings"]["ift"]["bearerToken"] == "test-token-ift"
        assert data["settings"]["psi"]["apiMode"] == "backend"
        assert data["settings"]["prod"]["apiMode"] == "bench"

    def test_update_settings_partial(self, client, auth_headers):
        """Test updating settings for single environment."""
        update_data = {
            "settings": {
                "ift": {
                    "apiMode": "backend",
                    "bearerToken": "updated-token",
                    "systemPlatform": "updated-platform",
                    "systemPlatformUser": "updated-user",
                    "platformUserId": "updated-user-id",
                    "platformId": "updated-platform-id",
                    "withClassify": True,
                    "resetSessionMode": True
                }
            }
        }

        response = client.put(
            "/api/v1/settings",
            json=update_data,
            headers=auth_headers
        )

        assert response.status_code == 200

        data = response.json()
        assert data["settings"]["ift"]["apiMode"] == "backend"
        assert data["settings"]["ift"]["bearerToken"] == "updated-token"

    def test_update_then_get_settings(self, client, auth_headers):
        """Test updating settings and then retrieving them."""
        # Update settings
        update_data = {
            "settings": {
                "ift": {
                    "apiMode": "bench",
                    "bearerToken": "integration-test-token",
                    "systemPlatform": "test",
                    "systemPlatformUser": "test",
                    "platformUserId": "test-123",
                    "platformId": "test-456",
                    "withClassify": False,
                    "resetSessionMode": True
                }
            }
        }

        put_response = client.put(
            "/api/v1/settings",
            json=update_data,
            headers=auth_headers
        )

        assert put_response.status_code == 200

        # Get settings
        get_response = client.get("/api/v1/settings", headers=auth_headers)

        assert get_response.status_code == 200

        data = get_response.json()
        assert data["settings"]["ift"]["bearerToken"] == "integration-test-token"
        assert data["settings"]["ift"]["platformUserId"] == "test-123"

    def test_update_settings_invalid_api_mode(self, client, auth_headers):
        """Test updating settings with invalid apiMode."""
        update_data = {
            "settings": {
                "ift": {
                    "apiMode": "invalid_mode",  # Invalid
                    "bearerToken": "",
                    "systemPlatform": "",
                    "systemPlatformUser": "",
                    "platformUserId": "",
                    "platformId": "",
                    "withClassify": False,
                    "resetSessionMode": True
                }
            }
        }

        response = client.put(
            "/api/v1/settings",
            json=update_data,
            headers=auth_headers
        )

        # Should accept any string (no validation on FastAPI side)
        # DB API might validate
        assert response.status_code in [200, 400]

    def test_settings_persistence(self, client, auth_headers):
        """Test that settings persist across requests."""
        # Set unique value
        unique_token = "persistence-test-token-12345"
        update_data = {
            "settings": {
                "psi": {
                    "apiMode": "backend",
                    "bearerToken": unique_token,
                    "systemPlatform": "test",
                    "systemPlatformUser": "test",
                    "platformUserId": "test",
                    "platformId": "test",
                    "withClassify": True,
                    "resetSessionMode": False
                }
            }
        }

        # Update
        client.put("/api/v1/settings", json=update_data, headers=auth_headers)

        # Get multiple times to verify persistence
        for _ in range(3):
            response = client.get("/api/v1/settings", headers=auth_headers)
            assert response.status_code == 200
            data = response.json()
            assert data["settings"]["psi"]["bearerToken"] == unique_token

    def test_settings_require_authentication(self, client):
        """Test that settings endpoints require authentication."""
        # GET without auth
        response = client.get("/api/v1/settings")
        assert response.status_code == 401

        # PUT without auth
        response = client.put("/api/v1/settings", json={"settings": {}})
        assert response.status_code == 401