Skip to content

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

Python
27.0 KB
Raw Blame
from types import SimpleNamespace

import pytest

from api.settings import langflow_sync
from config.settings import AppClients


class _Response:
    def __init__(self, status_code=200, json_data=None, text=""):
        self.status_code = status_code
        self._json_data = json_data
        self.text = text

    def json(self):
        return self._json_data


@pytest.mark.asyncio
async def test_create_langflow_global_variable_uses_requested_type():
    client = AppClients()
    calls = []

    async def langflow_request(method, endpoint, **kwargs):
        calls.append((method, endpoint, kwargs))
        return _Response(status_code=201)

    client.langflow_request = langflow_request

    await client._create_langflow_global_variable(
        "SELECTED_EMBEDDING_MODEL",
        "text-embedding-3-small",
        variable_type="Generic",
    )

    assert calls == [
        (
            "POST",
            "/api/v1/variables/",
            {
                "json": {
                    "name": "SELECTED_EMBEDDING_MODEL",
                    "value": "text-embedding-3-small",
                    "default_fields": [],
                    "type": "Generic",
                }
            },
        )
    ]


@pytest.mark.asyncio
async def test_update_langflow_global_variable_recreates_when_type_changes():
    client = AppClients()
    calls = []

    async def langflow_request(method, endpoint, **kwargs):
        calls.append((method, endpoint, kwargs))
        if method == "GET":
            return _Response(
                json_data=[
                    {
                        "id": "var-1",
                        "name": "OPENSEARCH_INDEX_NAME",
                        "value": "documents",
                        "type": "Credential",
                        "default_fields": ["OpenRAG", "Index"],
                    }
                ]
            )
        if method == "DELETE":
            return _Response(status_code=204)
        return _Response(status_code=201)

    client.langflow_request = langflow_request

    await client._update_langflow_global_variable(
        "OPENSEARCH_INDEX_NAME", "documents-v2", variable_type="Generic"
    )

    assert calls == [
        ("GET", "/api/v1/variables/", {}),
        ("DELETE", "/api/v1/variables/var-1", {}),
        (
            "POST",
            "/api/v1/variables/",
            {
                "json": {
                    "name": "OPENSEARCH_INDEX_NAME",
                    "value": "documents-v2",
                    "default_fields": [],
                    "type": "Generic",
                }
            },
        ),
    ]


@pytest.mark.asyncio
async def test_update_langflow_global_variable_patches_when_type_matches():
    client = AppClients()
    calls = []

    async def langflow_request(method, endpoint, **kwargs):
        calls.append((method, endpoint, kwargs))
        if method == "GET":
            return _Response(
                json_data=[
                    {
                        "id": "var-1",
                        "name": "OPENAI_API_KEY",
                        "value": "old",
                        "type": "Credential",
                        "default_fields": ["OpenAI", "OpenAI API Key"],
                    }
                ]
            )
        return _Response(status_code=200)

    client.langflow_request = langflow_request

    await client._update_langflow_global_variable(
        "OPENAI_API_KEY", "new-secret", variable_type="Credential"
    )

    assert calls == [
        ("GET", "/api/v1/variables/", {}),
        (
            "PATCH",
            "/api/v1/variables/var-1",
            {
                "json": {
                    "id": "var-1",
                    "name": "OPENAI_API_KEY",
                    "value": "new-secret",
                    "default_fields": [],
                    "type": "Credential",
                },
                "idempotent": True,
            },
        ),
    ]


@pytest.mark.asyncio
async def test_ensure_required_langflow_global_variables_removes_apply_to_fields(monkeypatch):
    langflow_calls = []

    async def mock_langflow_request(method, endpoint, **kwargs):
        langflow_calls.append((method, endpoint, kwargs))
        if method == "GET":
            return _Response(
                json_data=[
                    {
                        "id": "var-1",
                        "name": "OPENAI_API_KEY",
                        "value": "secret",
                        "type": "Credential",
                        "default_fields": ["OpenAI", "api_key"],
                    },
                    {
                        "id": "var-2",
                        "name": "DOCLING_SERVE_URL",
                        "value": langflow_sync.settings.get_langflow_docling_url(),
                        "type": "Generic",
                        "default_fields": [],
                    },
                ]
            )
        return _Response(status_code=200)

    monkeypatch.setattr(
        langflow_sync.clients,
        "langflow_request",
        mock_langflow_request,
        raising=True,
    )

    create_calls = []

    async def create_variable(name, value, modify=False, variable_type="Credential"):
        create_calls.append((name, value, modify, variable_type))

    monkeypatch.setattr(
        langflow_sync.clients,
        "_create_langflow_global_variable",
        create_variable,
        raising=True,
    )

    config = SimpleNamespace(
        providers=SimpleNamespace(),
        knowledge=SimpleNamespace(),
    )

    await langflow_sync.ensure_required_langflow_global_variables(config)

    # Verify PATCH call was made to remove default_fields from var-1
    patch_calls = [c for c in langflow_calls if c[0] == "PATCH"]
    assert len(patch_calls) == 1
    assert patch_calls[0] == (
        "PATCH",
        "/api/v1/variables/var-1",
        {
            "json": {
                "id": "var-1",
                "name": "OPENAI_API_KEY",
                "default_fields": [],
                "type": "Credential",
            },
            "idempotent": True,
        },
    )


@pytest.mark.asyncio
async def test_update_langflow_global_variables_marks_non_secret_provider_fields_generic(
    monkeypatch,
):
    calls = []

    async def create_variable(name, value, modify=False, variable_type="Credential"):
        calls.append((name, value, modify, variable_type))

    monkeypatch.setattr(
        langflow_sync.clients,
        "_create_langflow_global_variable",
        create_variable,
        raising=True,
    )

    config = SimpleNamespace(
        providers=SimpleNamespace(
            watsonx=SimpleNamespace(
                api_key="watson-key",
                project_id="watson-project",
                endpoint="https://watson.example",
            ),
            openai=SimpleNamespace(api_key="openai-key"),
            anthropic=SimpleNamespace(api_key="anthropic-key"),
            ollama=SimpleNamespace(endpoint="http://ollama.local"),
        ),
        knowledge=SimpleNamespace(
            embedding_model="embedding-model",
            embedding_provider=None,
        ),
        agent=SimpleNamespace(
            llm_model=None,
            llm_provider=None,
        ),
    )

    async def resolve_ollama_url(endpoint, force_refresh=False):
        return endpoint

    flows_service = SimpleNamespace(resolve_ollama_url=resolve_ollama_url)

    await langflow_sync._update_langflow_global_variables(config, flows_service=flows_service)

    names = {name for name, *_ in calls}
    assert ("OPENRAG_LLM_TOKEN", "None", True, "Credential") in calls
    assert "ANTHROPIC_API_KEY" not in names
    assert "WATSONX_APIKEY" not in names
    assert ("SELECTED_EMBEDDING_MODEL", "embedding-model", True, "Generic") in calls
    assert ("SELECTED_EMBEDDING_PROVIDER", "openai", True, "Generic") in calls
    assert ("SELECTED_EMBEDDING_MODEL_PROVIDER", "OpenAI", True, "Generic") in calls
    assert ("SELECTED_LANGUAGE_MODEL_PROVIDER", "OpenAI", True, "Generic") in calls
    assert any(name == "OPENRAG_LLM_BASE_URL" for name, *_ in calls)


@pytest.mark.asyncio
async def test_ensure_required_langflow_global_variables_creates_generics_and_credential_placeholders(
    monkeypatch,
):
    calls = []

    async def mock_langflow_request(method, endpoint, **kwargs):
        if method == "GET":
            return _Response(status_code=200, json_data=[])
        return _Response(status_code=200)

    monkeypatch.setattr(
        langflow_sync.clients,
        "langflow_request",
        mock_langflow_request,
        raising=True,
    )

    async def create_variable(name, value, modify=False, variable_type="Credential"):
        calls.append((name, value, modify, variable_type))

    monkeypatch.setattr(
        langflow_sync.clients,
        "_create_langflow_global_variable",
        create_variable,
        raising=True,
    )

    config = SimpleNamespace(
        providers=SimpleNamespace(
            watsonx=SimpleNamespace(project_id="project", endpoint="https://watson.example"),
            ollama=SimpleNamespace(endpoint="http://ollama.local"),
        ),
        knowledge=SimpleNamespace(
            embedding_model="text-embedding-3-large",
            index_name="documents-v2",
        ),
    )

    await langflow_sync.ensure_required_langflow_global_variables(config)

    names = {name for name, *_ in calls}
    assert langflow_sync.LANGFLOW_GENERIC_GLOBAL_VARIABLES <= names
    assert langflow_sync.LANGFLOW_RUNTIME_CREDENTIAL_PLACEHOLDERS <= names
    generic_calls = [c for c in calls if c[3] == "Generic"]
    credential_calls = [c for c in calls if c[3] == "Credential"]
    assert generic_calls
    assert all(variable_type == "Generic" for *_, variable_type in generic_calls)
    assert ("OPENSEARCH_INDEX_NAME", "documents-v2", True, "Generic") in calls
    assert ("SELECTED_EMBEDDING_MODEL", "text-embedding-3-large", True, "Generic") in calls
    assert ("OPENRAG_LLM_TOKEN", "None", True, "Credential") in credential_calls


@pytest.mark.asyncio
async def test_update_langflow_global_variable_overwrites_redacted_credential():
    """Langflow GET hides Credential values as null; still PATCH a placeholder."""
    client = AppClients()
    calls = []

    async def langflow_request(method, endpoint, **kwargs):
        calls.append((method, endpoint, kwargs))
        if method == "GET":
            return _Response(
                json_data=[
                    {
                        "id": "var-token",
                        "name": "OPENRAG_LLM_TOKEN",
                        "value": None,
                        "type": "Credential",
                        "default_fields": [],
                    }
                ]
            )
        return _Response(status_code=200)

    client.langflow_request = langflow_request

    await client._update_langflow_global_variable(
        "OPENRAG_LLM_TOKEN", "None", variable_type="Credential"
    )

    assert calls == [
        ("GET", "/api/v1/variables/", {}),
        (
            "PATCH",
            "/api/v1/variables/var-token",
            {
                "json": {
                    "id": "var-token",
                    "name": "OPENRAG_LLM_TOKEN",
                    "value": "None",
                    "default_fields": [],
                    "type": "Credential",
                },
                "idempotent": True,
            },
        ),
    ]


@pytest.mark.asyncio
async def test_ensure_required_langflow_global_variables_get_500_sends_no_post_requests(
    monkeypatch,
):
    langflow_calls = []

    async def mock_langflow_request(method, endpoint, **kwargs):
        langflow_calls.append((method, endpoint, kwargs))
        if method == "GET":
            return _Response(status_code=500, text="Internal Server Error")
        return _Response(status_code=200)

    monkeypatch.setattr(
        langflow_sync.clients,
        "langflow_request",
        mock_langflow_request,
        raising=True,
    )

    create_calls = []

    async def create_variable(name, value, modify=False, variable_type="Credential"):
        create_calls.append((name, value, modify, variable_type))

    monkeypatch.setattr(
        langflow_sync.clients,
        "_create_langflow_global_variable",
        create_variable,
        raising=True,
    )

    config = SimpleNamespace(
        providers=SimpleNamespace(),
        knowledge=SimpleNamespace(),
    )

    await langflow_sync.ensure_required_langflow_global_variables(config)

    assert len(create_calls) == 0
    assert len(langflow_calls) == 1
    assert langflow_calls[0][0] == "GET"


@pytest.mark.asyncio
async def test_ensure_required_langflow_global_variables_handles_failed_delete_post_patch(
    monkeypatch,
):
    langflow_calls = []

    async def mock_langflow_request(method, endpoint, **kwargs):
        langflow_calls.append((method, endpoint, kwargs))
        if method == "GET":
            return _Response(
                json_data=[
                    {
                        "id": "var-del-fail",
                        "name": "OPENSEARCH_INDEX_NAME",
                        "value": "documents",
                        "type": "Credential",
                    },
                    {
                        "id": "var-post-fail",
                        "name": "WATSONX_URL",
                        "value": "https://watson.example",
                        "type": "Credential",
                    },
                    {
                        "id": "var-patch-fail",
                        "name": "OPENAI_API_KEY",
                        "value": "secret",
                        "type": "Credential",
                        "default_fields": ["OpenAI", "api_key"],
                    },
                ]
            )
        if method == "DELETE" and "var-del-fail" in endpoint:
            return _Response(status_code=500)
        if method == "DELETE" and "var-post-fail" in endpoint:
            return _Response(status_code=204)
        if method == "POST" and endpoint == "/api/v1/variables/":
            return _Response(status_code=500)
        if method == "PATCH" and "var-patch-fail" in endpoint:
            return _Response(status_code=500)
        return _Response(status_code=200)

    monkeypatch.setattr(
        langflow_sync.clients,
        "langflow_request",
        mock_langflow_request,
        raising=True,
    )

    config = SimpleNamespace(
        providers=SimpleNamespace(),
        knowledge=SimpleNamespace(),
    )

    # Should complete without raising exception even though individual DELETE, POST, PATCH failed
    await langflow_sync.ensure_required_langflow_global_variables(config)

    methods = [c[0] for c in langflow_calls]
    assert "DELETE" in methods
    assert "POST" in methods
    assert "PATCH" in methods


@pytest.mark.asyncio
async def test_update_langflow_global_variables_continues_when_one_fails(monkeypatch):
    """One failing upsert must not abort the rest; errors are aggregated (PR #2267)."""
    calls = []
    attempted_names = []

    async def create_variable(name, value, modify=False, variable_type="Credential"):
        attempted_names.append(name)
        if name == "OPENRAG_LLM_BASE_URL":
            raise RuntimeError("Simulated network failure on OPENRAG_LLM_BASE_URL")
        calls.append((name, value, modify, variable_type))

    monkeypatch.setattr(
        langflow_sync.clients,
        "_create_langflow_global_variable",
        create_variable,
        raising=True,
    )

    config = SimpleNamespace(
        knowledge=SimpleNamespace(embedding_model="embedding-model"),
        agent=SimpleNamespace(llm_model="llm-model"),
    )

    with pytest.raises(RuntimeError) as exc_info:
        await langflow_sync._update_langflow_global_variables(config)

    assert "OPENRAG_LLM_BASE_URL" in str(exc_info.value)
    assert "OPENRAG_LLM_BASE_URL" in attempted_names

    names = {name for name, *_ in calls}
    assert "OPENRAG_LLM_BASE_URL" not in names
    assert "SELECTED_EMBEDDING_MODEL" in names
    assert "SELECTED_LANGUAGE_MODEL" in names
    assert langflow_sync.LANGFLOW_RUNTIME_CREDENTIAL_PLACEHOLDERS <= names


@pytest.mark.asyncio
async def test_model_change_pushes_selected_model_globals(monkeypatch):
    """A model-only settings change must reach Langflow.

    The flows use one OpenAI-compatible component per kind, so
    `change_langflow_model_value` finds no per-provider node to patch and the
    SELECTED_*_MODEL global variables are the only channel left. Those globals
    used to be written solely when provider credentials changed, which left the
    retrieval flow embedding with — and labelling chunks as — the previous
    model until some unrelated credential edit happened to resync it.
    """
    upserts: list[tuple[str, str]] = []

    async def fake_upsert(name, value, **kwargs):
        upserts.append((name, value))

    monkeypatch.setattr(langflow_sync, "_upsert_langflow_global_variable", fake_upsert)

    class _FlowsService:
        def __init__(self):
            self.calls = []

        async def change_langflow_model_value(self, provider, **kwargs):
            self.calls.append((provider, kwargs))
            return {"updated": []}

    config = SimpleNamespace(
        agent=SimpleNamespace(llm_model="gpt-4o-mini", llm_provider="openai"),
        knowledge=SimpleNamespace(
            embedding_model="ibm/slate-125m-english-rtrvr-v2",
            embedding_provider="watsonx",
        ),
    )

    await langflow_sync._update_langflow_model_values(
        config,
        _FlowsService(),
        embedding_model="ibm/slate-125m-english-rtrvr-v2",
        embedding_provider="watsonx",
    )

    assert ("SELECTED_EMBEDDING_MODEL", "ibm/slate-125m-english-rtrvr-v2") in upserts
    assert ("SELECTED_EMBEDDING_PROVIDER", "watsonx") in upserts
    assert not any(name == "SELECTED_LANGUAGE_MODEL" for name, _ in upserts)


@pytest.mark.asyncio
async def test_llm_model_change_pushes_selected_language_model(monkeypatch):
    upserts: list[tuple[str, str]] = []

    async def fake_upsert(name, value, **kwargs):
        upserts.append((name, value))

    monkeypatch.setattr(langflow_sync, "_upsert_langflow_global_variable", fake_upsert)

    class _FlowsService:
        async def change_langflow_model_value(self, provider, **kwargs):
            return {"updated": []}

    config = SimpleNamespace(
        agent=SimpleNamespace(llm_model="ibm/granite-4-h-small", llm_provider="watsonx"),
        knowledge=SimpleNamespace(embedding_model="", embedding_provider="watsonx"),
    )

    await langflow_sync._update_langflow_model_values(
        config,
        _FlowsService(),
        llm_model="ibm/granite-4-h-small",
        llm_provider="watsonx",
    )

    assert ("SELECTED_LANGUAGE_MODEL", "ibm/granite-4-h-small") in upserts


@pytest.mark.asyncio
async def test_selected_model_upsert_failure_stops_flow_update(monkeypatch):
    async def boom(name, value, **kwargs):
        raise RuntimeError("langflow down")

    monkeypatch.setattr(langflow_sync, "_upsert_langflow_global_variable", boom)

    calls = []

    class _FlowsService:
        async def change_langflow_model_value(self, provider, **kwargs):
            calls.append(provider)
            return {"updated": []}

    config = SimpleNamespace(
        agent=SimpleNamespace(llm_model="gpt-4o-mini", llm_provider="openai"),
        knowledge=SimpleNamespace(
            embedding_model="text-embedding-3-small", embedding_provider="openai"
        ),
    )

    with pytest.raises(RuntimeError, match="langflow down"):
        await langflow_sync._update_langflow_model_values(
            config,
            _FlowsService(),
            embedding_model="text-embedding-3-small",
            embedding_provider="openai",
        )

    assert calls == []


@pytest.mark.asyncio
async def test_embedding_model_update_defaults_unset_provider_to_openai(monkeypatch):
    upserts: list[tuple[str, str]] = []

    async def fake_upsert(name, value, **kwargs):
        upserts.append((name, value))

    monkeypatch.setattr(langflow_sync, "_upsert_langflow_global_variable", fake_upsert)

    class _FlowsService:
        def __init__(self):
            self.calls = []

        async def change_langflow_model_value(self, provider, **kwargs):
            self.calls.append((provider, kwargs))
            return {"updated": []}

    flows_service = _FlowsService()
    config = SimpleNamespace(
        agent=SimpleNamespace(llm_model="gpt-4o-mini", llm_provider="openai"),
        knowledge=SimpleNamespace(
            embedding_model="text-embedding-3-small", embedding_provider=None
        ),
    )

    await langflow_sync._update_langflow_model_values(
        config,
        flows_service,
        embedding_model="text-embedding-3-small",
    )

    assert ("SELECTED_EMBEDDING_PROVIDER", "openai") in upserts
    assert flows_service.calls == [
        ("openai", {"embedding_model": "text-embedding-3-small", "force_embedding_update": True})
    ]


# --- guards carried over from main (#2265) -------------------------------
# Those tests exercised OLLAMA_BASE_URL / WATSONX_URL / WATSONX_PROJECT_ID.
# This branch stops publishing vendor endpoints to Langflow entirely - the
# /v1 proxy holds the credentials - so those names are no longer in
# LANGFLOW_GENERIC_GLOBAL_VARIABLES and the originals would have passed
# vacuously. They are retargeted at OPENRAG_LLM_BASE_URL, which is generic
# and can still resolve to "" when the proxy URL is not derivable.


def _patch_llm_base_url(monkeypatch, value: str) -> None:
    monkeypatch.setattr(
        langflow_sync.settings, "get_langflow_llm_base_url", lambda: value, raising=True
    )


def _stub_langflow(monkeypatch, existing=None, calls=None):
    async def mock_langflow_request(method, endpoint, **kwargs):
        if calls is not None:
            calls.append((method, endpoint, kwargs))
        if method == "GET":
            return _Response(json_data=existing or [])
        if method == "DELETE":
            return _Response(status_code=204)
        return _Response(status_code=201)

    monkeypatch.setattr(
        langflow_sync.clients, "langflow_request", mock_langflow_request, raising=True
    )


@pytest.mark.asyncio
async def test_ensure_required_globals_skips_creating_empty_valued_variables(monkeypatch):
    """Langflow answers 400 "Variable value cannot be empty" for a blank value.

    Creating one anyway logs a "Failed to create Langflow global variable"
    warning on every boot.
    """
    _stub_langflow(monkeypatch)
    _patch_llm_base_url(monkeypatch, "")

    create_calls = []

    async def create_variable(name, value, modify=False, variable_type="Credential"):
        create_calls.append((name, value, modify, variable_type))

    monkeypatch.setattr(
        langflow_sync.clients, "_create_langflow_global_variable", create_variable, raising=True
    )

    config = SimpleNamespace(providers=SimpleNamespace(), knowledge=SimpleNamespace())
    await langflow_sync.ensure_required_langflow_global_variables(config)

    created = {name for name, *_ in create_calls}
    assert "OPENRAG_LLM_BASE_URL" not in created
    # Variables that do have a value are still created.
    assert "OPENSEARCH_INDEX_NAME" in created
    assert all(value for _, value, *_ in create_calls)


@pytest.mark.asyncio
async def test_ensure_required_globals_creates_the_variable_once_it_has_a_value(monkeypatch):
    _stub_langflow(monkeypatch)
    _patch_llm_base_url(monkeypatch, "http://openrag-backend:8000/v1")

    create_calls = []

    async def create_variable(name, value, modify=False, variable_type="Credential"):
        create_calls.append((name, value, modify, variable_type))

    monkeypatch.setattr(
        langflow_sync.clients, "_create_langflow_global_variable", create_variable, raising=True
    )

    config = SimpleNamespace(providers=SimpleNamespace(), knowledge=SimpleNamespace())
    await langflow_sync.ensure_required_langflow_global_variables(config)

    assert (
        "OPENRAG_LLM_BASE_URL",
        "http://openrag-backend:8000/v1",
        True,
        "Generic",
    ) in create_calls


@pytest.mark.asyncio
async def test_ensure_required_globals_does_not_blank_an_existing_value(monkeypatch):
    """An empty target must never overwrite what Langflow already holds."""
    calls = []
    _stub_langflow(
        monkeypatch,
        existing=[
            {
                "id": "var-1",
                "name": "OPENRAG_LLM_BASE_URL",
                "value": "http://openrag-backend:8000/v1",
                "type": "Generic",
                "default_fields": [],
            }
        ],
        calls=calls,
    )
    _patch_llm_base_url(monkeypatch, "")

    async def create_variable(name, value, modify=False, variable_type="Credential"):
        pass

    monkeypatch.setattr(
        langflow_sync.clients, "_create_langflow_global_variable", create_variable, raising=True
    )

    config = SimpleNamespace(providers=SimpleNamespace(), knowledge=SimpleNamespace())
    await langflow_sync.ensure_required_langflow_global_variables(config)

    patched = [c for c in calls if c[0] == "PATCH" and "var-1" in c[1]]
    assert patched == []


@pytest.mark.asyncio
async def test_ensure_required_globals_defers_type_migration_when_value_is_empty(monkeypatch):
    """The DELETE lands before the recreate, so a refused POST would drop it."""
    calls = []
    _stub_langflow(
        monkeypatch,
        existing=[
            {
                "id": "var-1",
                "name": "OPENRAG_LLM_BASE_URL",
                "value": "",
                "type": "Credential",
                "default_fields": [],
            }
        ],
        calls=calls,
    )
    _patch_llm_base_url(monkeypatch, "")

    async def create_variable(name, value, modify=False, variable_type="Credential"):
        pass

    monkeypatch.setattr(
        langflow_sync.clients, "_create_langflow_global_variable", create_variable, raising=True
    )

    config = SimpleNamespace(providers=SimpleNamespace(), knowledge=SimpleNamespace())
    await langflow_sync.ensure_required_langflow_global_variables(config)

    touched = [c for c in calls if "var-1" in c[1]]
    assert touched == []


@pytest.mark.asyncio
async def test_ensure_required_globals_migration_keeps_the_value_when_target_empty(monkeypatch):
    """A Credential->Generic migration must not recreate the variable with ""."""
    calls = []
    _stub_langflow(
        monkeypatch,
        existing=[
            {
                "id": "var-1",
                "name": "OPENRAG_LLM_BASE_URL",
                "value": "http://openrag-backend:8000/v1",
                "type": "Credential",
                "default_fields": [],
            }
        ],
        calls=calls,
    )
    _patch_llm_base_url(monkeypatch, "")

    async def create_variable(name, value, modify=False, variable_type="Credential"):
        pass

    monkeypatch.setattr(
        langflow_sync.clients, "_create_langflow_global_variable", create_variable, raising=True
    )

    config = SimpleNamespace(providers=SimpleNamespace(), knowledge=SimpleNamespace())
    await langflow_sync.ensure_required_langflow_global_variables(config)

    posts = [c for c in calls if c[0] == "POST"]
    assert len(posts) == 1
    # Recreated as Generic, carrying the value Langflow already held.
    assert posts[0][2]["json"]["value"] == "http://openrag-backend:8000/v1"
    assert posts[0][2]["json"]["type"] == "Generic"