Skip to content

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

29.4 KB
Raw Blame
"""Tests for reindex admin endpoint and executor behavior."""

import json
from types import SimpleNamespace
from unittest.mock import AsyncMock

import httpx
import pytest

from openviking.server.identity import RequestContext, Role
from openviking.storage.queuefs.process_result import ProcessResult
from openviking_cli.exceptions import PermissionDeniedError
from openviking_cli.session.user_id import UserIdentifier
from tests.server.test_admin_api import ROOT_KEY
from tests.server.test_admin_api import admin_app as _admin_app_fixture
from tests.server.test_admin_api import admin_client as _admin_client_fixture
from tests.server.test_admin_api import admin_service as _admin_service_fixture

admin_service = _admin_service_fixture
admin_app = _admin_app_fixture
admin_client = _admin_client_fixture

ROOT_ACCOUNT_HEADERS = {
    "X-API-Key": ROOT_KEY,
    "X-OpenViking-Account": "default",
}


def _make_reindex_run(ctx, counters):
    from openviking.service.reindex_executor import _ReindexRunContext

    return _ReindexRunContext(ctx=ctx, counters=counters)


async def test_reindex_requires_admin_role(admin_client: httpx.AsyncClient):
    resp = await admin_client.post(
        "/api/v1/content/reindex",
        json={"uri": "viking://resources/demo", "mode": "vectors_only"},
    )
    assert resp.status_code == 401


async def test_reindex_user_can_only_target_own_user_scope(monkeypatch):
    from openviking.server.routers.content import ReindexRequest, reindex
    from openviking.service.reindex_executor import ReindexExecutor

    ctx = RequestContext(
        user=UserIdentifier(account_id="reindex_user_scope", user_id="bob"),
        role=Role.USER,
    )
    seen = {}

    class FakeService:
        async def reindex(self, *, uri, mode, wait, ctx):
            seen.update(uri=uri, mode=mode, wait=wait, ctx=ctx)
            return {"status": "completed", "uri": uri, "mode": mode}

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

    own_scope = await reindex(
        body=ReindexRequest(uri="viking://~/resources", mode="vectors_only"),
        ctx=ctx,
    )
    assert own_scope.status == "ok"
    assert seen["uri"] == "viking://user/bob/resources"
    assert seen["ctx"].role == Role.USER
    assert seen["ctx"].account_id == "reindex_user_scope"

    with pytest.raises(PermissionDeniedError):
        await reindex(
            body=ReindexRequest(uri="viking://resources/shared", mode="vectors_only"),
            ctx=ctx,
        )

    with pytest.raises(PermissionDeniedError):
        await reindex(
            body=ReindexRequest(uri="viking://user/alice/resources", mode="vectors_only"),
            ctx=ctx,
        )

    peer_ctx = RequestContext(
        user=ctx.user,
        role=Role.USER,
        actor_peer_id="peer-a",
    )
    peer_scope = await reindex(
        body=ReindexRequest(
            uri="viking://user/bob/peers/peer-a/resources",
            mode="vectors_only",
        ),
        ctx=peer_ctx,
    )
    assert peer_scope.status == "ok"
    assert seen["uri"] == "viking://user/bob/peers/peer-a/resources"

    with pytest.raises(PermissionDeniedError):
        await reindex(
            body=ReindexRequest(uri="viking://user/bob/peers/peer-b/resources"),
            ctx=peer_ctx,
        )

    # An administrator's actor-peer view is also incomplete for reconciliation.
    monkeypatch.setattr(
        "openviking.server.routers.content.get_service",
        lambda: SimpleNamespace(reindex=ReindexExecutor().execute),
    )
    admin_peer_ctx = RequestContext(user=ctx.user, role=Role.ADMIN, actor_peer_id="peer-a")
    with pytest.raises(PermissionDeniedError):
        await reindex(body=ReindexRequest(uri="viking://user/bob"), ctx=admin_peer_ctx)


async def test_reindex_rejects_unsupported_uri(admin_client: httpx.AsyncClient):
    resp = await admin_client.post(
        "/api/v1/content/reindex",
        json={"uri": "viking://unknown/demo", "mode": "vectors_only"},
        headers=ROOT_ACCOUNT_HEADERS,
    )
    assert resp.status_code == 403
    body = resp.json()
    assert body["status"] == "error"


@pytest.mark.parametrize(
    "uri",
    [
        "viking://session/test/demo",
        "viking://user/default/sessions/test/demo",
    ],
)
async def test_reindex_rejects_session_uri(admin_client: httpx.AsyncClient, uri: str):
    resp = await admin_client.post(
        "/api/v1/content/reindex",
        json={"uri": uri, "mode": "vectors_only"},
        headers=ROOT_ACCOUNT_HEADERS,
    )
    assert resp.status_code == 403
    body = resp.json()
    assert body["status"] == "error"


async def test_reindex_root_requires_explicit_account(admin_client: httpx.AsyncClient):
    resp = await admin_client.post(
        "/api/v1/content/reindex",
        json={"uri": "viking://resources/demo", "mode": "vectors_only"},
        headers={"X-API-Key": ROOT_KEY},
    )
    assert resp.status_code == 403
    body = resp.json()
    assert body["status"] == "error"


@pytest.mark.asyncio
async def test_reindex_resource_vectors_only_wait_true(tmp_path, monkeypatch):
    import asyncio

    import ragfs_python

    from openviking.server.routers.content import ReindexRequest, reindex
    from openviking.service.reindex_executor import ReindexExecutor
    from openviking.service.task_store import PersistentTaskStore
    from openviking.service.task_tracker import TaskStatus, TaskTracker
    from openviking.storage.queuefs.embedding_msg import EmbeddingMsg
    from openviking.storage.queuefs.named_queue import DequeueHandlerBase
    from openviking.storage.queuefs.queue_manager import QueueManager
    from openviking.storage.queuefs.reindex_processor import ReindexProcessor
    from openviking.storage.viking_fs import VikingFS

    agfs = ragfs_python.RAGFSBindingClient()
    agfs.mount("localfs", "/local", {"local_dir": str(tmp_path)})
    agfs.mount("queuefs", "/queue", {"backend": "memory"})
    fs = VikingFS(agfs=agfs)
    tracker = TaskTracker(PersistentTaskStore(agfs))
    monkeypatch.setattr("openviking.service.task_tracker._instance", tracker)
    manager = QueueManager(agfs)
    queue = manager.get_queue("Reindex", ReindexProcessor(fs), allow_create=True)
    child_enqueued, child_started, release_child = asyncio.Event(), asyncio.Event(), asyncio.Event()

    class EmbeddingHandler(DequeueHandlerBase):
        async def on_dequeue(self, data):
            child_started.set()
            await release_child.wait()
            return ProcessResult.success({"vector_written": True})

    embedding = manager.get_queue("Embedding", EmbeddingHandler(), allow_create=True)
    ctx = RequestContext(user=UserIdentifier("test", "alice"), role=Role.ROOT)
    owner = {"account_id": ctx.account_id, "user_id": ctx.user.user_id}
    uri = "viking://resources/demo.md"
    service = SimpleNamespace(
        viking_fs=fs,
        vikingdb_manager=SimpleNamespace(has_queue_manager=True),
        reindex=ReindexExecutor().execute,
    )
    monkeypatch.setattr("openviking.server.routers.content.get_service", lambda: service)
    monkeypatch.setattr("openviking.service.reindex_executor.get_service", lambda: service)
    monkeypatch.setattr("openviking.server.dependencies.get_service", lambda: service)
    monkeypatch.setattr("openviking.storage.queuefs.get_queue_manager", lambda: manager)

    async def rebuild(_self, *, uri, mode, run):
        assert mode == "vectors_only"
        assert run.ingest_options.search_tags == ["team=search", "env=prod"]
        assert run.ingest_options.search_tag_mode == "append"
        await embedding.enqueue(
            EmbeddingMsg(message="source", context_data={"uri": uri, "account_id": ctx.account_id})
        )
        run.counters.scanned_records = run.counters.rebuilt_records = 1
        child_enqueued.set()

    monkeypatch.setattr(ReindexExecutor, "_reindex_resource", rebuild)
    await fs.write_file(uri, "source", ctx=ctx)
    request = asyncio.create_task(
        reindex(
            body=ReindexRequest(
                uri=uri,
                mode="vectors_only",
                wait=True,
                tags=["Team=Search", "env=prod"],
                tag_mode="append",
            ),
            ctx=ctx,
        )
    )
    processing = child = None
    try:
        deadline = asyncio.get_running_loop().time() + 2
        while not (messages := await queue.snapshot()):
            if request.done():
                request.result()
            assert asyncio.get_running_loop().time() < deadline
            await asyncio.sleep(0.001)
        task_id = json.loads(messages[0]["data"])["task_id"]
        while (await tracker.get(task_id, **owner)).stage != "queued":
            assert asyncio.get_running_loop().time() < deadline
            await asyncio.sleep(0.001)
        processing = asyncio.create_task(queue.dequeue())
        await asyncio.wait_for(child_enqueued.wait(), 2)
        child = asyncio.create_task(embedding.dequeue())
        await asyncio.wait_for(child_started.wait(), 2)
        assert not request.done()
        assert (await tracker.get(task_id, **owner)).status is TaskStatus.RUNNING
        release_child.set()
        await asyncio.wait_for(asyncio.gather(processing, child), 2)
        response = await asyncio.wait_for(request, 2)
        assert response.status == "ok"
        assert response.result["status"] == "completed"
        assert response.result["object_type"] == "resource"
        assert response.result["rebuilt_records"] == 1
        assert response.result["failed_records"] == 0
        assert "task_id" not in response.result
        assert (await tracker.get(task_id, **owner)).status is TaskStatus.COMPLETED
        assert await queue.snapshot() == await embedding.snapshot() == []
    finally:
        release_child.set()
        pending = [task for task in (request, processing, child) if task is not None]
        for task in pending:
            if not task.done():
                task.cancel()
        await asyncio.gather(*pending, return_exceptions=True)
        agfs.close()


@pytest.mark.asyncio
async def test_reindex_rfv_skips_complete_file_without_enqueue_or_second_read(monkeypatch):
    from unittest.mock import AsyncMock

    from openviking.service.reindex_executor import ReindexExecutor, _ReindexCounters
    from openviking.utils.content_hash import content_md5

    uri = "viking://resources/demo.md"
    body = b"same body"

    class FakeFS:
        stat = AsyncMock(return_value={"isDir": False})
        read_file_bytes = AsyncMock(return_value=body)

    class FakeDB:
        async def get_reindex_inventory_under_uri(
            self, target, *, ctx, output_fields, recursive=True, include_direct_children=False
        ):
            assert target == uri
            assert recursive is False
            assert include_direct_children is False
            return {
                "file-l2": {
                    "id": "file-l2",
                    "uri": uri,
                    "level": 2,
                    "md5": content_md5(body),
                }
            }

    resource_processor = SimpleNamespace(_enqueue_index_actions=AsyncMock())
    service = SimpleNamespace(
        viking_fs=FakeFS(),
        vikingdb_manager=FakeDB(),
        _resource_processor=resource_processor,
    )
    monkeypatch.setattr("openviking.service.reindex_executor.get_service", lambda: service)
    ctx = RequestContext(
        user=UserIdentifier(account_id="test", user_id="alice"),
        role=Role.ROOT,
    )
    counters = _ReindexCounters()

    await ReindexExecutor()._reindex_rfv(
        uri=uri,
        mode="vectors_only",
        context_type="resource",
        recursive=False,
        run=_make_reindex_run(ctx, counters),
    )

    resource_processor._enqueue_index_actions.assert_not_awaited()
    service.viking_fs.read_file_bytes.assert_awaited_once_with(uri, ctx=ctx)
    assert counters.scanned_records == 1
    assert counters.rebuilt_records == 0


@pytest.mark.asyncio
async def test_reindex_rfv_deletes_missing_root_with_owner_context(monkeypatch):
    from openviking.service.reindex_executor import ReindexExecutor, _ReindexCounters

    root = "viking://user/bob/resources/gone"
    inventory = {
        "root-l0": {"id": "root-l0", "uri": root, "level": 0},
        "root-l1": {"id": "root-l1", "uri": root, "level": 1},
        "file-l2": {"id": "file-l2", "uri": root + "/old.md", "level": 2},
    }
    db = SimpleNamespace(strict_delete=AsyncMock(return_value=3))
    service = SimpleNamespace(viking_fs=SimpleNamespace(), vikingdb_manager=db)
    monkeypatch.setattr("openviking.service.reindex_executor.get_service", lambda: service)
    ctx = RequestContext(user=UserIdentifier("test", "admin"), role=Role.ADMIN)
    counters = _ReindexCounters()

    await ReindexExecutor()._reindex_rfv(
        uri=root,
        mode="vectors_only",
        context_type="resource",
        recursive=True,
        run=_make_reindex_run(ctx, counters),
        root_is_dir=True,
        root_exists=False,
        formal_entries=[],
        vector_inventory=inventory,
    )

    (deleted,) = db.strict_delete.await_args.args
    assert set(deleted) == set(inventory)
    assert db.strict_delete.await_args.kwargs["ctx"].user == UserIdentifier("test", "bob")
    assert counters.deleted_records == 3


@pytest.mark.asyncio
async def test_reindex_memory_semantic_request_survives_write_deduplication(monkeypatch):
    from openviking.service.reindex_executor import ReindexExecutor, _ReindexCounters
    from openviking.storage.queuefs.semantic_msg import SemanticMsg
    from openviking.storage.queuefs.semantic_queue import SemanticQueue
    from openviking.utils.ingest_options import IngestOptions
    from openviking_cli.exceptions import NotFoundError

    root = "viking://user/bob/memories/events"
    ctx = RequestContext(user=UserIdentifier("test", "bob"), role=Role.USER)
    queue_fs = SimpleNamespace(mkdir=AsyncMock(), write=AsyncMock(return_value="queued"))
    monkeypatch.setattr(
        "openviking.storage.queuefs.named_queue.AsyncAGFSClient", lambda _: queue_fs
    )
    queue = SemanticQueue(object(), "/queue", "Semantic")
    manager = SimpleNamespace(SEMANTIC="Semantic", get_queue=lambda *args, **kw: queue)
    monkeypatch.setattr("openviking.storage.queuefs.get_queue_manager", lambda: manager)
    await queue.enqueue(
        SemanticMsg(
            uri=root,
            context_type="memory",
            account_id="test",
            user_id="bob",
            peer_id="bob",
        )
    )
    fs = SimpleNamespace(
        stat=AsyncMock(return_value={"isDir": True}),
        exists=AsyncMock(return_value=True),
        tree=AsyncMock(return_value=[{"uri": root + "/live.md", "isDir": False}]),
        read_file=AsyncMock(side_effect=NotFoundError(root)),
    )
    db = SimpleNamespace(
        get_reindex_inventory_under_uri=AsyncMock(
            return_value={
                "gone": {"id": "gone", "uri": root + "/gone.md", "level": 2},
            }
        ),
        strict_delete=AsyncMock(return_value=1),
    )
    monkeypatch.setattr("openviking.service.reindex_executor.get_viking_fs", lambda: fs)
    monkeypatch.setattr(
        "openviking.service.reindex_executor.get_service",
        lambda: SimpleNamespace(vikingdb_manager=db),
    )
    counters = _ReindexCounters()
    run = _make_reindex_run(ctx, counters)
    run.ingest_options = IngestOptions.from_search_tags(["team=search"], mode="append")

    await ReindexExecutor()._reindex_memory(uri=root, mode="semantic_and_vectors", run=run)

    # Explicit reindex survives ordinary write deduplication.
    assert queue_fs.write.await_count == 2
    queued = SemanticMsg.from_dict(json.loads(queue_fs.write.await_args.args[1]))
    assert queued.uri == root and queued.recursive
    assert queued.use_hierarchical_aggregation and not queued.skip_vectorization
    assert queued.ingest_options == run.ingest_options
    assert counters.deleted_records == 1
    db.strict_delete.assert_awaited_once_with(["gone"], ctx=ctx)


@pytest.mark.asyncio
async def test_reindex_rejects_non_recursive_namespace_before_starting_work(monkeypatch):
    from openviking.service.reindex_executor import ReindexExecutor
    from openviking_cli.exceptions import InvalidArgumentError

    def unexpected_tracker():
        pytest.fail("unsupported non-recursive reindex must not start task tracking")

    monkeypatch.setattr("openviking.service.reindex_executor.get_task_tracker", unexpected_tracker)
    ctx = RequestContext(
        user=UserIdentifier(account_id="test", user_id="alice"),
        role=Role.ROOT,
    )
    with pytest.raises(InvalidArgumentError, match="recursive=false.*namespace"):
        await ReindexExecutor().execute(
            uri="viking://user/alice",
            mode="semantic_and_vectors",
            recursive=False,
            wait=True,
            ctx=ctx,
        )


@pytest.mark.asyncio
async def test_reindex_memory_cancellation_waits_for_inflight_reads(monkeypatch):
    import asyncio

    from openviking.service.reindex_executor import ReindexExecutor, _ReindexCounters

    root = "viking://user/bob/memories/events"
    files = [root + "/a.md", root + "/b.md"]
    started, cleaning = asyncio.Queue(), asyncio.Queue()
    finish = asyncio.Event()
    settled = set()

    async def read(uri, **kwargs):
        started.put_nowait(uri)
        try:
            await asyncio.Future()
        finally:
            cleaning.put_nowait(uri)
            await finish.wait()
            settled.add(uri)

    fs = SimpleNamespace()
    db = SimpleNamespace(strict_delete=AsyncMock())
    monkeypatch.setattr("openviking.service.reindex_executor.get_viking_fs", lambda: fs)
    monkeypatch.setattr(
        "openviking.service.reindex_executor.get_service",
        lambda: SimpleNamespace(vikingdb_manager=db),
    )
    executor = ReindexExecutor()
    executor._read_memory_body = read
    executor._reindex_memory_directory_chain = AsyncMock(return_value={})
    executor._upsert_context = AsyncMock()
    monkeypatch.setattr(executor, "_effective_file_vectorization_concurrency", lambda: 2)
    ctx = RequestContext(user=UserIdentifier("test", "bob"), role=Role.USER)
    operation = asyncio.create_task(
        executor._reindex_memory_vectors(
            uri=root,
            ctx=ctx,
            counters=_ReindexCounters(),
            root_is_dir=True,
            formal_entries=[{"uri": uri, "isDir": False} for uri in files],
            vector_inventory={"gone": {"uri": root + "/gone.md", "level": 2}},
        )
    )
    try:
        await asyncio.wait_for(started.get(), 1)
        await asyncio.wait_for(started.get(), 1)
        operation.cancel()
        await asyncio.wait_for(cleaning.get(), 1)
        await asyncio.wait_for(cleaning.get(), 1)
        operation.cancel()
        await asyncio.sleep(0)
        assert not operation.done()
        finish.set()
        with pytest.raises(asyncio.CancelledError):
            await asyncio.wait_for(operation, 1)
        assert settled == set(files)
        db.strict_delete.assert_not_awaited()
        executor._upsert_context.assert_not_awaited()
    finally:
        finish.set()
        if not operation.done():
            operation.cancel()
        await asyncio.gather(operation, return_exceptions=True)


@pytest.mark.asyncio
async def test_reindex_memory_l2_strips_memory_fields_from_abstract(monkeypatch):
    from openviking.service.reindex_executor import (
        ReindexExecutor,
        _ReindexCounters,
        _SourceRead,
    )

    class FakeVikingFS:
        async def exists(self, uri, ctx=None):
            return True

        async def stat(self, uri, ctx=None, skip_count=True):
            return {"isDir": False}

    seen = {}
    raw_body = (
        "User has a preference for watermelon, as mentioned in the conversation: "
        '\'我爱吃西瓜\'. <!-- MEMORY_FIELDS { "user": "user", "topic": "food_preference" } -->'
    )

    async def fake_read_memory_body(self, uri, *, ctx):
        return _SourceRead(exists=True, text=raw_body)

    async def fake_upsert_context(self, **kwargs):
        seen[kwargs["uri"]] = kwargs

    monkeypatch.setattr("openviking.service.reindex_executor.get_viking_fs", lambda: FakeVikingFS())
    monkeypatch.setattr(ReindexExecutor, "_read_memory_body", fake_read_memory_body)
    monkeypatch.setattr(ReindexExecutor, "_upsert_context", fake_upsert_context)

    service = ReindexExecutor()
    counters = _ReindexCounters()
    ctx = RequestContext(
        user=UserIdentifier(account_id="test", user_id="alice"),
        role=Role.ROOT,
    )

    await service._reindex_memory_vectors(
        uri="viking://user/default/memories/preferences/food_preference.md",
        counters=counters,
        ctx=ctx,
        vector_inventory={},
    )

    assert (
        seen["viking://user/default/memories/preferences/food_preference.md"]["abstract"]
        == "User has a preference for watermelon, as mentioned in the conversation: '我爱吃西瓜'."
    )
    assert (
        seen["viking://user/default/memories/preferences/food_preference.md"]["vector_text"]
        == raw_body
    )


@pytest.mark.asyncio
async def test_reindex_memory_vectors_preserves_live_sources_and_cleans_orphans(monkeypatch):
    from openviking.service.reindex_executor import ReindexExecutor, _ReindexCounters
    from openviking_cli.exceptions import NotFoundError

    root = "viking://user/bob/memories/preferences"
    nested = root + "/user"
    hidden, broken, literal = nested + "/.note.md", nested + "/broken.md", root + "/real#chunk_0000"
    sources = {
        root + "/.abstract.md": "root abstract",
        root + "/.overview.md": OSError("overview unavailable"),
        nested + "/.overview.md": "nested overview",
        hidden: "likes spicy food",
        broken: OSError("body unavailable"),
        literal: "real memory",
    }
    records = {
        "hidden": (hidden, 2),
        "broken": (broken, 2),
        "literal": (literal, 2),
        "root-l0": (root, 0),
        "root-l1": (root, 1),
        "missing-sidecar": (nested, 0),
        "gone-a": (root + "/gone.md", 2),
        "gone-b": (root + "/gone.md", 2),
        "legacy-chunk": (hidden + "#chunk_0000", 2),
    }
    inventory = {
        key: {"id": key, "uri": uri, "level": level} for key, (uri, level) in records.items()
    }
    stored = dict(inventory)

    async def read(uri, **kwargs):
        if uri not in sources:
            raise NotFoundError(uri)
        if isinstance(sources[uri], Exception):
            raise sources[uri]
        return sources[uri]

    async def tree(uri, *, show_all_hidden, node_limit, level_limit, **kwargs):
        assert uri == root and node_limit is None and level_limit is None
        return [{"uri": nested, "isDir": True}] + [
            {"uri": path, "isDir": False}
            for path in sources
            if show_all_hidden or not path.rsplit("/", 1)[-1].startswith(".")
        ]

    async def delete(ids, **kwargs):
        for key in ids:
            del stored[key]
        return len(ids)

    fs = SimpleNamespace(
        exists=AsyncMock(side_effect=lambda uri, **kw: uri == root or uri in sources),
        stat=AsyncMock(return_value={"isDir": True}),
        tree=tree,
        read_file=read,
    )
    db = SimpleNamespace(
        get_reindex_inventory_under_uri=AsyncMock(return_value=inventory),
        strict_delete=AsyncMock(side_effect=delete),
        enqueue_embedding_msg=AsyncMock(return_value=True),
    )
    monkeypatch.setattr("openviking.service.reindex_executor.get_viking_fs", lambda: fs)
    monkeypatch.setattr(
        "openviking.service.reindex_executor.get_service",
        lambda: SimpleNamespace(vikingdb_manager=db),
    )
    executor = ReindexExecutor()
    monkeypatch.setattr(executor, "_effective_file_vectorization_concurrency", lambda: 2)
    counters = _ReindexCounters()
    ctx = RequestContext(user=UserIdentifier("test", "admin"), role=Role.ADMIN)

    await executor._reindex_memory(
        uri=root, mode="vectors_only", run=_make_reindex_run(ctx, counters)
    )

    queued = [call.args[0].context_data for call in db.enqueue_embedding_msg.await_args_list]
    assert {(record["uri"], record["level"]) for record in queued} == {
        (root, 0),
        (nested, 1),
        (hidden, 2),
        (literal, 2),
    }
    assert all(record["owner_user_id"] == "bob" for record in queued)
    assert set(stored) == {"hidden", "broken", "literal", "root-l0", "root-l1"}
    assert counters.deleted_records == 4
    assert counters.rebuilt_records == 4
    assert counters.failed_records == 2
    assert any("overview unavailable" in warning for warning in counters.warnings)
    assert any("body unavailable" in warning for warning in counters.warnings)


@pytest.mark.asyncio
async def test_reindex_user_namespace_partitions_memory_skill_and_resource(monkeypatch):
    from openviking.service.reindex_executor import ReindexExecutor, _ReindexCounters
    from openviking_cli.exceptions import NotFoundError

    root = "viking://user/bob"
    directories = {
        root: [
            "resources",
            "skills",
            "memories",
            "peers",
            "notes",
            "sessions",
            "privacy",
            "settings",
        ],
        root + "/skills": ["live"],
        root + "/memories": [],
        root + "/peers": [],
    }
    children = {
        uri: [{"uri": uri + "/" + name, "isDir": True} for name in names]
        for uri, names in directories.items()
    }
    children[root].append({"uri": root + "/persona.md", "isDir": False})
    hidden = root + "/memories/.note.md"
    children[root + "/memories"].append({"uri": hidden, "isDir": False})
    records = {
        "skill": {"uri": root + "/skills/gone/SKILL.md", "level": 2},
        "peer": {"uri": root + "/peers/gone/memories/events/a.md", "level": 2},
    }

    async def stat(uri, **kwargs):
        if uri not in directories and uri != root + "/resources":
            raise NotFoundError(uri)
        return {"isDir": True}

    async def listing(uri, *, offset, node_limit, show_all_hidden, **kwargs):
        entries = [
            entry
            for entry in children[uri]
            if entry["isDir"]
            or show_all_hidden
            or not entry["uri"].rsplit("/", 1)[-1].startswith(".")
        ]
        return entries[offset : offset + node_limit]

    async def inventory(uri, *, recursive, **kwargs):
        return {
            key: dict(record, id=key)
            for key, record in records.items()
            if recursive and record["uri"].startswith(uri + "/")
        }

    fs = SimpleNamespace(stat=stat, ls=AsyncMock(side_effect=listing))
    db = SimpleNamespace(get_reindex_inventory_under_uri=AsyncMock(side_effect=inventory))
    monkeypatch.setattr("openviking.service.reindex_executor.get_viking_fs", lambda: fs)
    monkeypatch.setattr(
        "openviking.service.reindex_executor.get_service",
        lambda: SimpleNamespace(vikingdb_manager=db),
    )
    executor = ReindexExecutor()
    executor._reindex_rfv = AsyncMock()
    executor._reindex_memory = AsyncMock()
    ctx = RequestContext(user=UserIdentifier("test", "bob"), role=Role.USER)

    await executor._reindex_user_namespace(
        uri=root, mode="vectors_only", run=_make_reindex_run(ctx, _ReindexCounters())
    )

    scopes = {call.kwargs["uri"]: call.kwargs for call in executor._reindex_rfv.await_args_list}
    assert set(scopes) == {
        root + suffix
        for suffix in ("/resources", "/skills/live", "/skills/gone", "/notes", "/persona.md")
    }
    assert scopes[root + "/skills/gone"]["root_exists"] is False
    assert set(scopes[root + "/skills/gone"]["vector_inventory"]) == {"skill"}
    memories = {
        call.kwargs["uri"]: call.kwargs for call in executor._reindex_memory.await_args_list
    }
    assert set(memories) == {root + "/memories", root + "/peers/gone/memories"}
    assert memories[root + "/memories"]["formal_entries"] == [{"uri": hidden, "isDir": False}]
    assert memories[root + "/peers/gone/memories"]["root_exists"] is False
    assert set(memories[root + "/peers/gone/memories"]["vector_inventory"]) == {"peer"}
    assert not any(
        part in call.args[0]
        for call in fs.ls.await_args_list
        for part in ("/sessions", "/privacy", "/settings")
    )


@pytest.mark.asyncio
async def test_reindex_global_namespace_partitions_user_and_resources(monkeypatch):
    from openviking.service.reindex_executor import ReindexExecutor, _ReindexCounters

    children = {
        "viking://agent/skills": [{"uri": "viking://agent/skills/demo", "isDir": True}],
        "viking://user": [{"uri": "viking://user/bob", "isDir": True}],
    }
    fs = SimpleNamespace(
        stat=AsyncMock(return_value={"isDir": True}),
        ls=AsyncMock(side_effect=lambda uri, **kw: children[uri]),
    )
    db = SimpleNamespace(get_reindex_inventory_under_uri=AsyncMock(return_value={}))
    monkeypatch.setattr("openviking.service.reindex_executor.get_viking_fs", lambda: fs)
    monkeypatch.setattr(
        "openviking.service.reindex_executor.get_service",
        lambda: SimpleNamespace(vikingdb_manager=db),
    )
    executor = ReindexExecutor()
    executor._reindex_user_namespace = AsyncMock()
    executor._reindex_rfv = AsyncMock()
    ctx = RequestContext(user=UserIdentifier("test", "admin"), role=Role.ADMIN)

    await executor._reindex_global_namespace(
        uri="viking://", mode="vectors_only", run=_make_reindex_run(ctx, _ReindexCounters())
    )

    assert {
        (call.kwargs["uri"], call.kwargs["context_type"])
        for call in executor._reindex_rfv.await_args_list
    } == {
        ("viking://resources", "resource"),
        ("viking://agent/skills/demo", "skill"),
    }
    assert [call.kwargs["uri"] for call in executor._reindex_user_namespace.await_args_list] == [
        "viking://user/bob"
    ]