Skip to content

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

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

from __future__ import annotations

import json
import logging
import threading
import time
from datetime import datetime, timedelta, timezone
from types import SimpleNamespace

import pytest

import openviking.service.session_auto_commit as auto_commit_module
import openviking.service.session_service as session_service_module
from openviking.server.identity import RequestContext
from openviking.service.session_auto_commit import (
    SessionAutoCommitScheduler,
    compute_next_check_at,
)
from openviking.service.session_service import SessionService
from openviking_cli.session.user_id import UserIdentifier
from openviking_cli.utils.config.memory_config import SessionAutoCommitConfig


_REAL_DATETIME = datetime


class _Python310LikeDateTime:
    @classmethod
    def fromisoformat(cls, value: str):
        if isinstance(value, str) and value.endswith("Z"):
            raise ValueError("Invalid isoformat string")
        return _REAL_DATETIME.fromisoformat(value)

    @classmethod
    def now(cls):
        return _REAL_DATETIME.now()

    @classmethod
    def fromtimestamp(cls, timestamp: float, tz=None):
        return _REAL_DATETIME.fromtimestamp(timestamp, tz=tz)


class _FakeVikingFS:
    def __init__(
        self,
        tree_entries: list[dict[str, str]],
        metas: dict[str, object],
        *,
        users_by_account: dict[str, list[str]] | None = None,
        tree_entries_by_user: dict[tuple[str, str], list[dict[str, str]]] | None = None,
        ls_errors: dict[str, BaseException] | None = None,
        read_delay_seconds: float = 0.0,
    ) -> None:
        self._tree_entries = tree_entries
        self._metas = metas
        self._users_by_account = users_by_account or {"acct_a": ["user_b"]}
        self._tree_entries_by_user = tree_entries_by_user or {}
        self._ls_errors = ls_errors or {}
        self._read_delay_seconds = read_delay_seconds
        self.agfs = self
        self.ls_calls: list[tuple[str, str]] = []
        self.read_calls: list[str] = []
        self.active_reads = 0
        self.max_active_reads = 0
        self._read_lock = threading.Lock()

    def ls(self, path: str, ctx=None):
        account_id = ""
        if isinstance(ctx, dict):
            account_id = str(ctx.get("account_id", ""))
        elif ctx is not None:
            account_id = str(getattr(ctx, "account_id", ""))
        self.ls_calls.append((path, account_id))
        if path in self._ls_errors:
            raise self._ls_errors[path]
        if path == "/local":
            return [{"name": account, "isDir": True} for account in self._users_by_account] + [
                {"name": "_system", "isDir": True},
            ]
        parts = [part for part in path.split("/") if part]
        if len(parts) == 3 and parts[0] == "local" and parts[2] == "user":
            return [
                {"name": user, "isDir": True} for user in self._users_by_account.get(parts[1], [])
            ]
        if (
            len(parts) == 5
            and parts[0] == "local"
            and parts[2] == "user"
            and parts[4] == "sessions"
        ):
            return list(self._tree_entries_by_user.get((parts[1], parts[3]), self._tree_entries))
        raise AssertionError(path)

    def read(self, path: str):
        with self._read_lock:
            self.read_calls.append(path)
            self.active_reads += 1
            self.max_active_reads = max(self.max_active_reads, self.active_reads)
        try:
            if self._read_delay_seconds:
                time.sleep(self._read_delay_seconds)
            value = self._metas[path]
            if isinstance(value, BaseException):
                raise value
            if isinstance(value, bytes):
                return value
            if isinstance(value, str):
                return value.encode("utf-8")
            return json.dumps(value).encode("utf-8")
        finally:
            with self._read_lock:
                self.active_reads -= 1


class _FakeSessionService:
    def __init__(
        self,
        tree_entries: list[dict[str, str]],
        metas: dict[str, object],
        *,
        users_by_account: dict[str, list[str]] | None = None,
        tree_entries_by_user: dict[tuple[str, str], list[dict[str, str]]] | None = None,
        ls_errors: dict[str, BaseException] | None = None,
        read_delay_seconds: float = 0.0,
    ) -> None:
        self.viking_fs = _FakeVikingFS(
            tree_entries,
            metas,
            users_by_account=users_by_account,
            tree_entries_by_user=tree_entries_by_user,
            ls_errors=ls_errors,
            read_delay_seconds=read_delay_seconds,
        )
        self.calls: list[tuple[str, str, str]] = []
        self.schedule_results: list[bool] = []

    async def maybe_schedule_auto_commit(
        self,
        session_id: str,
        ctx: RequestContext,
        *,
        reason_hint: str,
    ):
        self.calls.append((session_id, reason_hint, ctx.user.user_id))
        if self.schedule_results:
            return self.schedule_results.pop(0)
        return True


class _FakeSessionMeta:
    def __init__(
        self,
        *,
        auto_commit_policy: dict | None,
        pending_tokens: int = 0,
        message_count: int = 0,
        keep_recent_count: int = 0,
        last_message_at: str = "",
        last_auto_commit_at: str = "",
    ) -> None:
        self.auto_commit_policy = auto_commit_policy
        self.pending_tokens = pending_tokens
        self.message_count = message_count
        self.keep_recent_count = keep_recent_count
        self.last_message_at = last_message_at
        self.last_auto_commit_at = last_auto_commit_at

    def to_dict(self) -> dict:
        return {
            "auto_commit_policy": self.auto_commit_policy,
            "pending_tokens": self.pending_tokens,
            "message_count": self.message_count,
            "keep_recent_count": self.keep_recent_count,
            "last_message_at": self.last_message_at,
            "last_auto_commit_at": self.last_auto_commit_at,
        }


class _FakeAutoCommitSession:
    def __init__(self, meta: _FakeSessionMeta) -> None:
        self.meta = meta
        self.commit_calls: list[tuple[int, bool, bool]] = []
        self.save_calls = 0

    async def commit_async(
        self,
        *,
        keep_recent_count: int = 0,
        persist_keep_recent_count: bool = True,
        record_auto_commit_success: bool = False,
    ):
        self.commit_calls.append(
            (keep_recent_count, persist_keep_recent_count, record_auto_commit_success)
        )
        return {"archived": True}

    async def _save_meta(self):
        self.save_calls += 1


class _FakeTaskTracker:
    async def has_running(self, *args, **kwargs) -> bool:
        return False


def _auto_commit_ctx() -> RequestContext:
    return RequestContext(
        user=UserIdentifier(account_id="acct_a", user_id="user_b"),
        role="user",
    )


def _session_service_for_auto_commit_test(
    monkeypatch: pytest.MonkeyPatch,
    session: _FakeAutoCommitSession,
) -> SessionService:
    service = SessionService()
    service.set_session_auto_commit_config(
        SessionAutoCommitConfig(enabled=True, check_interval_seconds=60.0)
    )

    async def fake_get(session_id, ctx, auto_create=False):
        return session

    monkeypatch.setattr(service, "get", fake_get)
    monkeypatch.setattr(session_service_module, "get_task_tracker", lambda: _FakeTaskTracker())
    return service


def _meta(
    *,
    account_id: str = "acct_a",
    user_id: str = "user_b",
    idle_timeout_seconds: int | None = 60,
    pending_tokens: int = 1,
    message_count: int = 1,
    keep_recent_count: int = 0,
    last_message_at: str | None = None,
) -> dict:
    if last_message_at is None:
        last_message_at = (datetime.now(timezone.utc) - timedelta(minutes=5)).isoformat()
    policy: dict = {"keep_recent_count": keep_recent_count}
    if idle_timeout_seconds is not None:
        policy["idle_timeout_seconds"] = idle_timeout_seconds
    return {
        "auto_commit_policy": policy,
        "created_by_account_id": account_id,
        "created_by_user_id": user_id,
        "pending_tokens": pending_tokens,
        "message_count": message_count,
        "keep_recent_count": keep_recent_count,
        "last_message_at": last_message_at,
    }


def _session_entry(session_id: str) -> dict[str, object]:
    return {"name": session_id, "isDir": True}


def test_compute_next_check_at_parses_utc_z_timestamps_on_python310(monkeypatch):
    monkeypatch.setattr(auto_commit_module, "datetime", _Python310LikeDateTime)

    assert (
        compute_next_check_at("2026-06-20T10:00:00.000Z", 60)
        == "2026-06-20T10:01:00+00:00"
    )


@pytest.mark.asyncio
async def test_run_auto_commit_skips_when_below_token_threshold(monkeypatch):
    session = _FakeAutoCommitSession(
        _FakeSessionMeta(
            auto_commit_policy={
                "pending_token_threshold": 100,
                "message_count_threshold": 50,
                "keep_recent_count": 0,
                "min_commit_interval_seconds": 0,
            },
            pending_tokens=10,
            message_count=1,
        )
    )
    service = _session_service_for_auto_commit_test(monkeypatch, session)

    await service.run_auto_commit("session_a", _auto_commit_ctx(), reason="message_write")

    assert session.commit_calls == []
    assert session.save_calls == 0


@pytest.mark.asyncio
async def test_run_auto_commit_skips_when_policy_is_disabled(monkeypatch):
    session = _FakeAutoCommitSession(
        _FakeSessionMeta(
            auto_commit_policy=None,
            pending_tokens=10_000,
            message_count=1_000,
        )
    )
    service = _session_service_for_auto_commit_test(monkeypatch, session)

    await service.run_auto_commit("session_a", _auto_commit_ctx(), reason="message_write")

    assert session.commit_calls == []
    assert session.save_calls == 0


@pytest.mark.asyncio
async def test_maybe_schedule_auto_commit_reuses_loaded_session(monkeypatch):
    session = _FakeAutoCommitSession(
        _FakeSessionMeta(
            auto_commit_policy=None,
            pending_tokens=10_000,
            message_count=1_000,
        )
    )
    service = SessionService()

    async def fail_get(*args, **kwargs):
        raise AssertionError("session should be reused instead of reloaded")

    monkeypatch.setattr(service, "get", fail_get)

    did_schedule = await service.maybe_schedule_auto_commit(
        "session_a",
        _auto_commit_ctx(),
        reason_hint="message_write",
        session=session,
    )

    assert did_schedule is False


@pytest.mark.asyncio
async def test_maybe_schedule_auto_commit_swallows_scheduling_errors(monkeypatch):
    session = _FakeAutoCommitSession(
        _FakeSessionMeta(
            auto_commit_policy={
                "pending_token_threshold": 100,
                "message_count_threshold": 500,
            },
            pending_tokens=101,
            message_count=5,
        )
    )
    service = SessionService()
    service.set_session_auto_commit_config(SessionAutoCommitConfig())

    class _FailingTaskTracker:
        async def has_running(self, *args, **kwargs) -> bool:
            raise RuntimeError("task store unavailable")

    monkeypatch.setattr(
        session_service_module, "get_task_tracker", lambda: _FailingTaskTracker()
    )

    did_schedule = await service.maybe_schedule_auto_commit(
        "session_a",
        _auto_commit_ctx(),
        reason_hint="message_write",
        session=session,
    )

    assert did_schedule is False
    assert session.commit_calls == []
    session = _FakeAutoCommitSession(
        _FakeSessionMeta(
            auto_commit_policy={
                "pending_token_threshold": 100,
                "message_count_threshold": 500,
                "keep_recent_count": 3,
                "min_commit_interval_seconds": 0,
            },
            pending_tokens=101,
            message_count=5,
        )
    )
    service = _session_service_for_auto_commit_test(monkeypatch, session)

    await service.run_auto_commit("session_a", _auto_commit_ctx(), reason="message_write")

    # message_write reserves the configured keep_recent tail and persists it.
    assert session.commit_calls == [(3, True, True)]
    assert session.save_calls == 0
    assert session.meta.last_auto_commit_at == ""


@pytest.mark.asyncio
async def test_run_auto_commit_throttles_with_utc_z_last_auto_commit_at_on_python310(monkeypatch):
    monkeypatch.setattr(session_service_module, "datetime", _Python310LikeDateTime)
    session = _FakeAutoCommitSession(
        _FakeSessionMeta(
            auto_commit_policy={
                "pending_token_threshold": 100,
                "message_count_threshold": 500,
                "keep_recent_count": 0,
                "min_commit_interval_seconds": 60,
            },
            pending_tokens=101,
            message_count=5,
            last_auto_commit_at="2099-01-01T00:00:00.000Z",
        )
    )
    service = _session_service_for_auto_commit_test(monkeypatch, session)

    await service.run_auto_commit("session_a", _auto_commit_ctx(), reason="message_write")

    assert session.commit_calls == []
    assert session.save_calls == 0


@pytest.mark.asyncio
async def test_run_auto_commit_rechecks_idle_timeout_before_committing(monkeypatch):
    session = _FakeAutoCommitSession(
        _FakeSessionMeta(
            auto_commit_policy={
                "idle_timeout_seconds": 300,
                "keep_recent_count": 0,
            },
            pending_tokens=1,
            message_count=1,
            last_message_at=datetime.now(timezone.utc).isoformat(),
        )
    )
    service = _session_service_for_auto_commit_test(monkeypatch, session)

    await service.run_auto_commit("session_a", _auto_commit_ctx(), reason="idle_timeout")

    assert session.commit_calls == []
    assert session.save_calls == 0


@pytest.mark.asyncio
async def test_run_auto_commit_idle_commits_full_backlog_without_persisting_keep_recent(monkeypatch):
    session = _FakeAutoCommitSession(
        _FakeSessionMeta(
            auto_commit_policy={
                "idle_timeout_seconds": 60,
                "keep_recent_count": 5,
            },
            pending_tokens=10,
            message_count=8,
            last_message_at=(datetime.now(timezone.utc) - timedelta(minutes=5)).isoformat(),
        )
    )
    service = _session_service_for_auto_commit_test(monkeypatch, session)

    await service.run_auto_commit("session_a", _auto_commit_ctx(), reason="idle_timeout")

    # Idle commits the full backlog and must not overwrite the stored keep pref.
    assert session.commit_calls == [(0, False, True)]
    assert session.save_calls == 0


@pytest.mark.asyncio
async def test_scheduler_scans_agfs_paths_directly_without_account_user_indices():
    tree_entries = [
        _session_entry("session_due"),
        _session_entry("session_skip"),
    ]
    metas = {
        "/local/acct_a/user/user_b/sessions/session_due/.meta.json": _meta(),
        "/local/acct_a/user/user_b/sessions/session_skip/.meta.json": _meta(
            pending_tokens=0,
            message_count=0,
        ),
    }
    service = _FakeSessionService(tree_entries, metas)
    scheduler = SessionAutoCommitScheduler(
        service,
        SimpleNamespace(enabled=True, check_interval_seconds=60.0),
        check_interval=60.0,
    )

    await scheduler._scan_once()

    assert service.viking_fs.ls_calls == [
        ("/local", "_system"),
        ("/local/acct_a/user", "acct_a"),
        ("/local/acct_a/user/user_b/sessions", "acct_a"),
    ]
    assert service.viking_fs.read_calls == [
        "/local/acct_a/user/user_b/sessions/session_due/.meta.json",
        "/local/acct_a/user/user_b/sessions/session_skip/.meta.json",
    ]
    # session_skip has no uncommitted content and is filtered at scan time.
    assert service.calls == [
        ("session_due", "idle_timeout", "user_b"),
    ]


@pytest.mark.asyncio
async def test_scheduler_skips_sessions_without_uncommitted_content():
    service = _FakeSessionService(
        [_session_entry("session_empty")],
        {
            "/local/acct_a/user/user_b/sessions/session_empty/.meta.json": _meta(
                pending_tokens=0,
                message_count=0,
            ),
        },
    )
    scheduler = SessionAutoCommitScheduler(
        service,
        SimpleNamespace(enabled=True, check_interval_seconds=60.0),
        check_interval=60.0,
    )

    await scheduler._scan_once()

    assert service.calls == []


@pytest.mark.asyncio
async def test_scheduler_skips_sessions_without_auto_commit_policy():
    service = _FakeSessionService(
        [_session_entry("session_disabled")],
        {
            "/local/acct_a/user/user_b/sessions/session_disabled/.meta.json": _meta()
            | {"auto_commit_policy": None},
        },
    )
    scheduler = SessionAutoCommitScheduler(
        service,
        SimpleNamespace(enabled=True, check_interval_seconds=60.0),
        check_interval=60.0,
    )

    await scheduler._scan_once()

    assert service.calls == []


@pytest.mark.asyncio
async def test_scheduler_schedules_idle_sessions_still_within_keep_recent_window():
    service = _FakeSessionService(
        [_session_entry("session_within_keep")],
        {
            "/local/acct_a/user/user_b/sessions/session_within_keep/.meta.json": _meta(
                pending_tokens=0,
                message_count=2,
                keep_recent_count=2,
            ),
        },
    )
    scheduler = SessionAutoCommitScheduler(
        service,
        SimpleNamespace(enabled=True, check_interval_seconds=60.0),
        check_interval=60.0,
    )

    await scheduler._scan_once()

    assert service.calls == [
        ("session_within_keep", "idle_timeout", "user_b"),
    ]


@pytest.mark.asyncio
async def test_scheduler_logs_scheduled_count_separately_from_due_candidates(caplog):
    service = _FakeSessionService(
        [_session_entry("session_due_1"), _session_entry("session_due_2")],
        {
            "/local/acct_a/user/user_b/sessions/session_due_1/.meta.json": _meta(),
            "/local/acct_a/user/user_b/sessions/session_due_2/.meta.json": _meta(),
        },
    )
    service.schedule_results = [True, False]
    scheduler = SessionAutoCommitScheduler(
        service,
        SimpleNamespace(enabled=True, check_interval_seconds=60.0),
        check_interval=60.0,
    )

    openviking_logger = logging.getLogger("openviking")
    old_propagate = openviking_logger.propagate
    openviking_logger.propagate = True
    try:
        with caplog.at_level(logging.INFO, logger="openviking.service.session_auto_commit"):
            await scheduler._scan_once()
    finally:
        openviking_logger.propagate = old_propagate

    assert "SessionAutoCommitScheduler scanned=2 due=2 scheduled=1" in caplog.text


@pytest.mark.asyncio
async def test_scheduler_reads_session_meta_serially():
    tree_entries = [_session_entry(f"session_{index}") for index in range(6)]
    metas = {
        f"/local/acct_a/user/user_b/sessions/session_{index}/.meta.json": _meta()
        for index in range(6)
    }
    service = _FakeSessionService(tree_entries, metas, read_delay_seconds=0.01)
    scheduler = SessionAutoCommitScheduler(
        service,
        SimpleNamespace(
            enabled=True,
            check_interval_seconds=60.0,
            scan_rate_limit_files_per_second=0.0,
        ),
        check_interval=60.0,
    )

    await scheduler._scan_once()

    assert service.viking_fs.max_active_reads == 1
    assert len(service.viking_fs.read_calls) == 6
    assert len(service.calls) == 6


@pytest.mark.asyncio
async def test_scheduler_paces_reads_by_rate_limit():
    tree_entries = [_session_entry(f"session_{index}") for index in range(5)]
    metas = {
        f"/local/acct_a/user/user_b/sessions/session_{index}/.meta.json": _meta()
        for index in range(5)
    }
    service = _FakeSessionService(tree_entries, metas)
    sleep_calls: list[float] = []

    async def fake_sleep(seconds: float) -> None:
        sleep_calls.append(seconds)

    scheduler = SessionAutoCommitScheduler(
        service,
        SimpleNamespace(
            enabled=True,
            check_interval_seconds=60.0,
            scan_rate_limit_files_per_second=2.0,
        ),
        check_interval=60.0,
        sleep=fake_sleep,
    )

    await scheduler._scan_once()

    # 5 reads => 4 pacing sleeps (the first read has no prior timestamp, so no
    # wait is required before it).
    assert len(sleep_calls) == 4
    assert all(0.0 <= call <= 0.5 + 1e-6 for call in sleep_calls)


@pytest.mark.asyncio
async def test_scheduler_paces_reads_across_multiple_users():
    users_by_account = {"acct_a": ["user_1", "user_2", "user_3"]}
    tree_entries_by_user = {
        ("acct_a", "user_1"): [_session_entry("session_1")],
        ("acct_a", "user_2"): [_session_entry("session_2")],
        ("acct_a", "user_3"): [_session_entry("session_3")],
    }
    metas = {
        "/local/acct_a/user/user_1/sessions/session_1/.meta.json": _meta(user_id="user_1"),
        "/local/acct_a/user/user_2/sessions/session_2/.meta.json": _meta(user_id="user_2"),
        "/local/acct_a/user/user_3/sessions/session_3/.meta.json": _meta(user_id="user_3"),
    }
    service = _FakeSessionService(
        [],
        metas,
        users_by_account=users_by_account,
        tree_entries_by_user=tree_entries_by_user,
    )
    sleep_calls: list[float] = []

    async def fake_sleep(seconds: float) -> None:
        sleep_calls.append(seconds)

    scheduler = SessionAutoCommitScheduler(
        service,
        SimpleNamespace(
            enabled=True,
            check_interval_seconds=60.0,
            scan_rate_limit_files_per_second=2.0,
        ),
        check_interval=60.0,
        sleep=fake_sleep,
    )

    await scheduler._scan_once()

    assert len(sleep_calls) == 2
    assert service.calls == [
        ("session_1", "idle_timeout", "user_1"),
        ("session_2", "idle_timeout", "user_2"),
        ("session_3", "idle_timeout", "user_3"),
    ]


@pytest.mark.asyncio
async def test_scheduler_does_not_warn_for_missing_meta(caplog):
    service = _FakeSessionService(
        [_session_entry("deleted_session")],
        {
            "/local/acct_a/user/user_b/sessions/deleted_session/.meta.json": FileNotFoundError(
                "missing"
            )
        },
    )
    scheduler = SessionAutoCommitScheduler(
        service,
        SimpleNamespace(enabled=True, check_interval_seconds=60.0),
        check_interval=60.0,
    )

    await scheduler._scan_once()

    assert not [record for record in caplog.records if record.levelname == "WARNING"]
    assert service.calls == []


@pytest.mark.asyncio
async def test_scheduler_warns_for_invalid_meta_json(caplog):
    service = _FakeSessionService(
        [_session_entry("bad_session")],
        {
            "/local/acct_a/user/user_b/sessions/bad_session/.meta.json": "{not-json",
        },
    )
    scheduler = SessionAutoCommitScheduler(
        service,
        SimpleNamespace(enabled=True, check_interval_seconds=60.0),
        check_interval=60.0,
    )

    openviking_logger = logging.getLogger("openviking")
    old_propagate = openviking_logger.propagate
    openviking_logger.propagate = True
    try:
        with caplog.at_level(logging.WARNING, logger="openviking.service.session_auto_commit"):
            await scheduler._scan_once()
    finally:
        openviking_logger.propagate = old_propagate

    assert "Invalid session meta JSON for idle auto-commit" in caplog.text
    assert service.calls == []


@pytest.mark.asyncio
async def test_scheduler_skips_non_object_meta_without_aborting_batch(caplog):
    service = _FakeSessionService(
        [_session_entry("bad_session"), _session_entry("good_session")],
        {
            "/local/acct_a/user/user_b/sessions/bad_session/.meta.json": [],
            "/local/acct_a/user/user_b/sessions/good_session/.meta.json": _meta(),
        },
    )
    scheduler = SessionAutoCommitScheduler(
        service,
        SimpleNamespace(enabled=True, check_interval_seconds=60.0),
        check_interval=60.0,
    )

    with caplog.at_level(logging.WARNING, logger="openviking.service.session_auto_commit"):
        await scheduler._scan_once()

    assert "Session auto-commit scheduler loop failed" not in caplog.text
    assert service.calls == [("good_session", "idle_timeout", "user_b")]


@pytest.mark.asyncio
async def test_scheduler_skips_malformed_due_fields_without_aborting_batch(caplog):
    service = _FakeSessionService(
        [_session_entry("bad_session"), _session_entry("good_session")],
        {
            "/local/acct_a/user/user_b/sessions/bad_session/.meta.json": _meta()
            | {"last_message_at": []},
            "/local/acct_a/user/user_b/sessions/good_session/.meta.json": _meta(),
        },
    )
    scheduler = SessionAutoCommitScheduler(
        service,
        SimpleNamespace(enabled=True, check_interval_seconds=60.0),
        check_interval=60.0,
    )

    with caplog.at_level(logging.WARNING, logger="openviking.service.session_auto_commit"):
        await scheduler._scan_once()

    assert "Session auto-commit scheduler loop failed" not in caplog.text
    assert service.calls == [("good_session", "idle_timeout", "user_b")]


@pytest.mark.asyncio
async def test_scheduler_warns_for_non_missing_session_scan_errors(caplog):
    service = _FakeSessionService(
        [],
        {},
        ls_errors={"/local/acct_a/user/user_b/sessions": RuntimeError("backend down")},
    )
    scheduler = SessionAutoCommitScheduler(
        service,
        SimpleNamespace(enabled=True, check_interval_seconds=60.0),
        check_interval=60.0,
    )

    openviking_logger = logging.getLogger("openviking")
    old_propagate = openviking_logger.propagate
    openviking_logger.propagate = True
    try:
        with caplog.at_level(logging.WARNING, logger="openviking.service.session_auto_commit"):
            await scheduler._scan_once()
    finally:
        openviking_logger.propagate = old_propagate

    assert "Failed to scan sessions for idle auto-commit" in caplog.text
    assert service.calls == []


@pytest.mark.asyncio
async def test_scheduler_reuses_async_agfs_client_between_scans(monkeypatch):
    service = _FakeSessionService(
        [_session_entry("session_due")],
        {
            "/local/acct_a/user/user_b/sessions/session_due/.meta.json": _meta(),
        },
    )
    created_clients = 0
    real_client = auto_commit_module.AsyncAGFSClient

    class _CountingAsyncAGFSClient(real_client):
        def __init__(self, client):
            nonlocal created_clients
            created_clients += 1
            super().__init__(client)

    monkeypatch.setattr(auto_commit_module, "AsyncAGFSClient", _CountingAsyncAGFSClient)
    scheduler = SessionAutoCommitScheduler(
        service,
        SimpleNamespace(enabled=True, check_interval_seconds=60.0),
        check_interval=60.0,
    )

    await scheduler._scan_once()
    await scheduler._scan_once()

    assert created_clients == 1