Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

14.8 KB
Raw Blame
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0

"""Tests for content endpoints: read, abstract, overview, reindex."""

from types import SimpleNamespace
from unittest.mock import AsyncMock

import pytest

from openviking.server.identity import RequestContext, Role
from openviking.server.routers import content as content_router
from openviking.server.routers.content import (
    BatchWriteOperation,
    BatchWriteRequest,
    ReindexRequest,
    WriteContentRequest,
    batch_write,
    reindex,
)
from openviking_cli.exceptions import PermissionDeniedError
from openviking_cli.session.user_id import UserIdentifier


def test_write_content_request_accepts_processing_mode():
    request = WriteContentRequest(
        uri="viking://resources/demo.md",
        content="updated",
        processing_mode="vectors_only",
    )

    assert request.processing_mode == "vectors_only"


def test_write_content_request_defaults_processing_mode():
    request = WriteContentRequest(uri="viking://resources/demo.md", content="updated")

    assert request.processing_mode == "semantic_and_vectors"


def test_write_content_request_accepts_tags_and_tag_mode():
    request = WriteContentRequest(
        uri="viking://resources/demo.md",
        content="updated",
        tags=["Env=Prod", "team=search"],
        tag_mode="append",
    )

    assert request.tags == ["Env=Prod", "team=search"]
    assert request.tag_mode == "append"


def test_write_content_request_accepts_clear_without_tags():
    request = WriteContentRequest(
        uri="viking://resources/demo.md",
        content="updated",
        tag_mode="clear",
    )

    assert request.tags is None
    assert request.tag_mode == "clear"


def test_batch_write_request_accepts_write_parity_options():
    request = BatchWriteRequest(
        root_uri="viking://resources/demo",
        processing_mode="vectors_only",
        operations=[
            BatchWriteOperation(
                uri="viking://resources/demo/a.md",
                content="updated",
                tags=["team=search"],
                tag_mode="append",
                acl={
                    "acl_mode": "restricted",
                    "entries": [{"principal": "group:engineering", "level": "write"}],
                },
            )
        ],
    )

    assert request.processing_mode == "vectors_only"
    assert request.defer_processing is False
    assert request.operations[0].tags == ["team=search"]
    assert request.operations[0].tag_mode == "append"
    assert request.operations[0].acl.acl_mode == "restricted"


async def test_batch_write_forwards_processing_mode_and_operation_metadata(monkeypatch):
    seen = {}

    async def fake_batch_write(**kwargs):
        seen.update(kwargs)
        return {"updated": [kwargs["operations"][0]["uri"]]}

    monkeypatch.setattr(
        content_router,
        "get_service",
        lambda: SimpleNamespace(fs=SimpleNamespace(batch_write=fake_batch_write)),
    )
    ctx = RequestContext(user=UserIdentifier("account-1", "user-1"), role=Role.USER)

    await batch_write(
        BatchWriteRequest(
            root_uri="viking://resources/demo",
            processing_mode="vectors_only",
            defer_processing=True,
            operations=[
                BatchWriteOperation(
                    uri="viking://resources/demo/a.md",
                    content="updated",
                    tags=["team=search"],
                    tag_mode="append",
                    acl={"acl_mode": "restricted", "entries": []},
                )
            ],
        ),
        ctx,
    )

    assert seen["processing_mode"] == "vectors_only"
    assert seen["defer_processing"] is True
    assert seen["edit_source"] == "agent"
    operation = seen["operations"][0]
    assert operation["tags"] == ["team=search"]
    assert operation["tag_mode"] == "append"
    assert operation["acl"]["acl_mode"] == "restricted"
    assert list(operation["acl"]["entries"]) == []


async def test_write_forwards_processing_mode_to_service(monkeypatch):
    seen = {}

    async def fake_write(**kwargs):
        seen.update(kwargs)
        return {"uri": kwargs["uri"], "semantic_status": "skipped"}

    service = SimpleNamespace(fs=SimpleNamespace(write=fake_write))
    monkeypatch.setattr(content_router, "get_service", lambda: service)
    ctx = RequestContext(user=UserIdentifier("account-1", "user-1"), role=Role.USER)

    response = await content_router.write(
        WriteContentRequest(
            uri="viking://resources/demo.md",
            content="updated",
            processing_mode="vectors_only",
            edit_source="manual",
        ),
        ctx,
    )

    assert response["status"] == "ok"
    assert seen["processing_mode"] == "vectors_only"
    assert seen["edit_source"] == "manual"


async def test_write_forwards_tags_and_tag_mode_to_service(monkeypatch):
    seen = {}

    async def fake_write(**kwargs):
        seen.update(kwargs)
        return {"uri": kwargs["uri"]}

    service = SimpleNamespace(fs=SimpleNamespace(write=fake_write))
    monkeypatch.setattr(content_router, "get_service", lambda: service)
    ctx = RequestContext(user=UserIdentifier("account-1", "user-1"), role=Role.USER)

    await content_router.write(
        WriteContentRequest(
            uri="viking://resources/demo.md",
            content="updated",
            tags=["env=prod"],
            tag_mode="append",
        ),
        ctx,
    )

    assert seen["tags"] == ["env=prod"]
    assert seen["tag_mode"] == "append"


async def test_write_forwards_clear_without_tags_to_service(monkeypatch):
    seen = {}

    async def fake_write(**kwargs):
        seen.update(kwargs)
        return {"uri": kwargs["uri"]}

    service = SimpleNamespace(fs=SimpleNamespace(write=fake_write))
    monkeypatch.setattr(content_router, "get_service", lambda: service)
    ctx = RequestContext(user=UserIdentifier("account-1", "user-1"), role=Role.USER)

    await content_router.write(
        WriteContentRequest(
            uri="viking://resources/demo.md",
            content="updated",
            tag_mode="clear",
        ),
        ctx,
    )

    assert seen["tags"] is None
    assert seen["tag_mode"] == "clear"


async def test_read_content(client, service, monkeypatch):
    ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.ROOT)
    legacy_uri = "viking://resources/业务 域/章节 一.md"
    encoded_uri = "viking://resources/业务%20域/章节%20一.md"
    await service.viking_fs.write_file(legacy_uri, "legacy content", ctx=ctx)

    resp = await client.get("/api/v1/content/read", params={"uri": encoded_uri})
    assert resp.status_code == 200
    body = resp.json()
    assert body["status"] == "ok"
    assert body["result"] == "legacy content"

    await service.viking_fs.write_file(encoded_uri, "literal percent20 content", ctx=ctx)
    resp = await client.get("/api/v1/content/read", params={"uri": encoded_uri})
    assert resp.status_code == 200
    assert resp.json()["result"] == "literal percent20 content"

    resp = await client.get(
        "/api/v1/content/read",
        params={"uri": "viking://resources/业务%2520域/章节%2520一.md"},
    )
    assert resp.status_code == 404
    assert resp.json()["error"]["code"] == "NOT_FOUND"

    monkeypatch.setattr(
        service.viking_fs,
        "read_file",
        AsyncMock(side_effect=[PermissionDeniedError("denied"), "legacy content"]),
    )
    resp = await client.get("/api/v1/content/read", params={"uri": encoded_uri})
    assert resp.status_code == 403
    assert resp.json()["error"]["code"] == "PERMISSION_DENIED"


async def test_read_memory_uses_visible_projection_and_raw_bypasses_it(monkeypatch):
    ctx = RequestContext(user=UserIdentifier.the_default_user("test_user"), role=Role.USER)
    uri = "viking://user/test_user/memories/notes/private.md"
    raw = 'line one\nline two\n\n<!-- MEMORY_FIELDS\n{"secret": "do-not-leak"}\n-->'
    calls = []

    async def fake_read_visible(_uri, *, ctx, offset, limit):
        calls.append((offset, limit))
        return "visible slice"

    async def fake_read(_uri, *, ctx, offset, limit):
        lines = raw.splitlines(keepends=True)
        return "".join(lines[offset:] if limit == -1 else lines[offset : offset + limit])

    monkeypatch.setattr(
        content_router,
        "get_service",
        lambda: SimpleNamespace(fs=SimpleNamespace(read=fake_read, read_visible=fake_read_visible)),
    )

    response = await content_router.read(uri=uri, offset=4, limit=1, raw=False, _ctx=ctx)
    assert response.result == "visible slice"
    assert calls[-1] == (4, 1)

    raw_response = await content_router.read(uri=uri, offset=4, limit=1, raw=True, _ctx=ctx)
    assert raw_response.result == '{"secret": "do-not-leak"}\n'
    assert calls[-1] == (4, 1)


async def test_read_directory_uri_returns_invalid_argument(client_with_resource):
    client, uri = client_with_resource

    resp = await client.get("/api/v1/content/read", params={"uri": uri})

    assert resp.status_code == 400
    body = resp.json()
    assert body["status"] == "error"
    assert body["error"]["code"] == "INVALID_ARGUMENT"
    assert "Directory URI is not readable as a file" in body["error"]["message"]
    assert "List it first, then read a file URI." in body["error"]["message"]
    assert body["error"]["details"] == {
        "resource": uri,
        "expected": "file",
        "actual": "directory",
    }


@pytest.mark.parametrize("uri", ["viking://temp/generated", "viking://queue/tasks"])
async def test_read_internal_scope_uri_returns_invalid_uri(client, uri: str):
    resp = await client.get("/api/v1/content/read", params={"uri": uri})

    assert resp.status_code == 400
    body = resp.json()
    assert body["status"] == "error"
    assert body["error"]["code"] == "INVALID_URI"
    assert "Must be one of" in body["error"]["message"]
    assert "frozenset" not in body["error"]["message"]


async def test_abstract_content(client_with_resource, service):
    client, uri = client_with_resource
    ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.ROOT)
    await service.viking_fs.write_file(f"{uri}/.abstract.md", "---\n", ctx=ctx)

    resp = await client.get("/api/v1/content/abstract", params={"uri": uri})
    assert resp.status_code == 200
    body = resp.json()
    assert body["status"] == "ok"
    assert body["result"] == f"# {uri} [Directory abstract is not ready]"


async def test_overview_content(client_with_resource, service):
    client, uri = client_with_resource
    ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.ROOT)
    await service.viking_fs.write_file(f"{uri}/.overview.md", "---\n", ctx=ctx)

    resp = await client.get("/api/v1/content/overview", params={"uri": uri})
    assert resp.status_code == 200
    body = resp.json()
    assert body["status"] == "ok"
    assert body["result"] == f"# {uri}\n\n[Directory overview is not ready]"


async def test_ls_file_uri_returns_invalid_argument(client, service):
    ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.ROOT)
    file_uri = "viking://resources/directory-type-check/file.md"
    await service.viking_fs.mkdir("viking://resources/directory-type-check", ctx=ctx)
    await service.viking_fs.write_file(file_uri, "file content", ctx=ctx)

    resp = await client.get("/api/v1/fs/ls", params={"uri": file_uri})
    assert resp.status_code == 400
    body = resp.json()
    assert body["status"] == "error"
    assert body["error"]["code"] == "INVALID_ARGUMENT"
    assert "not a directory" in body["error"]["message"]


async def test_overview_missing_uri_returns_not_found(client):
    resp = await client.get(
        "/api/v1/content/overview",
        params={"uri": "viking://resources/does-not-exist-for-overview"},
    )
    assert resp.status_code == 404
    body = resp.json()
    assert body["status"] == "error"
    assert body["error"]["code"] == "NOT_FOUND"


async def test_reindex_missing_uri(client):
    """Test reindex without uri field returns structured INVALID_ARGUMENT."""
    resp = await client.post(
        "/api/v1/content/reindex",
        json={"mode": "vectors_only"},
    )
    assert resp.status_code == 400


async def test_reindex_endpoint_registered(client):
    """Test the reindex endpoint is registered (GET returns 405, not 404)."""
    resp = await client.get("/api/v1/content/reindex")
    assert resp.status_code == 405  # Method Not Allowed, not 404


async def test_reindex_request_validation(client):
    """Test reindex validates the request body schema."""
    # Empty body — uri is required
    resp = await client.post("/api/v1/content/reindex", json={})
    assert resp.status_code == 400

    # Invalid mode should not be accepted by the endpoint
    resp = await client.post(
        "/api/v1/content/reindex",
        json={"uri": "viking://resources/test", "mode": "not_a_mode"},
    )
    assert resp.status_code in (200, 400)


async def test_reindex_wait_parameter_schema(client):
    """Test reindex accepts wait parameter in request schema."""
    # Invalid wait type should be coerced or rejected, not crash
    resp = await client.post(
        "/api/v1/content/reindex",
        json={"uri": "viking://resources/test", "wait": "invalid"},
    )
    # Pydantic coerces or rejects — either way, not a 404/405
    assert resp.status_code != 404
    assert resp.status_code != 405


@pytest.mark.asyncio
async def test_reindex_uses_request_tenant_for_exists(monkeypatch):
    """Reindex must validate URI existence inside the caller's tenant."""
    seen = {}

    class FakeService:
        async def reindex(self, *, uri, mode, wait, ctx, dry_run=False):
            seen["uri"] = uri
            seen["mode"] = mode
            seen["wait"] = wait
            seen["ctx"] = ctx
            return {"status": "completed", "uri": uri, "mode": mode}

    ctx = RequestContext(
        user=UserIdentifier(account_id="test", user_id="alice"),
        role=Role.ADMIN,
    )
    request = ReindexRequest(
        uri="viking://resources/demo/demo-note.md",
        mode="semantic_and_vectors",
        wait=True,
    )

    monkeypatch.setattr("openviking.server.routers.content.get_service", lambda: FakeService())

    response = await reindex(body=request, ctx=ctx)

    assert response.status == "ok"
    assert seen["uri"] == "viking://resources/demo/demo-note.md"
    assert seen["mode"] == "semantic_and_vectors"
    assert seen["wait"] is True
    assert seen["ctx"] == ctx


async def test_content_rebuild_endpoint_removed(client):
    response = await client.post(
        "/api/v1/content/rebuild",
        json={"uri": "viking://resources/demo", "mode": "vectors_only"},
    )
    assert response.status_code == 404


async def test_maintenance_reindex_endpoint_removed(client):
    response = await client.post(
        "/api/v1/maintenance/reindex",
        json={"uri": "viking://resources/demo", "wait": True},
    )
    assert response.status_code == 404