Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0
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