Skip to content

OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.

Python
40.8 KB
Raw Blame
"""
Unit tests for api.settings.endpoints
Validates error handling in update_docling_preset endpoint.
"""

from unittest.mock import AsyncMock, MagicMock, patch

import httpx
import pytest
from fastapi import HTTPException
from pydantic import ValidationError

from api.settings import DoclingPresetBody, update_docling_preset
from api.settings.models import (
    AssistantMessage,
    OnboardingBody,
    OnboardingFunctionCall,
    SettingsUpdateBody,
)
from session_manager import User


@pytest.mark.asyncio
async def test_update_docling_preset_invalid_preset_returns_400():
    """Test that an invalid preset value returns 400 status code.

    This test ensures that the HTTPException with status_code=400 raised
    for invalid presets is not masked by the broad Exception handler.
    Regression test for issue #1586.
    """
    # Create a body with an invalid preset
    body = DoclingPresetBody(preset="nonexistent_preset")

    # Mock dependencies
    session_manager = AsyncMock()
    user = MagicMock(spec=User)

    # Call the endpoint and expect HTTPException with 400
    with pytest.raises(HTTPException) as exc_info:
        await update_docling_preset(body=body, session_manager=session_manager, user=user)

    # Assert it's a 400 error (not 500)
    assert exc_info.value.status_code == 400
    assert "Invalid preset" in exc_info.value.detail
    assert "nonexistent_preset" in exc_info.value.detail


def test_assistant_message_citation_serialization():
    """Test AssistantMessage model citation parsing with text and metadata."""
    payload = {
        "role": "assistant",
        "content": "Here is the response [1]",
        "timestamp": "2026-07-27T00:00:00.000Z",
        "functionCalls": [
            {
                "name": "search_docs",
                "status": "completed",
                "result": [
                    {
                        "chunk_id": "chunk-123",
                        "filename": "doc.pdf",
                        "page": 2,
                        "score": 0.95,
                        "text": "Extracted chunk text",
                        "embedding_model": "text-embedding-3-small",
                        "parser": "Docling",
                        "chunk_size": 512,
                        "chunk_overlap": 64,
                        "source_url": "https://example.com/doc.pdf",
                        "metadata": {"custom_key": "val"},
                        "data": {
                            "file_path": "/path/to/doc.pdf",
                            "page": 2,
                            "score": 0.95,
                            "text": "Extracted chunk text",
                            "embedding_model": "text-embedding-3-small",
                            "parser": "Docling",
                            "chunk_size": 512,
                            "chunk_overlap": 64,
                        },
                    }
                ],
            }
        ],
    }

    msg = AssistantMessage(**payload)
    assert msg.functionCalls is not None
    assert len(msg.functionCalls) == 1
    fc = msg.functionCalls[0]
    assert isinstance(fc, OnboardingFunctionCall)
    assert fc.result is not None
    result = fc.result[0]
    assert result.text == "Extracted chunk text"
    assert result.embedding_model == "text-embedding-3-small"
    assert result.parser == "Docling"
    assert result.chunk_size == 512
    assert result.chunk_overlap == 64
    assert result.source_url == "https://example.com/doc.pdf"
    assert result.metadata == {"custom_key": "val"}
    assert result.data is not None
    assert result.data.text == "Extracted chunk text"


def test_settings_models_accept_arbitrary_provider_credentials():
    credentials = {
        "gemini": {
            "api_key": "secret",
            "vertex_project": "project-1",
            "vertex_location": "us-central1",
        }
    }

    settings = SettingsUpdateBody(
        llm_provider="gemini",
        llm_model="gemini-2.5-pro",
        provider_credentials=credentials,
    )
    onboarding = OnboardingBody(
        llm_provider="gemini",
        llm_model="gemini-2.5-pro",
        provider_credentials=credentials,
    )

    assert settings.provider_credentials == credentials
    assert onboarding.provider_credentials == credentials


def test_custom_provider_payload_keeps_legacy_openai_secret():
    from api.settings.endpoints import _custom_providers_for_settings
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.providers.openai.api_key = "sk-test"
    config.providers.openai.configured = True
    config.providers.set_credentials("openai", {"organization": "org-1"})

    payload = _custom_providers_for_settings(config)
    assert payload["openai"].secret_fields == ["api_key"]
    assert payload["openai"].credential_values["organization"] == "org-1"


async def _vlm_gate_response(config, provider: str):
    """Run `update_settings` with VLM on, returning whatever the gate answers."""
    from unittest.mock import patch

    from api.settings.endpoints import update_settings

    config.edited = True
    body = SettingsUpdateBody(
        vlm_enabled=True,
        vlm_provider=provider,
        vlm_model=f"{provider}/gpt-4.1",
    )
    models_service = MagicMock()
    models_service.validate_model_configured = AsyncMock(return_value=True)
    rbac = MagicMock()
    rbac.has_permission = AsyncMock(return_value=True)

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch("api.settings.endpoints.config_manager.save_config_file", return_value=True),
        patch("api.settings.endpoints.clients.refresh_patched_client", new_callable=AsyncMock),
    ):
        return await update_settings(
            body=body,
            session_manager=AsyncMock(),
            user=MagicMock(spec=User),
            models_service=models_service,
            rbac=rbac,
        )


def _error_text(response) -> str:
    import json

    return json.loads(bytes(response.body).decode())["error"]


@pytest.mark.asyncio
async def test_update_settings_vlm_configured_without_a_key_says_so():
    """A provider can be fully configured and still have no API key.

    Azure OpenAI requires only `api_base`, so a service-principal or Entra
    configuration is `configured` with no key at all. docling-serve calls the
    model endpoint itself and only ever builds an API-key header, so VLM still
    cannot run — but telling the operator the provider "is not configured"
    sends them to re-enter credentials that are already valid. The two gates
    are separate so the message can name the real limitation.
    """
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.providers.set_credentials(
        "azure",
        {
            "api_base": "https://example.openai.azure.com",
            "tenant_id": "t",
            "client_id": "c",
            "client_secret": "s",
        },
        auth_method="service_principal",
    )
    assert config.providers.custom["azure"].configured, "precondition: configured without a key"

    response = await _vlm_gate_response(config, "azure")

    assert response.status_code == 400
    message = _error_text(response)
    assert "authenticates with an API key" in message
    assert "is not configured" not in message


@pytest.mark.asyncio
async def test_update_settings_vlm_unconfigured_provider_says_not_configured():
    """The other half of the split: nothing is set, so the first gate answers."""
    from config.config_manager import OpenRAGConfig

    response = await _vlm_gate_response(OpenRAGConfig.from_dict({}), "azure_ai")

    assert response.status_code == 400
    message = _error_text(response)
    assert "is not configured" in message
    assert "authenticates with an API key" not in message


@pytest.mark.asyncio
@pytest.mark.parametrize("provider", ["azure", "azure_ai"])
async def test_update_settings_vlm_azure_without_an_endpoint_is_not_configured(provider):
    """Both Azure providers need an endpoint, whatever `configured` claims.

    A config can carry `configured: true` with no `api_base` — the flag is
    read from the file rather than recomputed — and neither provider can be
    called without one.
    """
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict(
        {"providers": {"custom": {provider: {"configured": True, "credentials": {"api_key": "k"}}}}}
    )

    response = await _vlm_gate_response(config, provider)

    assert response.status_code == 400
    assert "is not configured" in _error_text(response)


@pytest.mark.asyncio
async def test_update_settings_vlm_azure_configured():
    """Test that update_settings allows enabling VLM with azure when azure credentials are configured."""
    from unittest.mock import patch

    from api.settings.endpoints import update_settings
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.edited = True
    config.providers.set_credentials(
        "azure", {"api_key": "az-key", "api_base": "https://example.openai.azure.com"}
    )

    body = SettingsUpdateBody(
        vlm_enabled=True,
        vlm_provider="azure",
        vlm_model="azure/gpt-4.1",
    )

    user = MagicMock(spec=User)
    session_manager = AsyncMock()
    models_service = MagicMock()
    models_service.validate_model_configured = AsyncMock(return_value=True)
    rbac = MagicMock()
    rbac.has_permission = AsyncMock(return_value=True)

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch(
            "api.settings.endpoints.config_manager.save_config_file", return_value=True
        ) as mock_save,
        patch("api.settings.endpoints.clients.refresh_patched_client", new_callable=AsyncMock),
    ):
        response = await update_settings(
            body=body,
            session_manager=session_manager,
            user=user,
            models_service=models_service,
            rbac=rbac,
        )
        assert getattr(response, "status_code", 200) == 200
        mock_save.assert_called_once()
        saved_config = mock_save.call_args[0][0]
        assert saved_config.knowledge.vlm_provider == "azure"
        assert saved_config.knowledge.vlm_model == "azure/gpt-4.1"


@pytest.mark.asyncio
async def test_update_settings_rejects_azure_without_an_api_key():
    """The API must enforce the Azure form requirement, not only the browser."""
    from api.settings.endpoints import update_settings
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.edited = True
    body = SettingsUpdateBody(
        provider_credentials={"azure": {"api_base": "https://example.openai.azure.com"}},
        provider_auth_methods={"azure": "api_key"},
    )
    rbac = MagicMock()
    rbac.has_permission = AsyncMock(return_value=True)

    with patch("api.settings.endpoints.get_openrag_config", return_value=config):
        response = await update_settings(
            body=body,
            session_manager=AsyncMock(),
            user=MagicMock(spec=User),
            models_service=MagicMock(),
            rbac=rbac,
        )

    assert response.status_code == 400
    assert b"api_key" in response.body


@pytest.mark.asyncio
async def test_update_settings_validates_azure_credentials_before_saving():
    """A bad Azure endpoint/key must not become a configured provider."""
    from api.settings.endpoints import update_settings
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.edited = True
    body = SettingsUpdateBody(
        provider_credentials={
            "azure": {
                "api_key": "wrong-key",
                "api_base": "https://example.openai.azure.com",
            }
        },
        provider_auth_methods={"azure": "api_key"},
    )
    rbac = MagicMock()
    rbac.has_permission = AsyncMock(return_value=True)

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch(
            "api.settings.endpoints.validate_provider_setup",
            new_callable=AsyncMock,
            side_effect=Exception("Access denied due to invalid subscription key"),
        ) as validate,
        patch("api.settings.endpoints.config_manager.save_config_file") as save,
    ):
        response = await update_settings(
            body=body,
            session_manager=AsyncMock(),
            user=MagicMock(spec=User),
            models_service=MagicMock(),
            rbac=rbac,
        )

    assert response.status_code == 400
    assert b"invalid subscription key" in response.body
    validate.assert_awaited_once()
    save.assert_not_called()


@pytest.mark.asyncio
async def test_update_settings_rejects_invalid_azure_foundry_key_before_saving():
    """The Azure OpenAI form must probe Foundry resource keys on Save too."""
    from api.settings.endpoints import update_settings
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.edited = True
    body = SettingsUpdateBody(
        provider_credentials={
            "azure": {
                "api_key": "wrong-key",
                "api_base": "https://example.services.ai.azure.com",
            }
        },
        provider_auth_methods={"azure": "api_key"},
    )
    rbac = MagicMock()
    rbac.has_permission = AsyncMock(return_value=True)

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch(
            "api.provider_validation._http_request_with_retry",
            new_callable=AsyncMock,
            return_value=httpx.Response(
                401, json={"error": {"message": "Invalid subscription key"}}
            ),
        ) as request,
        patch("api.settings.endpoints.config_manager.save_config_file") as save,
    ):
        response = await update_settings(
            body=body,
            session_manager=AsyncMock(),
            user=MagicMock(spec=User),
            models_service=MagicMock(),
            rbac=rbac,
        )

    assert response.status_code == 400
    assert b"Invalid subscription key" in response.body
    request.assert_awaited_once()
    save.assert_not_called()


@pytest.mark.asyncio
async def test_update_settings_saves_the_auth_method_it_validated_for_a_mixed_case_key():
    """The save must narrow by the same normalized key the probe used.

    Regression: the save read `provider_auth_methods` by the lowercased
    provider key, so `{"Azure": ...}` validated the new method but saved with
    none — keeping the old method's secret and the old `auth_method`.
    """
    from api.settings.endpoints import update_settings
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.edited = True
    config.providers.set_credentials(
        "azure",
        {"api_key": "old-key", "api_base": "https://example.openai.azure.com"},
        auth_method="api_key",
    )
    body = SettingsUpdateBody(
        provider_credentials={"Azure": {"azure_ad_token": "new-token"}},
        provider_auth_methods={"Azure": "entra_token"},
    )
    rbac = MagicMock()
    rbac.has_permission = AsyncMock(return_value=True)

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch("api.settings.endpoints.validate_provider_setup", new_callable=AsyncMock) as validate,
        patch("api.settings.endpoints.config_manager.save_config_file", return_value=True) as save,
        patch("api.settings.endpoints.clients.refresh_patched_client", new_callable=AsyncMock),
    ):
        response = await update_settings(
            body=body,
            session_manager=AsyncMock(),
            user=MagicMock(spec=User),
            models_service=MagicMock(),
            rbac=rbac,
        )

    assert getattr(response, "status_code", 200) == 200
    assert "api_key" not in validate.await_args.kwargs["credentials"]
    save.assert_called_once()
    saved = save.call_args[0][0].providers
    assert saved.custom["azure"].auth_method == "entra_token"
    assert saved.stored_credentials("azure") == {
        "api_base": "https://example.openai.azure.com",
        "azure_ad_token": "new-token",
    }


@pytest.mark.asyncio
async def test_update_settings_validates_enhancement_credentials_before_saving():
    """A credential-only save runs a provider enhancement's model-free check.

    `ProviderSettingsDialog` submits nothing but `provider_credentials`, so the
    `llm_provider` / `embedding_provider` branches never fire. Without a branch
    of its own, a bad OpenShift AI URL or token was stored and the UI reported
    success; the check is handed the untranslated pending form so it sees both
    endpoints, not the one LiteLLM was narrowed to.
    """
    from api.settings.endpoints import update_settings
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.edited = True
    submitted = {
        "api_base": "https://granite-chat.openrag.svc:8443/v1",
        "embedding_api_base": "https://granite-embed.openrag.svc:8443/v1",
        "api_key": "expired-token",
    }
    body = SettingsUpdateBody(provider_credentials={"rhoai": submitted})
    rbac = MagicMock()
    rbac.has_permission = AsyncMock(return_value=True)

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch(
            "api.settings.endpoints.validate_provider_setup",
            new_callable=AsyncMock,
            side_effect=Exception("The OpenShift AI chat endpoint rejected the token"),
        ) as validate,
        patch("api.settings.endpoints.config_manager.save_config_file") as save,
    ):
        response = await update_settings(
            body=body,
            session_manager=AsyncMock(),
            user=MagicMock(spec=User),
            models_service=MagicMock(),
            rbac=rbac,
        )

    assert response.status_code == 400
    assert b"rejected the token" in response.body
    validate.assert_awaited_once()
    kwargs = validate.await_args.kwargs
    assert kwargs["provider"] == "rhoai"
    assert kwargs.get("llm_model") is None and kwargs.get("embedding_model") is None
    assert kwargs["stored_credentials"] == submitted
    save.assert_not_called()


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "fields",
    [
        {"llm_provider": "rhoai", "llm_model": "granite-chat"},
        {"embedding_provider": "rhoai", "embedding_model": "granite-embedding"},
    ],
    ids=["llm", "embedding"],
)
async def test_update_settings_asks_for_a_real_model_probe(fields):
    """A model switch is verified for real, not with the polled lightweight check.

    For a provider enhancement only a real call rejects a model the cluster
    does not serve; without `verify_model` the validator would run the
    model-free check and the switch would save, failing later in chat.
    """
    from api.settings.endpoints import update_settings
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.edited = True
    rbac = MagicMock()
    rbac.has_permission = AsyncMock(return_value=True)

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch(
            "api.settings.endpoints.validate_provider_setup",
            new_callable=AsyncMock,
            side_effect=Exception("stop after validation arguments are captured"),
        ) as validate,
        patch("api.settings.endpoints.config_manager.save_config_file") as save,
    ):
        response = await update_settings(
            body=SettingsUpdateBody(**fields),
            session_manager=AsyncMock(),
            user=MagicMock(spec=User),
            models_service=MagicMock(),
            rbac=rbac,
        )

    assert response.status_code == 400
    validate.assert_awaited_once()
    assert validate.await_args.kwargs["verify_model"] is True
    save.assert_not_called()


@pytest.mark.asyncio
async def test_update_settings_skips_pre_save_check_for_litellm_only_providers():
    """Providers without an enhancement have no model-free probe to run."""
    from api.settings.endpoints import update_settings
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.edited = True
    body = SettingsUpdateBody(
        provider_credentials={"openai_like": {"api_base": "https://llm.example", "api_key": "k"}}
    )
    rbac = MagicMock()
    rbac.has_permission = AsyncMock(return_value=True)

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch("api.settings.endpoints.validate_provider_setup", new_callable=AsyncMock) as validate,
        patch("api.settings.endpoints.config_manager.save_config_file"),
        patch("api.settings.endpoints._update_langflow_global_variables", new_callable=AsyncMock),
    ):
        response = await update_settings(
            body=body,
            session_manager=AsyncMock(),
            user=MagicMock(spec=User),
            models_service=MagicMock(),
            rbac=rbac,
        )

    assert getattr(response, "status_code", 200) == 200
    validate.assert_not_awaited()


@pytest.mark.parametrize(
    "provider",
    ["openai", "watsonx", "anthropic", "local", "ollama", "azure", "azure_ai", "openai_like"],
)
def test_settings_update_body_accepts_configurable_vlm_providers(provider):
    """Any provider key the catalogue can publish must validate.

    `vlm_provider` used to carry a closed enum of the six original providers.
    Every provider added since — `azure_ai` first — 422'd the whole
    ingest-settings save, taking chunk size, OCR and the toggles down with it,
    because the frontend always sends the VLM fields alongside them.
    """
    assert SettingsUpdateBody(vlm_provider=provider).vlm_provider == provider


@pytest.mark.parametrize("provider", ["", "has space", "../etc", "semi;colon"])
def test_settings_update_body_rejects_malformed_vlm_provider(provider):
    with pytest.raises(ValidationError):
        SettingsUpdateBody(vlm_provider=provider)


def test_settings_body_accepts_ocr_languages():
    """OCR languages are settable through the settings API."""
    body = SettingsUpdateBody(ocr_languages=["en", "ja"])

    assert body.ocr_languages == ["ja", "en"]


def test_settings_body_rejects_blank_ocr_language():
    """A blank code would be forwarded to docling and silently break OCR."""
    with pytest.raises(ValidationError):
        SettingsUpdateBody(ocr_languages=["en", "  "])


def test_settings_body_accepts_empty_ocr_language_list():
    """An empty list clears the override so docling uses the engine default."""
    assert SettingsUpdateBody(ocr_languages=[]).ocr_languages == []


def test_settings_body_accepts_one_family_plus_english():
    """A selection drawn from a single recognition-model family is valid."""
    assert SettingsUpdateBody(ocr_languages=["en", "ja"]).ocr_languages == ["ja", "en"]
    assert SettingsUpdateBody(ocr_languages=["ru", "uk"]).ocr_languages == ["ru", "uk"]
    assert SettingsUpdateBody(ocr_languages=["fr", "de", "pt"]).ocr_languages == [
        "fr",
        "de",
        "pt",
    ]


def test_settings_body_rejects_two_restricted_ocr_languages():
    """easyocr cannot serve Japanese and Korean from one recognition model."""
    with pytest.raises(ValidationError):
        SettingsUpdateBody(ocr_languages=["ja", "ko"])


def test_settings_body_rejects_mixed_scripts():
    """Cyrillic and Latin need different easyocr models."""
    with pytest.raises(ValidationError):
        SettingsUpdateBody(ocr_languages=["ru", "fr"])


def test_settings_body_allows_unknown_passthrough_codes():
    """Raw engine codes are the operator's escape hatch; do not second-guess them."""
    assert SettingsUpdateBody(ocr_languages=["hi", "mr"]).ocr_languages == ["hi", "mr"]


@pytest.mark.asyncio
async def test_update_settings_persists_case_insensitive_removal_only_request():
    from api.settings.endpoints import update_settings
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.edited = True
    config.providers.set_credentials(
        "gemini",
        {"api_key": "secret", "api_base": "https://gemini.example.com"},
    )
    body = SettingsUpdateBody(
        provider_credential_removals={"Gemini": ["api_key"]},
    )
    rbac = MagicMock()
    rbac.has_permission = AsyncMock(return_value=True)

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch(
            "api.settings.endpoints.config_manager.save_config_file",
            return_value=True,
        ) as save,
        patch(
            "api.settings.endpoints.clients.refresh_patched_client",
            new_callable=AsyncMock,
        ),
    ):
        response = await update_settings(
            body=body,
            session_manager=AsyncMock(),
            user=MagicMock(spec=User),
            models_service=MagicMock(),
            rbac=rbac,
        )
    assert getattr(response, "status_code", 200) == 200
    saved_config = save.call_args.args[0]
    assert saved_config.providers.stored_credentials("gemini") == {
        "api_base": "https://gemini.example.com"
    }


@pytest.mark.asyncio
async def test_removal_only_provider_update_requires_provider_write_permission():
    from api.settings.endpoints import update_settings
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.edited = True
    rbac = MagicMock()
    rbac.has_permission = AsyncMock(return_value=False)
    rbac.audit_denied = AsyncMock()

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch("api.settings.endpoints.is_rbac_enforced", return_value=True),
        pytest.raises(HTTPException) as exc_info,
    ):
        await update_settings(
            body=SettingsUpdateBody(
                provider_credential_removals={"gemini": ["api_key"]},
            ),
            session_manager=AsyncMock(),
            user=MagicMock(spec=User, db_user_id="user-1", user_id="user-1"),
            models_service=MagicMock(),
            rbac=rbac,
        )

    assert exc_info.value.status_code == 403
    rbac.audit_denied.assert_awaited_once_with("user-1", "providers:write")


@pytest.mark.asyncio
async def test_failed_onboarding_validation_does_not_mutate_cached_config():
    from api.settings.endpoints import onboarding
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.agent.llm_provider = "openai"
    config.agent.llm_model = "old-model"
    body = OnboardingBody(
        llm_provider="openai",
        llm_model="new-model",
        openai_api_key="sk-new",
    )

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch(
            "api.settings.endpoints.TelemetryClient.send_event",
            new_callable=AsyncMock,
        ),
        patch(
            "api.settings.endpoints.validate_provider_setup",
            new_callable=AsyncMock,
            side_effect=Exception("validation failed"),
        ),
    ):
        response = await onboarding(
            body=body,
            flows_service=MagicMock(),
            session_manager=AsyncMock(),
            document_service=MagicMock(),
            models_service=MagicMock(),
            task_service=MagicMock(),
            langflow_file_service=MagicMock(),
            knowledge_filter_service=MagicMock(),
            user=MagicMock(spec=User),
        )

    assert response.status_code == 400
    assert config.agent.llm_model == "old-model"
    assert config.providers.openai.api_key == ""


@pytest.mark.asyncio
async def test_onboarding_validation_receives_onprem_tls_policy():
    from api.settings.endpoints import onboarding
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    body = OnboardingBody(
        llm_provider="watsonx_onprem",
        llm_model="ibm/granite-3-3-8b-instruct",
        provider_credentials={
            "watsonx_onprem": {
                "api_base": "https://cpd.example.com",
                "username": "cpd-user",
                "api_key": "secret",
                "ssl_verify": "false",
            }
        },
        provider_auth_methods={"watsonx_onprem": "username_api_key"},
    )

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch(
            "api.settings.endpoints.TelemetryClient.send_event",
            new_callable=AsyncMock,
        ),
        patch(
            "api.settings.endpoints.validate_provider_setup",
            new_callable=AsyncMock,
            side_effect=Exception("stop after validation arguments are captured"),
        ) as validate,
    ):
        response = await onboarding(
            body=body,
            flows_service=MagicMock(),
            session_manager=AsyncMock(),
            document_service=MagicMock(),
            models_service=MagicMock(),
            task_service=MagicMock(),
            langflow_file_service=MagicMock(),
            knowledge_filter_service=MagicMock(),
            user=MagicMock(spec=User),
        )

    assert response.status_code == 400
    assert validate.await_args.kwargs["stored_credentials"]["ssl_verify"] == "false"


@pytest.mark.asyncio
async def test_onboarding_embedding_validation_receives_onprem_tls_policy():
    from api.settings.endpoints import onboarding
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    body = OnboardingBody(
        embedding_provider="watsonx_onprem",
        embedding_model="ibm/slate-125m-english-rtrvr",
        provider_credentials={
            "watsonx_onprem": {
                "api_base": "https://cpd.example.com",
                "username": "cpd-user",
                "api_key": "secret",
                "ssl_verify": "false",
            }
        },
        provider_auth_methods={"watsonx_onprem": "username_api_key"},
    )

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch(
            "api.settings.endpoints.TelemetryClient.send_event",
            new_callable=AsyncMock,
        ),
        patch(
            "api.settings.endpoints.validate_provider_setup",
            new_callable=AsyncMock,
            side_effect=Exception("stop after validation arguments are captured"),
        ) as validate,
    ):
        response = await onboarding(
            body=body,
            flows_service=MagicMock(),
            session_manager=AsyncMock(),
            document_service=MagicMock(),
            models_service=MagicMock(),
            task_service=MagicMock(),
            langflow_file_service=MagicMock(),
            knowledge_filter_service=MagicMock(),
            user=MagicMock(spec=User),
        )

    assert response.status_code == 400
    assert validate.await_args.kwargs["stored_credentials"]["ssl_verify"] == "false"


@pytest.mark.asyncio
async def test_onboarding_narrows_credentials_by_auth_method_for_a_mixed_case_key():
    """Onboarding must find `provider_auth_methods` under the normalized key.

    Regression: a raw-key lookup gave `set_credentials` no method for
    `{"WatsonX_OnPrem": ...}`, so the previous method's secrets were kept and
    reached the validation probe.
    """
    from api.settings.endpoints import onboarding
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.providers.set_credentials(
        "watsonx_onprem",
        {"api_base": "https://cpd.example.com", "username": "cpd-user", "api_key": "old"},
        auth_method="username_api_key",
    )
    body = OnboardingBody(
        llm_provider="watsonx_onprem",
        llm_model="ibm/granite-3-3-8b-instruct",
        provider_credentials={"WatsonX_OnPrem": {"zen_api_key": "zen-key"}},
        provider_auth_methods={"WatsonX_OnPrem": "zen_api_key"},
    )

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch(
            "api.settings.endpoints.TelemetryClient.send_event",
            new_callable=AsyncMock,
        ),
        patch(
            "api.settings.endpoints.validate_provider_setup",
            new_callable=AsyncMock,
            side_effect=Exception("stop after validation arguments are captured"),
        ) as validate,
    ):
        response = await onboarding(
            body=body,
            flows_service=MagicMock(),
            session_manager=AsyncMock(),
            document_service=MagicMock(),
            models_service=MagicMock(),
            task_service=MagicMock(),
            langflow_file_service=MagicMock(),
            knowledge_filter_service=MagicMock(),
            user=MagicMock(spec=User),
        )

    assert response.status_code == 400
    assert validate.await_args.kwargs["stored_credentials"] == {
        "api_base": "https://cpd.example.com",
        "zen_api_key": "zen-key",
    }


@pytest.mark.asyncio
async def test_onboarding_caps_chunk_size_for_watsonx_onprem_embeddings():
    from api.settings.endpoints import onboarding
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.knowledge.chunk_size = 1000
    body = OnboardingBody(
        embedding_provider="watsonx_onprem",
        embedding_model="ibm/slate-30m-english-rtrvr",
        provider_credentials={
            "watsonx_onprem": {
                "api_base": "https://cpd.example.com",
                "username": "cpd-user",
                "api_key": "secret",
                "ssl_verify": "false",
            }
        },
        provider_auth_methods={"watsonx_onprem": "username_api_key"},
    )

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch("api.settings.endpoints.INGEST_SAMPLE_DATA", False),
        patch(
            "api.settings.endpoints.TelemetryClient.send_event",
            new_callable=AsyncMock,
        ),
        patch(
            "api.settings.endpoints.validate_provider_setup",
            new_callable=AsyncMock,
        ),
        patch(
            "api.settings.endpoints.wait_for_langflow",
            new_callable=AsyncMock,
        ),
        patch(
            "api.settings.endpoints._update_langflow_global_variables",
            new_callable=AsyncMock,
        ),
        patch(
            "api.settings.endpoints._update_mcp_server_urls",
            new_callable=AsyncMock,
        ),
        patch(
            "api.settings.endpoints._update_langflow_model_values",
            new_callable=AsyncMock,
        ),
        patch(
            "api.settings.endpoints.config_manager.save_config_file",
            return_value=True,
        ) as save_config,
        patch(
            "api.settings.endpoints.clients.refresh_patched_client",
            new_callable=AsyncMock,
        ),
        patch(
            "api.settings.endpoints.clients.create_index_admin_opensearch_client",
            return_value=MagicMock(),
        ),
        patch("main.init_index", new_callable=AsyncMock),
    ):
        response = await onboarding(
            body=body,
            flows_service=MagicMock(),
            session_manager=AsyncMock(),
            document_service=MagicMock(),
            models_service=MagicMock(),
            task_service=MagicMock(),
            langflow_file_service=MagicMock(),
            knowledge_filter_service=MagicMock(),
            user=MagicMock(spec=User),
        )

    saved_config = save_config.call_args.args[0]
    assert saved_config.knowledge.chunk_size == 500
    assert response.chunk_size_adjusted_to == 500


async def _save_settings(body: SettingsUpdateBody) -> None:
    from api.settings.endpoints import update_settings
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.edited = True
    rbac = MagicMock()
    rbac.has_permission = AsyncMock(return_value=True)

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch("api.settings.endpoints.validate_provider_setup", new_callable=AsyncMock),
        patch("api.settings.endpoints.config_manager.save_config_file", return_value=True),
        patch("api.settings.endpoints.clients.refresh_patched_client", new_callable=AsyncMock),
        patch(
            "api.settings.endpoints._run_async_post_save_langflow_updates",
            new_callable=AsyncMock,
        ),
    ):
        response = await update_settings(
            body=body,
            session_manager=AsyncMock(),
            user=MagicMock(spec=User),
            models_service=MagicMock(),
            rbac=rbac,
        )
    assert getattr(response, "status_code", 200) == 200


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "body",
    [
        SettingsUpdateBody(llm_model="qwen2.5-1.5b-instruct"),
        SettingsUpdateBody(
            provider_credentials={
                "openai_like": {"api_base": "https://llm.example", "api_key": "k"}
            }
        ),
    ],
    ids=["model", "credentials"],
)
async def test_provider_settings_save_clears_recorded_failures(body):
    """A recorded failure describes the setup the save just replaced.

    Without this, a provider whose probe cannot clear the banner kept showing
    the old failure after the operator fixed the model, until it went stale.
    """
    from services import provider_error_log

    provider_error_log.clear()
    provider_error_log.record_failure("rhoai", "chat", "old failure")
    try:
        await _save_settings(body)
        assert provider_error_log.latest_failure("rhoai", "chat") is None
    finally:
        provider_error_log.clear()


@pytest.mark.asyncio
async def test_non_provider_settings_save_keeps_recorded_failures():
    from services import provider_error_log

    provider_error_log.clear()
    provider_error_log.record_failure("rhoai", "chat", "still failing")
    try:
        await _save_settings(SettingsUpdateBody(system_prompt="Be brief."))
        assert provider_error_log.latest_failure("rhoai", "chat") == "still failing"
    finally:
        provider_error_log.clear()


def _config_with_saved_rhoai_token():
    from config.config_manager import OpenRAGConfig

    config = OpenRAGConfig.from_dict({})
    config.edited = True
    config.providers.set_credentials(
        "rhoai",
        {
            "api_base": "https://chat.host-a:8443/v1",
            "api_key": "sha256~host-a-token",
        },
    )
    return config


@pytest.mark.asyncio
async def test_update_settings_refuses_a_new_endpoint_without_the_token_before_probing():
    """A blank secret means "keep the saved one" — but not for a new host. The
    pre-save probe would otherwise send host A's token to host B."""
    from api.settings.endpoints import update_settings

    config = _config_with_saved_rhoai_token()
    body = SettingsUpdateBody(
        provider_credentials={"rhoai": {"api_base": "https://chat.host-b:8443/v1"}}
    )
    rbac = MagicMock()
    rbac.has_permission = AsyncMock(return_value=True)

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch("api.settings.endpoints.validate_provider_setup", new_callable=AsyncMock) as validate,
        patch("api.settings.endpoints.config_manager.save_config_file") as save,
    ):
        response = await update_settings(
            body=body,
            session_manager=AsyncMock(),
            user=MagicMock(spec=User),
            models_service=MagicMock(),
            rbac=rbac,
        )

    assert response.status_code == 400
    assert "Enter ServiceAccount token again" in _error_text(response)
    validate.assert_not_awaited()
    save.assert_not_called()
    assert config.providers.stored_credentials("rhoai")["api_base"] == (
        "https://chat.host-a:8443/v1"
    )


@pytest.mark.asyncio
async def test_onboarding_refuses_a_new_endpoint_without_the_token_before_probing():
    from api.settings.endpoints import onboarding

    config = _config_with_saved_rhoai_token()
    body = OnboardingBody(
        llm_provider="rhoai",
        llm_model="granite-chat",
        provider_credentials={"rhoai": {"api_base": "https://chat.host-b:8443/v1"}},
    )

    with (
        patch("api.settings.endpoints.get_openrag_config", return_value=config),
        patch(
            "api.settings.endpoints.TelemetryClient.send_event",
            new_callable=AsyncMock,
        ),
        patch("api.settings.endpoints.validate_provider_setup", new_callable=AsyncMock) as validate,
    ):
        response = await onboarding(
            body=body,
            flows_service=MagicMock(),
            session_manager=AsyncMock(),
            document_service=MagicMock(),
            models_service=MagicMock(),
            task_service=MagicMock(),
            langflow_file_service=MagicMock(),
            knowledge_filter_service=MagicMock(),
            user=MagicMock(spec=User),
        )

    assert response.status_code == 400
    assert "Enter ServiceAccount token again" in _error_text(response)
    validate.assert_not_awaited()
    assert config.providers.stored_credentials("rhoai")["api_base"] == (
        "https://chat.host-a:8443/v1"
    )