同步:完善质量分析工作台并更新主题字体
同步已上线的智能分析执行协议、来源查询、图表报告与管理页面配套代码。 补齐数据库迁移、运行依赖和回归测试,保留原有指标计算口径。 统一午夜黑及其他主题的控件细节、中文和业务数字字体。 排除本地业务数据、凭据、预览、发布与验收产物。 验证:生产构建通过,320项前端回归通过;本轮仅同步Git,不再次部署。
This commit is contained in:
@@ -0,0 +1,430 @@
|
||||
"""Offline isolation checks for concurrent NAO actor sessions; never calls a model."""
|
||||
from __future__ import annotations
|
||||
|
||||
import contextlib
|
||||
import json
|
||||
import os
|
||||
import sqlite3
|
||||
import sys
|
||||
import tempfile
|
||||
import threading
|
||||
import unittest
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
|
||||
import nao_quality_runtime as runtime
|
||||
import nao_quality_runtime_mcp as runtime_mcp
|
||||
|
||||
|
||||
class WaitingResponse:
|
||||
def __init__(self):
|
||||
self.closed = threading.Event()
|
||||
|
||||
def __enter__(self):
|
||||
return self
|
||||
|
||||
def __exit__(self, *_):
|
||||
self.close()
|
||||
|
||||
def __iter__(self):
|
||||
self.closed.wait(0.5)
|
||||
return iter(())
|
||||
|
||||
def close(self):
|
||||
self.closed.set()
|
||||
|
||||
|
||||
class WaitingClient:
|
||||
def open(self, *_args, **_kwargs):
|
||||
return WaitingResponse()
|
||||
|
||||
|
||||
class SessionIsolationTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory(prefix="test-nao-users-")
|
||||
self.users = Path(self.temp.name).resolve()
|
||||
self.manager = runtime.RuntimeManager(users_root=self.users)
|
||||
self.actor_id = str(uuid.uuid4())
|
||||
self.actor_b = str(uuid.uuid4())
|
||||
self.session_a = str(uuid.uuid4())
|
||||
self.session_b = str(uuid.uuid4())
|
||||
self.release_a = str(uuid.uuid4())
|
||||
self.release_b = str(uuid.uuid4())
|
||||
|
||||
def tearDown(self):
|
||||
self.temp.cleanup()
|
||||
|
||||
def test_same_actor_sessions_have_independent_roots_locks_credentials_and_mcp_paths(self):
|
||||
root_a, lock_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
||||
root_b, lock_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
||||
try:
|
||||
self.assertEqual(root_a, self.users / self.actor_id / "sessions" / self.session_a)
|
||||
self.assertEqual(root_b, self.users / self.actor_id / "sessions" / self.session_b)
|
||||
self.assertNotEqual(root_a, root_b)
|
||||
self.assertNotEqual(root_a / "active.lock", root_b / "active.lock")
|
||||
|
||||
access_a = runtime.write_access_file(root_a, "token-session-A", self.release_a,
|
||||
expected_actor_id=self.actor_id,
|
||||
expected_session_id=self.session_a)
|
||||
access_b = runtime.write_access_file(root_b, "token-session-B", self.release_b,
|
||||
expected_actor_id=self.actor_id,
|
||||
expected_session_id=self.session_b)
|
||||
snapshot_a = runtime.load_access_snapshot(
|
||||
access_a, runtime_root=self.users, expected_actor_id=self.actor_id,
|
||||
expected_session_id=self.session_a,
|
||||
)
|
||||
snapshot_b = runtime.load_access_snapshot(
|
||||
access_b, runtime_root=self.users, expected_actor_id=self.actor_id,
|
||||
expected_session_id=self.session_b,
|
||||
)
|
||||
self.assertEqual((snapshot_a.actor_id, snapshot_a.token, snapshot_a.release_id),
|
||||
(self.actor_id, "token-session-A", self.release_a))
|
||||
self.assertEqual((snapshot_b.actor_id, snapshot_b.token, snapshot_b.release_id),
|
||||
(self.actor_id, "token-session-B", self.release_b))
|
||||
self.assertNotEqual(access_a, access_b)
|
||||
|
||||
runtime._write_private_state(root_a)
|
||||
runtime._write_private_state(root_b)
|
||||
runtime._write_project(root_a, self.session_a, "test-model", refresh_templates=True,
|
||||
refresh_mcp=True, backup_schema=False,
|
||||
expected_actor_id=self.actor_id)
|
||||
runtime._write_project(root_b, self.session_b, "test-model", refresh_templates=True,
|
||||
refresh_mcp=True, backup_schema=False,
|
||||
expected_actor_id=self.actor_id)
|
||||
mcp_a = json.loads((root_a / "project/agent/mcps/mcp.json").read_text())
|
||||
mcp_b = json.loads((root_b / "project/agent/mcps/mcp.json").read_text())
|
||||
env_a = mcp_a["mcpServers"]["quality"]["env"]
|
||||
env_b = mcp_b["mcpServers"]["quality"]["env"]
|
||||
self.assertEqual(env_a["QUALITY_AGENT_ACTOR_ID"], self.actor_id)
|
||||
self.assertEqual(env_b["QUALITY_AGENT_ACTOR_ID"], self.actor_id)
|
||||
self.assertEqual(env_a["QUALITY_AGENT_SESSION_ID"], self.session_a)
|
||||
self.assertEqual(env_b["QUALITY_AGENT_SESSION_ID"], self.session_b)
|
||||
self.assertEqual(env_a["QUALITY_AGENT_ACCESS_FILE"], str(access_a))
|
||||
self.assertEqual(env_b["QUALITY_AGENT_ACCESS_FILE"], str(access_b))
|
||||
self.assertNotEqual(env_a["QUALITY_AGENT_SESSION_STATE_FILE"],
|
||||
env_b["QUALITY_AGENT_SESSION_STATE_FILE"])
|
||||
self.assertNotEqual(runtime._write_private_state(root_a), runtime._write_private_state(root_b))
|
||||
finally:
|
||||
self.manager.release_actor(lock_a)
|
||||
self.manager.release_actor(lock_b)
|
||||
# flock files are stable coordination objects and are never unlinked.
|
||||
self.assertTrue((root_a / "active.lock").is_file())
|
||||
self.assertTrue((root_b / "active.lock").is_file())
|
||||
|
||||
def test_same_session_is_mutually_exclusive_but_other_session_and_actor_can_run(self):
|
||||
_root_a, lock_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
||||
root_b, lock_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
||||
root_c, lock_c = self.manager.acquire_actor(self.actor_b, self.session_a)
|
||||
try:
|
||||
self.assertNotEqual(root_b, root_c)
|
||||
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "另一轮分析"):
|
||||
self.manager.acquire_actor(self.actor_id, self.session_a)
|
||||
finally:
|
||||
self.manager.release_actor(lock_c)
|
||||
self.manager.release_actor(lock_b)
|
||||
self.manager.release_actor(lock_a)
|
||||
_again, lock_again = self.manager.acquire_actor(self.actor_id, self.session_a)
|
||||
self.manager.release_actor(lock_again)
|
||||
|
||||
def test_access_snapshot_rejects_actor_session_mismatch_and_symlink(self):
|
||||
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
||||
try:
|
||||
access = runtime.write_access_file(root_a, "strict-token", self.release_a,
|
||||
expected_actor_id=self.actor_id,
|
||||
expected_session_id=self.session_a)
|
||||
with self.assertRaisesRegex(ValueError, "当前会话"):
|
||||
runtime.load_access_snapshot(access, runtime_root=self.users,
|
||||
expected_actor_id=self.actor_b,
|
||||
expected_session_id=self.session_a)
|
||||
with self.assertRaisesRegex(ValueError, "路径与当前会话"):
|
||||
runtime.load_access_snapshot(access, runtime_root=self.users,
|
||||
expected_actor_id=self.actor_id,
|
||||
expected_session_id=self.session_b)
|
||||
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "actor/session"):
|
||||
runtime.write_access_file(root_a, "wrong-owner", self.release_a,
|
||||
expected_actor_id=self.actor_b,
|
||||
expected_session_id=self.session_a)
|
||||
link = root_a / "linked-access.json"
|
||||
link.symlink_to(access)
|
||||
with self.assertRaisesRegex(ValueError, "路径无效"):
|
||||
runtime.load_access_snapshot(link, runtime_root=self.users,
|
||||
expected_actor_id=self.actor_id,
|
||||
expected_session_id=self.session_a)
|
||||
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "actor/session"):
|
||||
runtime._write_project(root_a, self.session_a, "test-model", refresh_templates=False,
|
||||
refresh_mcp=False, backup_schema=False,
|
||||
expected_actor_id=self.actor_b)
|
||||
finally:
|
||||
self.manager.release_actor(fd_a)
|
||||
|
||||
def test_mcp_shim_accepts_only_fixed_actor_session_paths(self):
|
||||
fake_root = self.users / "fake-project"
|
||||
users_root = fake_root / ".runtime" / "nao-users"
|
||||
session_root = users_root / self.actor_id / "sessions" / self.session_a
|
||||
session_root.mkdir(parents=True)
|
||||
environment = {
|
||||
"QUALITY_AGENT_USERS_ROOT": str(users_root),
|
||||
"QUALITY_AGENT_ACCESS_FILE": str(session_root / "access.json"),
|
||||
"QUALITY_AGENT_EVIDENCE_DIR": str(session_root / "evidence"),
|
||||
"QUALITY_AGENT_SESSION_STATE_FILE": str(session_root / "private" / "current-session.json"),
|
||||
"QUALITY_AGENT_ACTOR_ID": self.actor_id,
|
||||
"QUALITY_AGENT_SESSION_ID": self.session_a,
|
||||
}
|
||||
with patch.object(runtime_mcp, "ROOT", fake_root), patch.dict(os.environ, environment, clear=False):
|
||||
access, evidence, state, actor, session, root = runtime_mcp._paths()
|
||||
self.assertEqual(access, session_root / "access.json")
|
||||
self.assertEqual(evidence, session_root / "evidence")
|
||||
self.assertEqual(state, session_root / "private" / "current-session.json")
|
||||
self.assertEqual((actor, session), (self.actor_id, self.session_a))
|
||||
self.assertEqual(root, users_root.resolve())
|
||||
os.environ["QUALITY_AGENT_ACCESS_FILE"] = str(users_root / self.actor_id / "access.json")
|
||||
with self.assertRaisesRegex(ValueError, "路径无效"):
|
||||
runtime_mcp._paths()
|
||||
|
||||
def test_cancel_stops_only_the_current_session_chat(self):
|
||||
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
||||
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
||||
try:
|
||||
state_a = runtime.SessionState(root_a, self.actor_id, self.session_a)
|
||||
state_b = runtime.SessionState(root_b, self.actor_id, self.session_b)
|
||||
state_a.set_chat_id(self.session_a, "native-chat-A")
|
||||
state_b.set_chat_id(self.session_b, "native-chat-B")
|
||||
cancel = threading.Event()
|
||||
cancel.set()
|
||||
stopped = []
|
||||
|
||||
def stop_native(_client, _base, chat_id):
|
||||
stopped.append(chat_id)
|
||||
return True
|
||||
|
||||
with patch.object(runtime, "_stop_native",
|
||||
side_effect=lambda _client, _base, chat_id: stopped.append(chat_id) or True):
|
||||
result = runtime._sse_request(
|
||||
client=WaitingClient(), base_url="http://127.0.0.1:10000", model="offline-test",
|
||||
question="q", release_id=self.release_a, context=None,
|
||||
chat_id=state_a.get_chat_id(self.session_a), session_state=state_a,
|
||||
session_id=self.session_a, actor_root=root_a, emit=lambda _event: None,
|
||||
cancel_event=cancel, timeout=5,
|
||||
)
|
||||
self.assertEqual(result[1], "CANCELLED")
|
||||
self.assertEqual(stopped, ["native-chat-A"])
|
||||
self.assertEqual(state_b.get_chat_id(self.session_b), "native-chat-B")
|
||||
self.assertFalse((root_b / "instance.json").exists())
|
||||
finally:
|
||||
self.manager.release_actor(fd_b)
|
||||
self.manager.release_actor(fd_a)
|
||||
|
||||
def test_stop_instance_only_targets_processes_recorded_in_that_session(self):
|
||||
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
||||
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
||||
try:
|
||||
for root, session_id, pids, port in (
|
||||
(root_a, self.session_a, [10101, 10102], 41001),
|
||||
(root_b, self.session_b, [20201, 20202], 42001),
|
||||
):
|
||||
runtime._atomic_json(root / "instance.json", {
|
||||
"actorId": self.actor_id, "sessionId": session_id,
|
||||
"processes": [{"pid": pid, "pgid": pid, "lstart": "simulated",
|
||||
"kind": "server", "port": port + index}
|
||||
for index, pid in enumerate(pids)],
|
||||
})
|
||||
killed = []
|
||||
|
||||
def matches(record, runtime_root):
|
||||
return runtime_root == root_a and record.get("pid") in (10101, 10102)
|
||||
|
||||
with patch.object(runtime, "_process_matches", side_effect=matches), \
|
||||
patch.object(runtime, "_ps_value", return_value="simulated process"), \
|
||||
patch.object(runtime.os, "killpg", side_effect=lambda pgid, _sig: killed.append(pgid)), \
|
||||
patch.object(runtime.time, "sleep"):
|
||||
runtime._stop_instance(root_a, grace_seconds=0)
|
||||
self.assertEqual(set(killed), {10101, 10102})
|
||||
self.assertTrue((root_b / "instance.json").is_file())
|
||||
finally:
|
||||
self.manager.release_actor(fd_b)
|
||||
self.manager.release_actor(fd_a)
|
||||
|
||||
def test_stop_all_skips_active_session_and_scans_legacy_and_idle_sessions(self):
|
||||
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
||||
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
||||
legacy = self.users / self.actor_b
|
||||
legacy.mkdir(parents=True)
|
||||
runtime._atomic_json(legacy / "instance.json", {"actorId": self.actor_b, "processes": []})
|
||||
for root in (root_a, root_b, legacy):
|
||||
runtime._atomic_json(root / "access.json", {"token": "private"})
|
||||
self.manager.release_actor(fd_b)
|
||||
try:
|
||||
stopped = []
|
||||
manager = self.manager
|
||||
with patch.object(runtime, "_stop_instance", side_effect=lambda root: stopped.append(root) or True):
|
||||
count = manager.stop_idle_all()
|
||||
self.assertEqual(count, 2)
|
||||
self.assertEqual(set(stopped), {root_b, legacy})
|
||||
self.assertTrue((root_a / "access.json").exists())
|
||||
self.assertFalse((root_b / "access.json").exists())
|
||||
self.assertFalse((legacy / "access.json").exists())
|
||||
self.assertIn(legacy, runtime._runtime_roots(self.users))
|
||||
self.assertIn(root_a, runtime._runtime_roots(self.users))
|
||||
finally:
|
||||
self.manager.release_actor(fd_a)
|
||||
|
||||
def test_project_template_symlink_cannot_write_into_another_session(self):
|
||||
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
||||
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
||||
try:
|
||||
project_a = root_a / "project"
|
||||
project_a.mkdir()
|
||||
project_b = root_b / "project"
|
||||
project_b.mkdir()
|
||||
protected_config = project_b / "nao_config.yaml"
|
||||
protected_config.write_text("session B config", encoding="utf-8")
|
||||
(project_a / "nao_config.yaml").symlink_to(protected_config)
|
||||
with self.assertRaisesRegex(ValueError, "运行路径无效"):
|
||||
runtime._write_project(root_a, self.session_a, "test-model", refresh_templates=True,
|
||||
refresh_mcp=True, backup_schema=False,
|
||||
expected_actor_id=self.actor_id)
|
||||
self.assertEqual(protected_config.read_text(encoding="utf-8"), "session B config")
|
||||
finally:
|
||||
self.manager.release_actor(fd_b)
|
||||
self.manager.release_actor(fd_a)
|
||||
|
||||
def test_server_log_open_rejects_symlink_and_non_regular_files(self):
|
||||
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
||||
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
||||
try:
|
||||
logs_a = root_a / "logs"
|
||||
logs_b = root_b / "logs"
|
||||
logs_a.mkdir()
|
||||
logs_b.mkdir()
|
||||
protected_log = logs_b / "server.log"
|
||||
protected_log.write_text("session B log", encoding="utf-8")
|
||||
(logs_a / "server.log").symlink_to(protected_log)
|
||||
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "日志文件路径无效"):
|
||||
runtime._open_server_log(logs_a / "server.log", root_a)
|
||||
self.assertEqual(protected_log.read_text(encoding="utf-8"), "session B log")
|
||||
|
||||
(logs_a / "server.log").unlink()
|
||||
fifo = logs_a / "server.log"
|
||||
os.mkfifo(fifo)
|
||||
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "日志文件路径无效"):
|
||||
runtime._open_server_log(fifo, root_a)
|
||||
finally:
|
||||
self.manager.release_actor(fd_b)
|
||||
self.manager.release_actor(fd_a)
|
||||
|
||||
def test_legacy_session_history_is_copied_to_private_root_without_changing_source(self):
|
||||
actor_root = self.users / self.actor_id
|
||||
legacy_private = actor_root / "private"
|
||||
legacy_private.mkdir(parents=True)
|
||||
mapping = legacy_private / "sessions.json"
|
||||
runtime._atomic_json(mapping, {
|
||||
"actorId": self.actor_id,
|
||||
"sessions": {self.session_a: "old-native-chat-A", self.session_b: "old-native-chat-B"},
|
||||
})
|
||||
mapping_before = mapping.read_bytes()
|
||||
runtime._atomic_json(legacy_private / "credentials.json", {
|
||||
"authSecret": "legacy-auth", "email": "legacy@example.invalid", "password": "legacy-password",
|
||||
})
|
||||
legacy_project = actor_root / "project"
|
||||
legacy_project.mkdir(parents=True)
|
||||
source_db = legacy_private / "nao.sqlite"
|
||||
with contextlib.closing(sqlite3.connect(source_db)) as database:
|
||||
with database:
|
||||
# Mirrors NAO's actual SQLite project.path and chat.project_id
|
||||
# relationship used by agent routes and MCP project lookup.
|
||||
database.executescript("""
|
||||
CREATE TABLE project (
|
||||
id TEXT PRIMARY KEY NOT NULL,
|
||||
org_id TEXT,
|
||||
name TEXT NOT NULL,
|
||||
type TEXT NOT NULL,
|
||||
path TEXT,
|
||||
agent_settings TEXT,
|
||||
enabled_tools TEXT NOT NULL DEFAULT '[]',
|
||||
known_mcp_servers TEXT NOT NULL DEFAULT '[]',
|
||||
disabled_mcp_servers TEXT NOT NULL DEFAULT '[]',
|
||||
disabled_mcp_tools TEXT NOT NULL DEFAULT '[]',
|
||||
env_vars TEXT NOT NULL DEFAULT '{}',
|
||||
CONSTRAINT local_project_path_required
|
||||
CHECK(CASE WHEN type = 'local' THEN path IS NOT NULL ELSE TRUE END)
|
||||
);
|
||||
CREATE TABLE chat (
|
||||
id TEXT PRIMARY KEY NOT NULL,
|
||||
user_id TEXT NOT NULL,
|
||||
project_id TEXT NOT NULL REFERENCES project(id),
|
||||
title TEXT DEFAULT 'New Conversation' NOT NULL,
|
||||
is_starred INTEGER DEFAULT false NOT NULL,
|
||||
deleted_at INTEGER,
|
||||
slack_thread_id TEXT,
|
||||
teams_thread_id TEXT,
|
||||
telegram_thread_id TEXT,
|
||||
mattermost_thread_id TEXT,
|
||||
discord_thread_id TEXT,
|
||||
whatsapp_thread_id TEXT,
|
||||
fork_metadata TEXT,
|
||||
created_at INTEGER NOT NULL,
|
||||
updated_at INTEGER NOT NULL
|
||||
);
|
||||
""")
|
||||
database.execute(
|
||||
"INSERT INTO project(id,name,type,path) VALUES (?,?,?,?)",
|
||||
("legacy-project-id", "Quality", "local", str(legacy_project)),
|
||||
)
|
||||
database.executemany(
|
||||
"INSERT INTO chat(id,user_id,project_id,created_at,updated_at) VALUES (?,?,?,?,?)",
|
||||
(("old-native-chat-A", "legacy-user", "legacy-project-id", 1, 1),
|
||||
("old-native-chat-B", "legacy-user", "legacy-project-id", 2, 2)),
|
||||
)
|
||||
source_db.chmod(0o600)
|
||||
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
|
||||
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
|
||||
try:
|
||||
self.assertTrue(self.manager._migrate_legacy_session(self.actor_id, self.session_a, root_a))
|
||||
self.assertTrue(self.manager._migrate_legacy_session(self.actor_id, self.session_b, root_b))
|
||||
state = runtime.SessionState(root_a, self.actor_id, self.session_a)
|
||||
other_state = runtime.SessionState(root_b, self.actor_id, self.session_b)
|
||||
self.assertEqual(state.get_chat_id(self.session_a), "old-native-chat-A")
|
||||
self.assertEqual(other_state.get_chat_id(self.session_b), "old-native-chat-B")
|
||||
self.assertNotEqual(root_a / "private" / "nao.sqlite", source_db)
|
||||
with contextlib.closing(sqlite3.connect(root_a / "private" / "nao.sqlite")) as database:
|
||||
self.assertEqual(database.execute(
|
||||
"SELECT id,path FROM project WHERE id='legacy-project-id'"
|
||||
).fetchone(), ("legacy-project-id", str(root_a / "project")))
|
||||
self.assertEqual(database.execute(
|
||||
"SELECT id,project_id FROM chat WHERE id='old-native-chat-A'"
|
||||
).fetchone(), ("old-native-chat-A", "legacy-project-id"))
|
||||
self.assertEqual(database.execute(
|
||||
"SELECT id,project_id FROM chat WHERE id='old-native-chat-B'"
|
||||
).fetchone(), ("old-native-chat-B", "legacy-project-id"))
|
||||
with contextlib.closing(sqlite3.connect(root_b / "private" / "nao.sqlite")) as database:
|
||||
with database:
|
||||
database.execute(
|
||||
"INSERT INTO chat(id,user_id,project_id,created_at,updated_at) VALUES (?,?,?,?,?)",
|
||||
("session-B-only", "legacy-user", "legacy-project-id", 3, 3),
|
||||
)
|
||||
self.assertEqual(database.execute(
|
||||
"SELECT id,path FROM project WHERE id='legacy-project-id'"
|
||||
).fetchone(), ("legacy-project-id", str(root_b / "project")))
|
||||
with contextlib.closing(sqlite3.connect(root_a / "private" / "nao.sqlite")) as database:
|
||||
rows = database.execute("SELECT id FROM chat ORDER BY id").fetchall()
|
||||
self.assertEqual(rows, [("old-native-chat-A",), ("old-native-chat-B",)])
|
||||
with contextlib.closing(sqlite3.connect(source_db)) as database:
|
||||
self.assertEqual(database.execute(
|
||||
"SELECT id,path FROM project WHERE id='legacy-project-id'"
|
||||
).fetchone(), ("legacy-project-id", str(legacy_project)))
|
||||
self.assertEqual(database.execute(
|
||||
"SELECT id,project_id FROM chat WHERE id='old-native-chat-A'"
|
||||
).fetchone(), ("old-native-chat-A", "legacy-project-id"))
|
||||
self.assertEqual(mapping.read_bytes(), mapping_before)
|
||||
self.assertTrue(source_db.is_file())
|
||||
self.assertEqual(runtime._read_json(root_a / "private" / "credentials.json")["authSecret"],
|
||||
"legacy-auth")
|
||||
finally:
|
||||
self.manager.release_actor(fd_b)
|
||||
self.manager.release_actor(fd_a)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user