Skip to content

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

Python
4.2 KB
Raw Blame
import asyncio
import os
from typing import Any

import pytest

OPENRAG_MCP_SERVER_NAME = "lf-starter_project"
LANGFLOW_GLOBAL_VAR_PREFIX = "x-langflow-global-var-"
MCP_CREDENTIAL_MASK = "********"


async def _wait_for_langflow_client(timeout_s: float = 60.0):
    from config.settings import clients

    await clients.initialize()
    deadline = asyncio.get_event_loop().time() + timeout_s
    while asyncio.get_event_loop().time() < deadline:
        langflow_client = await clients.ensure_langflow_client()
        if langflow_client is not None:
            return langflow_client
        await asyncio.sleep(1.0)
    return None


def _server_name(server: dict[str, Any]) -> str | None:
    return server.get("name") or server.get("server") or server.get("id")


def _extract_server_urls(server_config: dict[str, Any]) -> list[str]:
    urls = []
    url = server_config.get("url")
    if isinstance(url, str):
        urls.append(url)

    args = server_config.get("args", [])
    if isinstance(args, list):
        urls.extend(
            arg
            for arg in args
            if isinstance(arg, str) and (arg.startswith("http://") or arg.startswith("https://"))
        )
    return urls


def _extract_server_headers(server_config: dict[str, Any]) -> dict[str, str]:
    headers = {}

    raw_headers = server_config.get("headers")
    if isinstance(raw_headers, dict):
        headers.update(
            {str(key): str(value) for key, value in raw_headers.items() if value is not None}
        )

    args = server_config.get("args", [])
    if isinstance(args, list):
        i = 0
        while i < len(args):
            if args[i] == "--headers" and i + 2 < len(args):
                headers[str(args[i + 1])] = str(args[i + 2])
                i += 3
            else:
                i += 1

    return headers


def _assert_has_redacted_required_global_headers(headers: dict[str, str]) -> None:
    from services.langflow_mcp_service import REQUIRED_MCP_HEADERS

    for key in REQUIRED_MCP_HEADERS:
        assert headers.get(key) == MCP_CREDENTIAL_MASK, (
            f"Expected required MCP header {key} to be redacted in the Langflow response, "
            f"got {headers.get(key)!r}"
        )


@pytest.mark.asyncio
async def test_openrag_mcp_server_url_is_patched_without_persisting_request_globals():
    from config.settings import LANGFLOW_URL
    from services.langflow_mcp_service import LangflowMCPService

    langflow_client = await _wait_for_langflow_client()
    assert langflow_client is not None, (
        "Langflow client not initialized. Provide LANGFLOW_KEY or enable "
        "superuser auto-login for integration tests."
    )

    mcp_service = LangflowMCPService()
    await mcp_service.update_all_mcp_server_urls()

    servers = await mcp_service.list_mcp_servers()
    server_names = [_server_name(server) for server in servers]
    assert OPENRAG_MCP_SERVER_NAME in server_names, (
        f"Expected OpenRAG MCP server {OPENRAG_MCP_SERVER_NAME!r}; found {server_names}"
    )

    server_config = await mcp_service.get_mcp_server(OPENRAG_MCP_SERVER_NAME)
    urls = _extract_server_urls(server_config)
    assert urls, f"MCP server has no configured URL: {server_config}"

    expected_base = (LANGFLOW_URL or os.environ.get("LANGFLOW_URL", "")).rstrip("/")
    if expected_base and "localhost" not in expected_base:
        assert any(url.startswith(expected_base) for url in urls), (
            f"MCP server URLs were not rewritten to LANGFLOW_URL={expected_base!r}: {urls}"
        )

    _assert_has_redacted_required_global_headers(_extract_server_headers(server_config))


@pytest.mark.asyncio
async def test_loaded_chat_flow_includes_url_ingestion_integration():
    from config.settings import LANGFLOW_CHAT_FLOW_ID, clients

    langflow_client = await _wait_for_langflow_client()
    assert langflow_client is not None, (
        "Langflow client not initialized. Provide LANGFLOW_KEY or enable "
        "superuser auto-login for integration tests."
    )
    assert LANGFLOW_CHAT_FLOW_ID, "LANGFLOW_CHAT_FLOW_ID is required"

    response = await clients.langflow_request(
        "GET",
        f"/api/v1/flows/{LANGFLOW_CHAT_FLOW_ID}",
    )
    response.raise_for_status()

    assert "opensearch_url_ingestion_flow" in response.text