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: Apache-2.0
"""Service-level tests for content write coordination."""
from types import SimpleNamespace
import pytest
from openviking.server.identity import RequestContext, Role
from openviking.session.memory.dataclass import MemoryFile
from openviking.session.memory.utils import MemoryFileUtils
from openviking.session.memory.utils.content_visibility import visible_content
from openviking.storage.acl import AclMode
from openviking.storage.content_write import ContentWriteCoordinator
from openviking.storage.errors import LockAcquisitionError, ResourceBusyError
from openviking_cli.exceptions import (
InvalidArgumentError,
NotFoundError,
PermissionDeniedError,
)
from openviking_cli.session.user_id import UserIdentifier
@pytest.mark.asyncio
async def test_write_updates_memory_file_and_parent_overview(service):
ctx = RequestContext(user=service.user, role=Role.USER)
memory_dir = f"viking://user/{ctx.user.user_space_name()}/memories/preferences"
memory_uri = f"{memory_dir}/theme.md"
await service.viking_fs.write_file(memory_uri, "Original preference", ctx=ctx)
result = await service.fs.write(
memory_uri,
content="Updated preference",
ctx=ctx,
mode="replace",
wait=True,
)
assert result["context_type"] == "memory"
assert result["semantic_status"] == "skipped"
assert result["vector_status"] == "complete"
assert result["overview_status"] == "complete"
assert result["queue_status"]["Embedding"]["processed"] >= 1
stored = await service.viking_fs.read_file(memory_uri, ctx=ctx)
assert visible_content(stored, uri=memory_uri) == "Updated preference"
assert await service.viking_fs.read_file(f"{memory_dir}/.overview.md", ctx=ctx)
with pytest.raises(NotFoundError):
await service.viking_fs.read_file(f"{memory_dir}/.abstract.md", ctx=ctx)
@pytest.mark.asyncio
async def test_write_denies_foreign_user_memory_space(service):
owner_ctx = RequestContext(user=service.user, role=Role.USER)
memory_uri = (
f"viking://user/{owner_ctx.user.user_space_name()}/memories/preferences/private-note.md"
)
await service.viking_fs.write_file(memory_uri, "Owner note", ctx=owner_ctx)
foreign_ctx = RequestContext(
user=UserIdentifier(owner_ctx.account_id, "other_user"),
role=Role.USER,
)
with pytest.raises(PermissionDeniedError):
await service.fs.write(
memory_uri,
content="Intruder update",
ctx=foreign_ctx,
)
@pytest.mark.asyncio
async def test_memory_replace_preserves_metadata(service):
ctx = RequestContext(user=service.user, role=Role.USER)
memory_uri = f"viking://user/{ctx.user.user_space_name()}/memories/preferences/theme.md"
metadata = {
"tags": ["ui", "preference"],
"created_at": "2026-04-01T10:00:00",
"updated_at": "2026-04-01T10:05:00",
"fields": {"topic": "theme"},
}
original_mf = MemoryFile(content="Original preference", extra_fields=metadata)
full_content = MemoryFileUtils.write(original_mf)
expected_mf = MemoryFileUtils.read(full_content)
await service.viking_fs.write_file(memory_uri, full_content, ctx=ctx)
await service.fs.write(
memory_uri,
content="Updated preference",
ctx=ctx,
mode="replace",
)
stored = await service.viking_fs.read_file(memory_uri, ctx=ctx)
stored_result = MemoryFileUtils.read(stored)
assert stored_result.content == "Updated preference"
assert stored_result.extra_fields == expected_mf.extra_fields
@pytest.mark.asyncio
async def test_shared_resource_creation_inherits_acl_and_preserves_plain_append(
service, sample_markdown_file, monkeypatch
):
"""Shared content inherits permissions without granting its creator extra access."""
writer = RequestContext(user=service.user, role=Role.USER, group_ids=("writers",))
admin = RequestContext(user=service.user, role=Role.ADMIN)
reader = RequestContext(
user=UserIdentifier(admin.account_id, "reader"), role=Role.USER, group_ids=("readers",)
)
outsider = RequestContext(user=UserIdentifier(admin.account_id, "outsider"), role=Role.USER)
public_uri = "viking://resources/public"
parent_uri = "viking://resources/append_plain"
uri = f"{parent_uri}/journal.md"
everyone = [{"principal": "user:*", "level": "manage"}]
# Disabled ACL does not change access, but explicit inherited ACL must survive
# writes and retain the fixed root grant when the account enables enforcement.
off_file = "viking://resources/created_while_disabled.md"
await service.fs.write(
off_file,
"before",
ctx=admin,
wait=True,
acl={"entries": [{"principal": "user:reader", "level": "read"}]},
)
await service.fs.write(off_file, "after", ctx=admin, wait=True)
# Content created with ACL disabled gains default management when enabled.
await service.fs.mkdir(public_uri, ctx=writer)
await service.resources.wait_processed()
with pytest.raises(PermissionDeniedError):
await service.fs.get_acl(public_uri, ctx=outsider)
await service.runtime_config_manager.patch_account(
writer.account_id, {"acl": {"enabled": True}}
)
assert (await service.fs.get_acl("viking://resources", ctx=outsider))[
"direct_entries"
] == everyone
off_acl = await service.fs.get_acl(off_file, ctx=outsider)
assert off_acl["direct_entries"] == [{"principal": "user:reader", "level": "read"}]
assert off_acl["inherited_entries"] == everyone
public_acl = await service.fs.get_acl(public_uri, ctx=outsider)
assert public_acl["direct_entries"] == []
assert public_acl["inherited_entries"] == everyone
with pytest.raises(InvalidArgumentError):
await service.fs.set_acl("viking://resources", [], ctx=outsider)
await service.fs.mkdir(parent_uri, ctx=writer)
await service.resources.wait_processed()
parent_acl = await service.fs.get_acl(parent_uri, ctx=outsider)
assert parent_acl["acl_mode"] == "inherit"
assert parent_acl["direct_entries"] == []
assert parent_acl["effective_entries"] == everyone
inherited_entries = [
{"principal": "group:readers", "level": "read"},
{"principal": "group:writers", "level": "write"},
]
# Any account member can establish a restricted boundary on an open node.
parent_acl = await service.fs.set_acl(
parent_uri, inherited_entries, acl_mode=AclMode.RESTRICTED, ctx=outsider
)
assert parent_acl["effective_entries"] == inherited_entries
await service.fs.write(uri, content="line1\n", ctx=writer, mode="create", wait=True)
created_acl = await service.fs.get_acl(uri, ctx=admin)
assert created_acl["direct_entries"] == []
assert created_acl["inherited_entries"] == inherited_entries
with pytest.raises(PermissionDeniedError):
await service.fs.get_acl(uri, ctx=writer)
with pytest.raises(PermissionDeniedError):
await service.fs.set_acl(uri, [], ctx=writer)
# MCP keeps full ACL access manage-only and preserves permission errors.
import openviking.server.mcp_endpoint as mcp_endpoint
from openviking.storage.acl import AclSpec
monkeypatch.setattr(mcp_endpoint, "get_service", lambda: service)
token = mcp_endpoint._mcp_ctx.set(reader)
try:
with pytest.raises(PermissionDeniedError):
await mcp_endpoint.get_acl(uri)
with pytest.raises(PermissionDeniedError):
await mcp_endpoint.set_acl(uri, AclSpec(acl_mode="inherit"))
with pytest.raises(PermissionDeniedError, match="write permission required"):
await mcp_endpoint.write(uri, "denied")
finally:
mcp_endpoint._mcp_ctx.reset(token)
token = mcp_endpoint._mcp_ctx.set(admin)
try:
await mcp_endpoint.write(
uri, "line1\n", wait=True, acl=AclSpec(acl_mode="restricted", entries=inherited_entries)
)
assert (await mcp_endpoint.get_acl(uri))["direct_entries"] == inherited_entries
await mcp_endpoint.set_acl(uri, AclSpec(acl_mode="inherit", entries=[]))
finally:
mcp_endpoint._mcp_ctx.reset(token)
imported = await service.resources.add_resource(
path=str(sample_markdown_file),
parent=parent_uri,
ctx=writer,
reason="ACL import",
wait=True,
)
# Include ancestor refreshes after the import's own task completes.
queue_status = await service.resources.wait_processed()
assert queue_status["Embedding"]["error_count"] == 0
import_root = imported["root_uri"]
children = (await service.fs.ls(import_root, ctx=writer, simple=True)).entries
for target in [import_root, *children]:
acl = await service.fs.get_acl(target, ctx=admin)
assert acl["direct_entries"] == []
assert acl["inherited_entries"] == inherited_entries
# An empty restricted ACL remains closed, including its inherit descendants.
await service.fs.set_acl(import_root, [], acl_mode=AclMode.RESTRICTED, ctx=admin)
child_acl = await service.fs.get_acl(children[0], ctx=admin)
assert child_acl["acl_mode"] == "inherit"
assert child_acl["effective_entries"] == []
for caller in (writer, reader, outsider):
with pytest.raises(PermissionDeniedError):
await service.viking_fs.read_file(children[0], ctx=caller)
removed_acl = await service.fs.delete_acl(import_root, ctx=admin)
assert removed_acl["acl_mode"] == "inherit"
assert removed_acl["direct_entries"] == []
assert removed_acl["effective_entries"] == inherited_entries
assert (await service.fs.ls(import_root, ctx=reader, simple=True)).entries == children
await service.fs.write(uri, content="line2\n", ctx=writer, mode="append", wait=True)
assert (await service.fs.get_acl(uri, ctx=admin))["direct_entries"] == []
stored = await service.viking_fs.read_file(uri, ctx=reader)
assert stored == "line1\nline2\n"
with pytest.raises(PermissionDeniedError):
await service.fs.write(uri, content="denied", ctx=reader)
with pytest.raises(PermissionDeniedError):
await service.viking_fs.read_file(uri, ctx=outsider)
await service.runtime_config_manager.patch_account(
writer.account_id, {"acl": {"enabled": False}}
)
assert await service.viking_fs.read_file(uri, ctx=outsider) == stored
await service.runtime_config_manager.patch_account(
writer.account_id, {"acl": {"enabled": True}}
)
with pytest.raises(PermissionDeniedError):
await service.viking_fs.read_file(uri, ctx=outsider)
# Resuming inheritance restores user:* manage without adding direct grants.
restored_acl = await service.fs.delete_acl(parent_uri, ctx=admin)
assert restored_acl["effective_entries"] == everyone
assert (await service.fs.get_acl(uri, ctx=outsider))["effective_entries"] == everyone
# Creation ACL shares one contract across directories, files and imports.
restricted = {"acl_mode": "restricted", "entries": inherited_entries}
explicit_dir = "viking://resources/explicit"
await service.fs.mkdir(explicit_dir, ctx=outsider, acl=restricted)
await service.resources.wait_processed()
assert (await service.fs.get_acl(explicit_dir, ctx=admin))[
"effective_entries"
] == inherited_entries
with pytest.raises(PermissionDeniedError):
await service.fs.write(f"{explicit_dir}/denied.md", "denied", ctx=writer, acl=restricted)
assert not await service.viking_fs.exists(f"{explicit_dir}/denied.md", ctx=admin)
explicit_file = f"{explicit_dir}/explicit.md"
await service.fs.write(
explicit_file, "first", ctx=admin, mode="create", wait=True, acl=restricted
)
assert (await service.fs.get_acl(explicit_file, ctx=admin))[
"direct_entries"
] == inherited_entries
assert (await service.fs.get_acl(explicit_dir, ctx=admin))[
"direct_entries"
] == inherited_entries
await service.fs.write(explicit_file, "first", ctx=admin, wait=True, acl={"entries": []})
assert (await service.fs.get_acl(explicit_file, ctx=admin))["effective_entries"] == []
explicit_import = "viking://resources/explicit_import"
await service.resources.add_resource(
path=str(sample_markdown_file), to=explicit_import, ctx=admin, wait=True, acl=restricted
)
await service.resources.wait_processed()
assert (await service.fs.get_acl(explicit_import, ctx=admin))[
"direct_entries"
] == inherited_entries
imported_children = (await service.fs.ls(explicit_import, ctx=admin, simple=True)).entries
for child in imported_children:
report = await service.fs.get_acl(child, ctx=admin)
assert report["direct_entries"] == []
assert report["effective_entries"] == inherited_entries
await service.resources.add_resource(
path=str(sample_markdown_file),
to=explicit_import,
ctx=admin,
wait=True,
acl={"entries": []},
)
await service.resources.wait_processed()
assert (await service.fs.get_acl(explicit_import, ctx=admin))["effective_entries"] == []
@pytest.mark.asyncio
async def test_memory_append_preserves_metadata(service):
ctx = RequestContext(user=service.user, role=Role.USER)
memory_uri = f"viking://user/{ctx.user.user_space_name()}/memories/preferences/theme.md"
metadata = {
"tags": ["ui", "preference"],
"created_at": "2026-04-01T10:00:00",
"updated_at": "2026-04-01T10:05:00",
"fields": {"topic": "theme"},
}
original_mf = MemoryFile(content="Original preference", extra_fields=metadata)
full_content = MemoryFileUtils.write(original_mf)
expected_mf = MemoryFileUtils.read(full_content)
await service.viking_fs.write_file(memory_uri, full_content, ctx=ctx)
await service.fs.write(
memory_uri,
content="\nUpdated preference",
ctx=ctx,
mode="append",
)
stored = await service.viking_fs.read_file(memory_uri, ctx=ctx)
stored_result = MemoryFileUtils.read(stored)
assert stored_result.content == "Original preference\nUpdated preference"
assert stored_result.extra_fields == expected_mf.extra_fields
@pytest.mark.asyncio
async def test_memory_write_adds_resource_refs_for_markdown_resource_link(service):
ctx = RequestContext(user=service.user, role=Role.USER)
memory_uri = f"viking://user/{ctx.user.user_space_name()}/memories/entities/ryoma.md"
resource_uri = "viking://resources/images/2026/06/10/yueqian_jpeg_1"
content = f"用户上传了一张[越前龙马]({resource_uri})的照片"
await service.viking_fs.write_file(memory_uri, "Original", ctx=ctx)
await service.fs.write(memory_uri, content=content, ctx=ctx, mode="replace")
stored = await service.viking_fs.read_file(memory_uri, ctx=ctx)
mf = MemoryFileUtils.read(stored, uri=memory_uri)
refs = mf.extra_fields["resource_refs"]
assert mf.content == content
assert refs[0]["resource_uri"] == resource_uri
assert refs[0]["source"] == "content.write"
assert refs[0]["match_text"] == "越前龙马"
assert mf.links == []
@pytest.mark.parametrize(
"resource_uri",
[
"viking://user/test_user/resources/images/2026/06/10/yueqian_jpeg",
"viking://user/test_user/peers/fuji/resources/images/2026/06/10/yueqian_jpeg",
],
)
@pytest.mark.asyncio
async def test_memory_write_adds_resource_refs_for_user_scoped_resource_links(
service,
resource_uri,
):
ctx = RequestContext(user=service.user, role=Role.USER)
memory_uri = f"viking://user/{ctx.user.user_space_name()}/memories/entities/ryoma.md"
content = f"用户上传了一张[越前龙马]({resource_uri})的照片"
await service.viking_fs.write_file(memory_uri, "Original", ctx=ctx)
await service.fs.write(memory_uri, content=content, ctx=ctx, mode="replace")
stored = await service.viking_fs.read_file(memory_uri, ctx=ctx)
mf = MemoryFileUtils.read(stored, uri=memory_uri)
refs = mf.extra_fields["resource_refs"]
assert mf.content == content
assert refs[0]["resource_uri"] == resource_uri
assert refs[0]["source"] == "content.write"
assert refs[0]["match_text"] == "越前龙马"
@pytest.mark.asyncio
async def test_memory_write_linkifies_bare_resource_uri_previous_sentence(service):
ctx = RequestContext(user=service.user, role=Role.USER)
memory_uri = f"viking://user/{ctx.user.user_space_name()}/memories/entities/ryoma.md"
resource_uri = "viking://resources/images/2026/06/10/yueqian_jpeg_1"
await service.viking_fs.write_file(memory_uri, "Original", ctx=ctx)
await service.fs.write(
memory_uri,
content=f"用户上传了一张越前龙马的照片 {resource_uri}",
ctx=ctx,
mode="replace",
)
stored = await service.viking_fs.read_file(memory_uri, ctx=ctx)
mf = MemoryFileUtils.read(stored, uri=memory_uri)
assert mf.content == f"[用户上传了一张越前龙马的照片]({resource_uri})"
refs = mf.extra_fields["resource_refs"]
assert refs[0]["resource_uri"] == resource_uri
assert refs[0]["source"] == "content.write"
assert refs[0]["match_text"] == "用户上传了一张越前龙马的照片"
assert mf.links == []
@pytest.mark.asyncio
async def test_memory_write_linkifies_resource_uri_marker_with_readable_anchor(service):
ctx = RequestContext(user=service.user, role=Role.USER)
memory_uri = f"viking://user/{ctx.user.user_space_name()}/memories/entities/ryoma.md"
resource_uri = "viking://resources/images/2026/06/12/yueqian_jpeg"
await service.viking_fs.write_file(memory_uri, "Original", ctx=ctx)
await service.fs.write(
memory_uri,
content=f"2026-06-12,用户保存了粉丝创作的越前龙马动漫插画资源,资源URI为{resource_uri}。",
ctx=ctx,
mode="replace",
)
stored = await service.viking_fs.read_file(memory_uri, ctx=ctx)
mf = MemoryFileUtils.read(stored, uri=memory_uri)
assert (
mf.content
== f"[2026-06-12,用户保存了粉丝创作的越前龙马动漫插画资源,资源URI为]({resource_uri})。"
)
refs = mf.extra_fields["resource_refs"]
assert refs[0]["resource_uri"] == resource_uri
assert refs[0]["source"] == "content.write"
assert (
refs[0]["match_text"] == "2026-06-12,用户保存了粉丝创作的越前龙马动漫插画资源,资源URI为"
)
assert mf.links == []
@pytest.mark.asyncio
async def test_memory_write_ignores_resource_uri_in_inline_code(service):
ctx = RequestContext(user=service.user, role=Role.USER)
memory_uri = f"viking://user/{ctx.user.user_space_name()}/memories/entities/ryoma.md"
resource_uri = "viking://resources/images/2026/06/10/yueqian_jpeg_1"
content = f"调试示例:`{resource_uri}`"
await service.viking_fs.write_file(memory_uri, "Original", ctx=ctx)
await service.fs.write(memory_uri, content=content, ctx=ctx, mode="replace")
stored = await service.viking_fs.read_file(memory_uri, ctx=ctx)
mf = MemoryFileUtils.read(stored, uri=memory_uri)
assert mf.content == content
assert "resource_refs" not in mf.extra_fields
assert mf.links == []
@pytest.mark.asyncio
async def test_memory_create_refreshes_nested_schema_overview(service):
ctx = RequestContext(user=service.user, role=Role.USER)
memory_type_dir = f"viking://user/{ctx.user.user_space_name()}/memories/entities"
memory_dir = f"viking://user/{ctx.user.user_space_name()}/memories/entities/动漫角色"
memory_uri = f"{memory_dir}/不二周助-link-test.md"
# Reproduce writes after the memory type root already exists. Previously this
# collapsed the refresh root to memories/entities and skipped the category overview.
await service.viking_fs.mkdir(memory_type_dir, exist_ok=True, ctx=ctx)
result = await service.fs.write(
memory_uri,
content=MemoryFileUtils.write(
MemoryFile(
uri=memory_uri,
memory_type="entities",
content=(
"用户保存了一张[不二周助]"
"(viking://resources/images/2026/06/10/不二周助_jpeg)的照片"
),
extra_fields={"category": "动漫角色", "name": "不二周助-link-test"},
)
),
ctx=ctx,
mode="create",
wait=True,
)
overview = await service.viking_fs.read_file(f"{memory_dir}/.overview.md", ctx=ctx)
assert result["root_uri"] == memory_dir
assert "(./不二周助-link-test.md)" in overview
@pytest.mark.asyncio
async def test_memory_rm_refreshes_nested_schema_overview(service):
ctx = RequestContext(user=service.user, role=Role.USER)
memory_dir = f"viking://user/{ctx.user.user_space_name()}/memories/entities/动漫角色"
deleted_uri = f"{memory_dir}/不二周助-delete-test.md"
kept_uri = f"{memory_dir}/越前龙马-keep-test.md"
await service.fs.write(
deleted_uri,
content="用户保存了一张不二周助的照片",
ctx=ctx,
mode="create",
wait=True,
)
await service.fs.write(
kept_uri,
content="用户保存了一张越前龙马的照片",
ctx=ctx,
mode="create",
wait=True,
)
before = await service.viking_fs.read_file(f"{memory_dir}/.overview.md", ctx=ctx)
assert "[不二周助-delete-test.md](./不二周助-delete-test.md)" in before
await service.fs.rm(deleted_uri, ctx=ctx, wait=True)
after = await service.viking_fs.read_file(f"{memory_dir}/.overview.md", ctx=ctx)
assert "不二周助-delete-test" not in after
assert "[越前龙马-keep-test.md](./越前龙马-keep-test.md)" in after
class _FakePathLock:
"""Mock for _async_agfs pathlock operations."""
def __init__(self, *, acquire_result=True, acquire_error=None):
self._lease = SimpleNamespace(id="lock-1")
self.acquire_result = acquire_result
self.acquire_error = acquire_error
self.release_calls = []
async def pathlock_acquire_exact(self, lock_path):
del lock_path
if self.acquire_error is not None:
raise self.acquire_error
if not self.acquire_result:
raise LockAcquisitionError("lock conflict")
return self._lease
async def pathlock_release(self, lease):
self.release_calls.append(lease.id)
class _FakeVikingFS:
def __init__(self, file_uri: str, root_uri: str):
self._file_uri = file_uri
self._root_uri = root_uri
self.delete_temp_calls = []
self.write_file_calls = []
self.rm_calls = []
self.content = {file_uri: "original"}
self.vector_store = None
self.tree_entries = []
self._async_agfs = _FakePathLock()
async def stat(self, uri: str, ctx=None, skip_count=False):
del ctx
assert skip_count is True
if uri == self._file_uri or uri in self.content:
return {"isDir": False}
if uri == self._root_uri:
return {"isDir": True}
raise AssertionError(f"unexpected stat uri: {uri}")
def _uri_to_path(self, uri: str, ctx=None):
del ctx
return f"/fake/{uri.replace('://', '/').strip('/')}"
async def _ensure_access(self, uri: str, ctx, *, action):
del uri, ctx, action
async def _ensure_access_many(self, uris, ctx, *, action):
del uris, ctx, action
async def delete_temp(self, temp_uri: str, ctx=None):
del ctx
self.delete_temp_calls.append(temp_uri)
async def read_file(self, uri: str, ctx=None):
del ctx
return self.content[uri]
async def write_file(self, uri: str, content: str, ctx=None, lock_handle=None, lease_ref=None):
del ctx
self.write_file_calls.append((uri, content, lease_ref or lock_handle))
self.content[uri] = content
async def rm(self, uri: str, ctx=None, lock_handle=None, lease_ref=None):
del ctx, lock_handle, lease_ref
self.rm_calls.append(uri)
self.content.pop(uri, None)
async def tree(
self,
uri: str,
ctx=None,
output: str = "original",
show_all_hidden: bool = False,
node_limit: int = 1000,
level_limit: int = 3,
abs_limit: int = 256,
):
del ctx, output, show_all_hidden, node_limit, level_limit, abs_limit
assert uri == self._root_uri
return list(self.tree_entries)
def _get_vector_store(self):
return self.vector_store
class _FakeSemanticQueue:
def __init__(self):
self.messages = []
async def enqueue(self, msg):
self.messages.append(msg)
return "queued-id"
class _FakeQueueManager:
SEMANTIC = "semantic"
def __init__(self, queue):
self.queue = queue
def get_queue(self, name, allow_create=False):
del allow_create
assert name == self.SEMANTIC
return self.queue
@pytest.mark.asyncio
async def test_resource_write_lock_conflict_raises_resource_busy(monkeypatch):
file_uri = "viking://resources/demo/doc.md"
root_uri = "viking://resources/demo"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
viking_fs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
viking_fs._async_agfs = _FakePathLock(acquire_result=False)
coordinator = ContentWriteCoordinator(viking_fs=viking_fs)
with pytest.raises(ResourceBusyError) as exc_info:
await coordinator.write(
uri=file_uri,
content="updated",
ctx=ctx,
)
assert exc_info.value.uri == file_uri
assert viking_fs._async_agfs.release_calls == []
assert viking_fs.content[file_uri] == "original"
@pytest.mark.asyncio
async def test_memory_write_lock_conflict_raises_resource_busy(monkeypatch):
file_uri = "viking://user/default/memories/preferences/theme.md"
root_uri = "viking://user/default/memories/preferences"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
viking_fs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
viking_fs._async_agfs = _FakePathLock(acquire_result=False)
coordinator = ContentWriteCoordinator(viking_fs=viking_fs)
with pytest.raises(ResourceBusyError) as exc_info:
await coordinator.write(
uri=file_uri,
content="updated",
ctx=ctx,
)
assert exc_info.value.uri == file_uri
assert viking_fs._async_agfs.release_calls == []
assert viking_fs.content[file_uri] == "original"
@pytest.mark.asyncio
@pytest.mark.parametrize(
"file_uri",
[
"viking://resources/demo/doc.md",
"viking://user/default/memories/preferences/theme.md",
],
)
async def test_write_lock_storage_error_is_not_mapped_to_resource_busy(file_uri):
"""Preserve non-conflict acquisition failures for direct and memory writes."""
root_uri = file_uri.rsplit("/", 1)[0]
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
viking_fs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
viking_fs._async_agfs = _FakePathLock(acquire_error=RuntimeError("storage failed"))
coordinator = ContentWriteCoordinator(viking_fs=viking_fs)
with pytest.raises(RuntimeError, match="storage failed"):
await coordinator.write(
uri=file_uri,
content="updated",
ctx=ctx,
)
class _AnyDirVikingFS:
"""Stats the given file uri as a file and every other uri as a directory."""
def __init__(self, file_uri: str):
self._file_uri = file_uri
async def stat(self, uri: str, ctx=None, skip_count=False):
del ctx
assert skip_count is True
return {"isDir": uri != self._file_uri}
@pytest.mark.parametrize(
("file_uri", "parent_uri", "project_root"),
[
(
"viking://resources/dir1/sub_dir/sub_dir_1/test.md",
"viking://resources/dir1/sub_dir/sub_dir_1",
"viking://resources/dir1",
),
(
"viking://user/default/resources/dir1/sub_dir/sub_dir_1/test.md",
"viking://user/default/resources/dir1/sub_dir/sub_dir_1",
"viking://user/default/resources/dir1",
),
],
)
@pytest.mark.asyncio
async def test_resource_write_anchors_nested_file_to_direct_parent(
file_uri,
parent_uri,
project_root,
):
"""A resource content write anchors the semantic refresh at the written file's
direct parent directory (anchor_to_parent=True), so the changed file is a direct
child of the semantic-tree root: its own L2 vector and the parent's L0/L1 are generated
from a single-directory run instead of a recursive walk of the whole project subtree.
set_tags keeps the project-root collapse (the default), which the derived
``.abstract.md`` sidecar mapping relies on."""
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
coordinator = ContentWriteCoordinator(viking_fs=_AnyDirVikingFS(file_uri))
write_anchor = await coordinator._resolve_root_uri(file_uri, ctx=ctx, anchor_to_parent=True)
set_tags_anchor = await coordinator._resolve_root_uri(file_uri, ctx=ctx)
assert write_anchor == parent_uri
assert set_tags_anchor == project_root
@pytest.mark.asyncio
async def test_set_tags_updates_vector_record(monkeypatch):
file_uri = "viking://resources/demo/doc.md"
root_uri = "viking://resources/demo"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
fake_vfs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
coordinator = ContentWriteCoordinator(viking_fs=fake_vfs)
class _FakeVectorStore:
def __init__(self):
self.update_calls = []
async def update_search_tags(self, uri: str, tags, *, mode: str, levels=None, ctx=None):
del ctx
if levels is None:
self.update_calls.append((uri, list(tags), mode))
return [{"uri": uri}]
self.update_calls.append((uri, list(tags), mode, list(levels)))
return []
fake_store = _FakeVectorStore()
fake_vfs.vector_store = fake_store
result = await coordinator.set_tags(
uri=file_uri,
tags=["Env=Prod", " env=prod "],
ctx=ctx,
)
assert result["tags"] == ["env=prod"]
assert result["tags_updated"] is True
assert "semantic_status" not in result
assert "vector_status" not in result
assert "queue_status" not in result
assert fake_store.update_calls == [(file_uri, ["env=prod"], "replace")]
@pytest.mark.asyncio
async def test_set_tags_uses_store_update_api_without_fetch(monkeypatch):
file_uri = "viking://resources/demo/doc.md"
root_uri = "viking://resources/demo"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
fake_vfs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
coordinator = ContentWriteCoordinator(viking_fs=fake_vfs)
class _FakeVectorStore:
def __init__(self):
self.update_calls = []
async def fetch_by_uri(self, uri: str, ctx=None):
del uri, ctx
raise AssertionError("set_tags should not depend on fetch_by_uri")
async def update_search_tags(self, uri: str, tags, *, mode: str, levels=None, ctx=None):
del ctx
assert levels is None
self.update_calls.append((uri, list(tags), mode))
return [{"uri": uri}]
fake_store = _FakeVectorStore()
fake_vfs.vector_store = fake_store
result = await coordinator.set_tags(
uri=file_uri,
tags=["Env=Prod"],
mode="replace",
ctx=ctx,
)
assert result["success_count"] == 1
assert result["skipped_count"] == 0
assert result["failed_count"] == 0
assert result["root_uri"] == root_uri
assert fake_store.update_calls == [(file_uri, ["env=prod"], "replace")]
@pytest.mark.asyncio
async def test_set_tags_user_scope_resource_leaf_returns_parent_root_uri(monkeypatch):
file_uri = "viking://user/default/resources/demo/doc.md"
root_uri = "viking://user/default/resources/demo"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
fake_vfs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
coordinator = ContentWriteCoordinator(viking_fs=fake_vfs)
class _FakeVectorStore:
def __init__(self):
self.update_calls = []
async def update_search_tags(self, uri: str, tags, *, mode: str, levels=None, ctx=None):
del ctx
assert levels is None
self.update_calls.append((uri, list(tags), mode))
return [{"uri": uri}]
fake_store = _FakeVectorStore()
fake_vfs.vector_store = fake_store
result = await coordinator.set_tags(
uri=file_uri,
tags=["team=search"],
mode="replace",
ctx=ctx,
)
assert result["success_count"] == 1
assert result["root_uri"] == root_uri
assert result["context_type"] == "resource"
assert fake_store.update_calls == [(file_uri, ["team=search"], "replace")]
@pytest.mark.asyncio
async def test_set_tags_derived_abstract_maps_to_parent_level_zero(monkeypatch):
file_uri = "viking://resources/demo/doc.md/.abstract.md"
root_uri = "viking://resources/demo"
updated_uri = "viking://resources/demo/doc.md"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
fake_vfs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
coordinator = ContentWriteCoordinator(viking_fs=fake_vfs)
class _FakeVectorStore:
def __init__(self):
self.update_calls = []
async def update_search_tags(self, uri: str, tags, *, mode: str, levels=None, ctx=None):
del ctx
self.update_calls.append((uri, list(tags), mode, levels))
return [{"uri": uri}]
fake_store = _FakeVectorStore()
fake_vfs.vector_store = fake_store
result = await coordinator.set_tags(
uri=file_uri,
tags=["team=test"],
mode="replace",
ctx=ctx,
)
assert result["success_count"] == 1
assert result["skipped_count"] == 0
assert result["updated_uris"] == [updated_uri]
assert fake_store.update_calls == [(updated_uri, ["team=test"], "replace", [0])]
@pytest.mark.asyncio
async def test_set_tags_append_merges_existing_tags(monkeypatch):
file_uri = "viking://resources/demo/doc.md"
root_uri = "viking://resources/demo"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
fake_vfs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
coordinator = ContentWriteCoordinator(viking_fs=fake_vfs)
class _FakeVectorStore:
def __init__(self):
self.update_calls = []
async def fetch_by_uri(self, uri: str, ctx=None):
del uri, ctx
raise AssertionError("append should be handled inside store update API")
async def update_search_tags(self, uri: str, tags, *, mode: str, levels=None, ctx=None):
del ctx
assert levels is None
self.update_calls.append((uri, list(tags), mode))
return [{"uri": uri}]
fake_store = _FakeVectorStore()
fake_vfs.vector_store = fake_store
result = await coordinator.set_tags(
uri=file_uri,
tags=["Env=Prod", " team=search "],
mode="append",
ctx=ctx,
)
assert result["mode"] == "append"
assert "recursive" not in result
assert result["success_count"] == 1
assert result["skipped_count"] == 0
assert result["failed_count"] == 0
assert fake_store.update_calls == [(file_uri, ["env=prod", "team=search"], "append")]
@pytest.mark.asyncio
async def test_set_tags_clear_ignores_values_and_clears_existing_tags(monkeypatch):
file_uri = "viking://resources/demo/doc.md"
root_uri = "viking://resources/demo"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
fake_vfs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
coordinator = ContentWriteCoordinator(viking_fs=fake_vfs)
class _FakeVectorStore:
def __init__(self):
self.update_calls = []
async def update_search_tags(self, uri: str, tags, *, mode: str, levels=None, ctx=None):
del ctx
assert levels is None
self.update_calls.append((uri, list(tags), mode))
return [{"uri": uri}]
fake_store = _FakeVectorStore()
fake_vfs.vector_store = fake_store
result = await coordinator.set_tags(
uri=file_uri,
tags=["team=ignored"],
mode="clear",
ctx=ctx,
)
assert result["mode"] == "clear"
assert result["tags"] == []
assert result["tags_updated"] is True
assert fake_store.update_calls == [(file_uri, [], "replace")]
@pytest.mark.asyncio
async def test_set_tags_empty_replace_is_noop(monkeypatch):
file_uri = "viking://resources/demo/doc.md"
root_uri = "viking://resources/demo"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
fake_vfs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
coordinator = ContentWriteCoordinator(viking_fs=fake_vfs)
class _FakeVectorStore:
async def update_search_tags(self, *args, **kwargs):
raise AssertionError("replace with [] must not update stored tags")
fake_vfs.vector_store = _FakeVectorStore()
result = await coordinator.set_tags(
uri=file_uri,
tags=[],
mode="replace",
ctx=ctx,
)
assert result["mode"] == "replace"
assert result["tags"] == []
assert result["tags_updated"] is False
assert result["success_count"] == 0
assert result["skipped_count"] == 1
@pytest.mark.asyncio
async def test_set_tags_discards_non_kv_tags(monkeypatch):
file_uri = "viking://resources/demo/doc.md"
root_uri = "viking://resources/demo"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
fake_vfs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
coordinator = ContentWriteCoordinator(viking_fs=fake_vfs)
class _FakeVectorStore:
def __init__(self):
self.update_calls = []
async def update_search_tags(self, uri: str, tags, *, mode: str, levels=None, ctx=None):
del levels, ctx
self.update_calls.append((uri, list(tags), mode))
return [{"uri": uri}]
fake_store = _FakeVectorStore()
fake_vfs.vector_store = fake_store
result = await coordinator.set_tags(
uri=file_uri,
tags=["project-a", "team=search"],
ctx=ctx,
)
assert result["tags"] == ["team=search"]
assert fake_store.update_calls == [(file_uri, ["team=search"], "replace")]
@pytest.mark.asyncio
async def test_set_tags_recursive_directory_updates_descendants(monkeypatch):
root_uri = "viking://resources/demo"
file_uri = f"{root_uri}/doc.md"
abstract_uri = f"{root_uri}/.abstract.md"
overview_uri = f"{root_uri}/.overview.md"
nested_dir_uri = f"{root_uri}/nested"
nested_abstract_uri = f"{nested_dir_uri}/.abstract.md"
nested_overview_uri = f"{nested_dir_uri}/.overview.md"
nested_file_uri = f"{nested_dir_uri}/note.md"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
fake_vfs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
fake_vfs.tree_entries = [
{"uri": abstract_uri, "isDir": False},
{"uri": overview_uri, "isDir": False},
{"uri": file_uri, "isDir": False},
{"uri": nested_dir_uri, "isDir": True},
{"uri": nested_abstract_uri, "isDir": False},
{"uri": nested_overview_uri, "isDir": False},
{"uri": nested_file_uri, "isDir": False},
]
coordinator = ContentWriteCoordinator(viking_fs=fake_vfs)
class _FakeVectorStore:
def __init__(self):
self.update_calls = []
self.directory_update_calls = []
async def fetch_by_uri(self, uri: str, ctx=None):
del uri, ctx
raise AssertionError("recursive tag updates should use store update API")
async def update_search_tags(self, uri: str, tags, *, mode: str, levels=None, ctx=None):
del ctx
if levels is None:
self.update_calls.append((uri, list(tags), mode))
return [{"uri": uri}]
self.directory_update_calls.append((uri, list(tags), mode, list(levels)))
return [{"uri": uri}]
fake_store = _FakeVectorStore()
fake_vfs.vector_store = fake_store
result = await coordinator.set_tags(
uri=root_uri,
tags=["env=prod"],
mode="append",
recursive=True,
ctx=ctx,
)
assert result["mode"] == "append"
assert "recursive" not in result
assert result["success_count"] == 4
assert result["skipped_count"] == 0
assert result["failed_count"] == 0
assert set(result["updated_uris"]) == {
root_uri,
file_uri,
nested_dir_uri,
nested_file_uri,
}
assert sorted(fake_store.update_calls) == sorted(
[
(file_uri, ["env=prod"], "append"),
(nested_file_uri, ["env=prod"], "append"),
]
)
assert sorted(fake_store.directory_update_calls) == sorted(
[
(root_uri, ["env=prod"], "append", [0, 1]),
(nested_dir_uri, ["env=prod"], "append", [0, 1]),
]
)
assert nested_dir_uri in result["updated_uris"]
@pytest.mark.asyncio
async def test_set_tags_recursive_directory_all_missing_vector_records_returns_zero_counts(
monkeypatch,
):
root_uri = "viking://resources/demo"
file_uri = f"{root_uri}/doc.md"
abstract_uri = f"{root_uri}/.abstract.md"
overview_uri = f"{root_uri}/.overview.md"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
fake_vfs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
fake_vfs.tree_entries = [
{"uri": abstract_uri, "isDir": False},
{"uri": overview_uri, "isDir": False},
{"uri": file_uri, "isDir": False},
]
coordinator = ContentWriteCoordinator(viking_fs=fake_vfs)
class _FakeVectorStore:
def __init__(self):
self.update_calls = []
async def update_search_tags(self, uri: str, tags, *, mode: str, levels=None, ctx=None):
del ctx
if levels is None:
self.update_calls.append((uri, list(tags), mode))
return []
self.update_calls.append((uri, list(tags), mode, list(levels)))
return []
fake_store = _FakeVectorStore()
fake_vfs.vector_store = fake_store
result = await coordinator.set_tags(
uri=root_uri,
tags=["env=prod"],
mode="replace",
recursive=True,
ctx=ctx,
)
assert result["success_count"] == 0
assert result["skipped_count"] == 2
assert result["failed_count"] == 0
assert result["updated_uris"] == []
assert result["tags_updated"] is False
@pytest.mark.asyncio
async def test_set_tags_non_recursive_directory_all_missing_vector_records_returns_zero_counts(
monkeypatch,
):
root_uri = "viking://resources/demo"
file_uri = f"{root_uri}/doc.md"
abstract_uri = f"{root_uri}/.abstract.md"
overview_uri = f"{root_uri}/.overview.md"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
fake_vfs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
fake_vfs.content[abstract_uri] = "abstract"
fake_vfs.content[overview_uri] = "overview"
coordinator = ContentWriteCoordinator(viking_fs=fake_vfs)
class _FakeVectorStore:
def __init__(self):
self.update_calls = []
async def update_search_tags(self, uri: str, tags, *, mode: str, levels=None, ctx=None):
del ctx
if levels is None:
self.update_calls.append((uri, list(tags), mode))
return []
self.update_calls.append((uri, list(tags), mode, list(levels)))
return []
fake_store = _FakeVectorStore()
fake_vfs.vector_store = fake_store
result = await coordinator.set_tags(
uri=root_uri,
tags=["env=prod"],
mode="replace",
recursive=False,
ctx=ctx,
)
assert result["success_count"] == 0
assert result["skipped_count"] == 1
assert result["failed_count"] == 0
assert result["updated_uris"] == []
assert result["tags_updated"] is False
assert fake_store.update_calls == [(root_uri, ["env=prod"], "replace", [0, 1])]
@pytest.mark.asyncio
async def test_set_tags_single_uri_missing_vector_record_returns_zero_counts(monkeypatch):
file_uri = "viking://resources/demo/doc.md"
root_uri = "viking://resources/demo"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
fake_vfs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
coordinator = ContentWriteCoordinator(viking_fs=fake_vfs)
class _FakeVectorStore:
def __init__(self):
self.update_calls = []
async def update_search_tags(self, uri: str, tags, *, mode: str, ctx=None):
del ctx
self.update_calls.append((uri, list(tags), mode))
return []
fake_store = _FakeVectorStore()
fake_vfs.vector_store = fake_store
result = await coordinator.set_tags(
uri=file_uri,
tags=["env=prod"],
mode="replace",
ctx=ctx,
)
assert result["success_count"] == 0
assert result["skipped_count"] == 1
assert result["failed_count"] == 0
assert result["updated_uris"] == []
assert result["root_uri"] == root_uri
assert result["tags_updated"] is False
@pytest.mark.asyncio
async def test_set_tags_does_not_return_write_queue_fields(monkeypatch):
file_uri = "viking://resources/demo/doc.md"
root_uri = "viking://resources/demo"
ctx = RequestContext(user=UserIdentifier.the_default_user(), role=Role.USER)
fake_vfs = _FakeVikingFS(file_uri=file_uri, root_uri=root_uri)
coordinator = ContentWriteCoordinator(viking_fs=fake_vfs)
class _FakeVectorStore:
async def update_search_tags(self, uri: str, tags, *, mode: str, ctx=None):
del ctx
assert uri == file_uri
assert list(tags) == ["env=prod"]
assert mode == "replace"
return [{"uri": uri}]
fake_vfs.vector_store = _FakeVectorStore()
result = await coordinator.set_tags(
uri=file_uri,
tags=["env=prod"],
mode="replace",
ctx=ctx,
)
assert result["tags_updated"] is True
assert "semantic_status" not in result
assert "vector_status" not in result
assert "queue_status" not in result