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
"""Regression tests for portable Bot session persistence paths."""
import json
import os
import unicodedata
from datetime import datetime
from pathlib import Path
from types import SimpleNamespace
import pytest
from vikingbot.config.schema import SessionKey
from vikingbot.heartbeat.service import HeartbeatService
from vikingbot.openviking_mount.session_state import (
OPENVIKING_SESSION_ID_FORMAT,
get_openviking_session_id,
)
from vikingbot.sandbox.manager import SandboxManager
from vikingbot.session.manager import Session, SessionManager
from vikingbot.utils.session_paths import (
portable_path_component,
resolve_workspace_path,
workspace_name,
)
def _write_session(
path: Path,
key: SessionKey,
content: str,
*,
metadata: dict | None = None,
) -> None:
metadata = {
"_type": "metadata",
"session_key": key.safe_name(),
"created_at": "2026-08-20T00:00:00",
"updated_at": "2026-08-20T00:00:01",
"metadata": metadata if metadata is not None else {"source": content},
}
message = {
"role": "user",
"content": content,
"timestamp": "2026-08-20T00:00:01",
}
path.write_text(
f"{json.dumps(metadata, ensure_ascii=False)}\n{json.dumps(message, ensure_ascii=False)}\n",
encoding="utf-8",
)
def test_openviking_storage_id_preserves_successful_legacy_namespace():
key = SessionKey(type="cli", channel_id="default", chat_id="scope:order:123")
logical_session_id = key.safe_name()
session = Session(
key=key,
metadata={
"openviking": {
"session_id": logical_session_id,
"last_sync_status": "success",
}
},
)
assert get_openviking_session_id(session) == logical_session_id
assert session.metadata["openviking"].get("session_id_format") is None
def test_openviking_storage_id_migrates_known_failed_unsafe_legacy_id():
key = SessionKey(type="cli", channel_id="default", chat_id="scope:order:123")
logical_session_id = key.safe_name()
session = Session(
key=key,
metadata={
"openviking": {
"session_id": logical_session_id,
"last_sync_status": "error",
"last_synced_local_index": -1,
"last_commit_local_index": -1,
}
},
)
storage_session_id = get_openviking_session_id(session)
assert storage_session_id == portable_path_component(logical_session_id)
assert ":" not in storage_session_id
assert session.metadata["openviking"]["logical_session_id"] == logical_session_id
assert session.metadata["openviking"]["session_id_format"] == (OPENVIKING_SESSION_ID_FORMAT)
def test_new_session_uses_portable_filename_without_changing_logical_key(tmp_path):
manager = SessionManager(tmp_path / "bot")
key = SessionKey(
type="cli",
channel_id="default",
chat_id="account:order__123/branch?",
)
session = Session(key=key, metadata={"openviking": {"session_id": key.safe_name()}})
session.add_message("user", "hello")
manager._save_unlocked(session)
path = manager._get_session_path(key)
assert path.name == f"{portable_path_component(key.safe_name())}.jsonl"
assert path.name.startswith("cli__default__account%3Aorder__123%2Fbranch%3F~")
assert path.exists()
first_line = json.loads(path.read_text(encoding="utf-8").splitlines()[0])
assert first_line["session_key"] == key.safe_name()
assert first_line["session_key_fields"] == key.model_dump(mode="json")
assert first_line["metadata"]["openviking"]["session_id"] == key.safe_name()
restarted = SessionManager(tmp_path / "bot")
loaded = restarted.get_or_create(key)
assert loaded.key == key
assert loaded.messages[0]["content"] == "hello"
assert restarted.list_sessions()[0]["key"] == key
def test_legacy_metadata_preserves_double_underscore_in_chat_id(tmp_path):
manager = SessionManager(tmp_path / "bot")
key = SessionKey(type="cli", channel_id="default", chat_id="legacy__session")
path = manager.sessions_dir / f"{key.safe_name()}.jsonl"
_write_session(path, key, "legacy history")
assert manager.get_or_create(key).key == key
assert manager.list_sessions()[0]["key"] == key
def test_legacy_session_is_loaded_then_lazily_migrated_on_save(tmp_path):
manager = SessionManager(tmp_path / "bot")
key = SessionKey(type="cli", channel_id="default", chat_id="legacy%session")
legacy_path = manager.sessions_dir / f"{key.safe_name()}.jsonl"
canonical_path = manager._get_session_path(key)
_write_session(legacy_path, key, "legacy history")
loaded = manager.get_or_create(key)
assert loaded.messages[0]["content"] == "legacy history"
assert manager.has_persisted(key)
assert legacy_path.exists()
assert not canonical_path.exists()
manager._save_unlocked(loaded)
assert canonical_path.exists()
assert not legacy_path.exists()
assert SessionManager(tmp_path / "bot").get_or_create(key).messages[0]["content"] == (
"legacy history"
)
@pytest.mark.skipif(os.name == "nt", reason="Windows cannot create the legacy colon filename")
def test_legacy_openapi_session_migrates_without_changing_openviking_id(tmp_path):
manager = SessionManager(tmp_path / "bot")
key = SessionKey(
type="cli",
channel_id="default",
chat_id="4ab668637bdb513f9384c8a8:order-123:7425fd71",
)
legacy_path = manager.sessions_dir / f"{key.safe_name()}.jsonl"
canonical_path = manager._get_session_path(key)
openviking_id = key.safe_name()
_write_session(
legacy_path,
key,
"existing OpenAPI history",
metadata={"openviking": {"session_id": openviking_id}},
)
loaded = manager.get_or_create(key)
manager._save_unlocked(loaded)
assert canonical_path.name == f"{portable_path_component(key.safe_name())}.jsonl"
assert canonical_path.exists()
assert not legacy_path.exists()
assert loaded.key == key
assert loaded.metadata["openviking"]["session_id"] == openviking_id
assert loaded.messages[0]["content"] == "existing OpenAPI history"
def test_delete_removes_canonical_and_legacy_files(tmp_path):
manager = SessionManager(tmp_path / "bot")
key = SessionKey(type="cli", channel_id="default", chat_id="both%paths")
canonical_path = manager._get_session_path(key)
legacy_path = manager.sessions_dir / f"{key.safe_name()}.jsonl"
_write_session(canonical_path, key, "canonical")
_write_session(legacy_path, key, "legacy")
assert manager.delete(key)
assert not canonical_path.exists()
assert not legacy_path.exists()
def test_list_sessions_deduplicates_interrupted_migration(tmp_path):
manager = SessionManager(tmp_path / "bot")
key = SessionKey(type="cli", channel_id="default", chat_id="both%paths")
canonical_path = manager._get_session_path(key)
legacy_path = manager.sessions_dir / f"{key.safe_name()}.jsonl"
_write_session(legacy_path, key, "legacy")
_write_session(canonical_path, key, "canonical")
sessions = manager.list_sessions()
assert len(sessions) == 1
assert sessions[0]["key"] == key
assert sessions[0]["path"] == str(canonical_path)
def test_session_files_do_not_collide_after_casefold_or_unicode_normalization(tmp_path):
manager = SessionManager(tmp_path / "bot")
keys = [
SessionKey(type="cli", channel_id="default", chat_id="foo"),
SessionKey(type="cli", channel_id="default", chat_id="FOO"),
SessionKey(type="cli", channel_id="default", chat_id="é"),
SessionKey(type="cli", channel_id="default", chat_id="e\u0301"),
]
paths = []
for key in keys:
session = Session(key=key)
session.add_message("user", key.chat_id)
manager._save_unlocked(session)
paths.append(manager._get_session_path(key))
assert len({path.name.casefold() for path in paths}) == len(paths)
assert len({unicodedata.normalize("NFD", path.name) for path in paths}) == len(paths)
assert all(path.exists() for path in paths)
restarted = SessionManager(tmp_path / "bot")
for key in keys:
assert restarted.get_or_create(key).messages[0]["content"] == key.chat_id
def test_legacy_lookup_does_not_reuse_a_case_folded_different_session(tmp_path):
manager = SessionManager(tmp_path / "bot")
lower = SessionKey(type="cli", channel_id="default", chat_id="foo")
upper = SessionKey(type="cli", channel_id="default", chat_id="FOO")
_write_session(manager.sessions_dir / f"{lower.safe_name()}.jsonl", lower, "lower")
assert manager._find_session_path(upper) is None
def test_sandbox_and_heartbeat_reuse_existing_legacy_workspace(tmp_path):
key = SessionKey(type="cli", channel_id="default", chat_id="legacy%workspace")
legacy_name = workspace_name(key, "per-session", portable=False)
legacy_path = tmp_path / legacy_name
legacy_path.mkdir()
sandbox_manager = object.__new__(SandboxManager)
sandbox_manager.workspace = tmp_path
sandbox_manager.config = SimpleNamespace(sandbox=SimpleNamespace(mode="per-session"))
assert sandbox_manager.to_workspace_id(key) == legacy_name
assert sandbox_manager.get_workspace_path(key) == legacy_path
session_manager = SimpleNamespace(
list_sessions=lambda: [
{
"key": key,
"created_at": datetime.now().isoformat(),
"updated_at": datetime.now().isoformat(),
"metadata": {},
}
]
)
heartbeat = HeartbeatService(
workspace=tmp_path,
sandbox_mode="per-session",
session_manager=session_manager,
)
assert heartbeat._get_all_workspaces() == {legacy_path: [key]}
def test_legacy_workspace_with_path_separators_is_not_reused(tmp_path):
key = SessionKey(type="cli", channel_id="default", chat_id="nested/workspace")
canonical = tmp_path / workspace_name(key, "per-session", portable=True)
assert resolve_workspace_path(tmp_path, key, "per-session") == canonical
assert canonical.parent == tmp_path
def test_legacy_workspace_lookup_requires_exact_logical_name(tmp_path):
lower = SessionKey(type="cli", channel_id="default", chat_id="foo")
upper = SessionKey(type="cli", channel_id="default", chat_id="FOO")
(tmp_path / lower.safe_name()).mkdir()
expected = tmp_path / workspace_name(upper, "per-session", portable=True)
assert resolve_workspace_path(tmp_path, upper, "per-session") == expected