Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
# 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