909 lines
30 KiB
Python
909 lines
30 KiB
Python
"""数据库迁移基础设施测试。"""
|
|
|
|
from pathlib import Path
|
|
from typing import List, Optional, Tuple
|
|
|
|
from sqlalchemy import text
|
|
from sqlalchemy.engine import Connection, Engine
|
|
from sqlmodel import SQLModel, create_engine
|
|
|
|
import json
|
|
import msgpack
|
|
import pytest
|
|
|
|
from src.common.database import database as database_module
|
|
from src.common.database.migrations import (
|
|
BaseSchemaVersionDetector,
|
|
BaseMigrationProgressReporter,
|
|
DatabaseSchemaSnapshot,
|
|
DatabaseMigrationBootstrapper,
|
|
DatabaseMigrationState,
|
|
DatabaseMigrationManager,
|
|
EMPTY_SCHEMA_VERSION,
|
|
LATEST_SCHEMA_VERSION,
|
|
LEGACY_V1_SCHEMA_VERSION,
|
|
MigrationExecutionContext,
|
|
MigrationPlan,
|
|
MigrationRegistry,
|
|
MigrationStep,
|
|
ResolvedSchemaVersion,
|
|
SchemaVersionResolver,
|
|
SchemaVersionSource,
|
|
SQLiteSchemaInspector,
|
|
SQLiteUserVersionStore,
|
|
build_default_migration_registry,
|
|
build_default_schema_version_resolver,
|
|
create_database_migration_bootstrapper,
|
|
)
|
|
|
|
|
|
class FixedVersionDetector(BaseSchemaVersionDetector):
|
|
"""测试用固定版本探测器。"""
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
"""返回测试探测器名称。
|
|
|
|
Returns:
|
|
str: 探测器名称。
|
|
"""
|
|
return "fixed_version_detector"
|
|
|
|
def detect_version(self, snapshot: DatabaseSchemaSnapshot) -> Optional[int]:
|
|
"""根据测试表是否存在返回固定版本。
|
|
|
|
Args:
|
|
snapshot: 当前数据库结构快照。
|
|
|
|
Returns:
|
|
Optional[int]: 若存在测试表则返回固定版本，否则返回 ``None``。
|
|
"""
|
|
if snapshot.has_table("legacy_records"):
|
|
return 2
|
|
return None
|
|
|
|
|
|
class FakeMigrationProgressReporter(BaseMigrationProgressReporter):
|
|
"""测试用迁移进度上报器。"""
|
|
|
|
def __init__(self) -> None:
|
|
"""初始化测试用进度上报器。"""
|
|
self.events: List[Tuple[str, Optional[int], Optional[int], Optional[str]]] = []
|
|
|
|
def open(self) -> None:
|
|
"""记录打开事件。"""
|
|
self.events.append(("open", None, None, None))
|
|
|
|
def close(self) -> None:
|
|
"""记录关闭事件。"""
|
|
self.events.append(("close", None, None, None))
|
|
|
|
def start(
|
|
self,
|
|
total_records: int,
|
|
total_tables: int,
|
|
description: str = "总迁移进度",
|
|
table_unit_name: str = "表",
|
|
record_unit_name: str = "记录",
|
|
) -> None:
|
|
"""记录启动事件。
|
|
|
|
Args:
|
|
total_records: 任务记录总数。
|
|
total_tables: 任务表总数。
|
|
description: 任务描述。
|
|
table_unit_name: 表级进度单位名称。
|
|
record_unit_name: 记录级进度单位名称。
|
|
"""
|
|
del table_unit_name, record_unit_name
|
|
self.events.append(("start", total_records, total_tables, description))
|
|
|
|
def advance(
|
|
self,
|
|
records: int = 0,
|
|
completed_tables: int = 0,
|
|
item_name: Optional[str] = None,
|
|
) -> None:
|
|
"""记录推进事件。
|
|
|
|
Args:
|
|
records: 推进的记录数。
|
|
completed_tables: 已完成的表数。
|
|
item_name: 当前完成的项目名称。
|
|
"""
|
|
self.events.append(("advance", records, completed_tables, item_name))
|
|
|
|
|
|
def _create_sqlite_engine(database_file: Path) -> Engine:
|
|
"""创建测试用 SQLite 引擎。
|
|
|
|
Args:
|
|
database_file: 测试数据库文件路径。
|
|
|
|
Returns:
|
|
Engine: SQLite 引擎实例。
|
|
"""
|
|
return create_engine(
|
|
f"sqlite:///{database_file}",
|
|
echo=False,
|
|
connect_args={"check_same_thread": False},
|
|
)
|
|
|
|
|
|
def _create_current_schema(connection: Connection) -> None:
|
|
"""创建当前最新版本的数据库结构。
|
|
|
|
Args:
|
|
connection: 当前数据库连接。
|
|
"""
|
|
import src.common.database.database_model # noqa: F401
|
|
|
|
SQLModel.metadata.create_all(connection)
|
|
|
|
|
|
def _create_legacy_v1_schema_with_sample_data(connection: Connection) -> None:
|
|
"""创建带示例数据的旧版 ``0.x`` 数据库结构。
|
|
|
|
Args:
|
|
connection: 当前数据库连接。
|
|
"""
|
|
connection.execute(
|
|
text(
|
|
"""
|
|
CREATE TABLE chat_streams (
|
|
id INTEGER PRIMARY KEY,
|
|
stream_id TEXT NOT NULL,
|
|
create_time REAL NOT NULL,
|
|
last_active_time REAL NOT NULL,
|
|
platform TEXT NOT NULL,
|
|
user_id TEXT,
|
|
group_id TEXT,
|
|
group_name TEXT
|
|
)
|
|
"""
|
|
)
|
|
)
|
|
connection.execute(
|
|
text(
|
|
"""
|
|
CREATE TABLE messages (
|
|
id INTEGER PRIMARY KEY,
|
|
message_id TEXT NOT NULL,
|
|
time REAL NOT NULL,
|
|
chat_id TEXT NOT NULL,
|
|
chat_info_platform TEXT,
|
|
user_id TEXT,
|
|
user_nickname TEXT,
|
|
chat_info_group_id TEXT,
|
|
chat_info_group_name TEXT,
|
|
is_mentioned INTEGER,
|
|
is_at INTEGER,
|
|
processed_plain_text TEXT,
|
|
display_message TEXT,
|
|
is_emoji INTEGER,
|
|
is_picid INTEGER,
|
|
is_command INTEGER,
|
|
is_notify INTEGER,
|
|
additional_config TEXT,
|
|
priority_mode TEXT
|
|
)
|
|
"""
|
|
)
|
|
)
|
|
connection.execute(
|
|
text(
|
|
"""
|
|
CREATE TABLE action_records (
|
|
id INTEGER PRIMARY KEY,
|
|
action_id TEXT NOT NULL,
|
|
time REAL NOT NULL,
|
|
action_reasoning TEXT,
|
|
action_name TEXT NOT NULL,
|
|
action_data TEXT,
|
|
action_prompt_display TEXT,
|
|
chat_id TEXT
|
|
)
|
|
"""
|
|
)
|
|
)
|
|
connection.execute(
|
|
text(
|
|
"""
|
|
CREATE TABLE expression (
|
|
id INTEGER PRIMARY KEY,
|
|
situation TEXT NOT NULL,
|
|
style TEXT NOT NULL,
|
|
content_list TEXT,
|
|
count INTEGER,
|
|
last_active_time REAL NOT NULL,
|
|
chat_id TEXT,
|
|
create_date REAL,
|
|
checked INTEGER,
|
|
rejected INTEGER,
|
|
modified_by TEXT
|
|
)
|
|
"""
|
|
)
|
|
)
|
|
connection.execute(
|
|
text(
|
|
"""
|
|
CREATE TABLE jargon (
|
|
id INTEGER PRIMARY KEY,
|
|
content TEXT NOT NULL,
|
|
raw_content TEXT,
|
|
meaning TEXT,
|
|
chat_id TEXT,
|
|
is_global INTEGER,
|
|
count INTEGER,
|
|
is_jargon INTEGER,
|
|
last_inference_count INTEGER,
|
|
is_complete INTEGER,
|
|
inference_with_context TEXT,
|
|
inference_content_only TEXT
|
|
)
|
|
"""
|
|
)
|
|
)
|
|
|
|
connection.execute(
|
|
text(
|
|
"""
|
|
INSERT INTO chat_streams (
|
|
id,
|
|
stream_id,
|
|
create_time,
|
|
last_active_time,
|
|
platform,
|
|
user_id,
|
|
group_id,
|
|
group_name
|
|
) VALUES (
|
|
1,
|
|
'session-1',
|
|
1710000000.0,
|
|
1710000300.0,
|
|
'qq',
|
|
'user-1',
|
|
'group-1',
|
|
'测试群'
|
|
)
|
|
"""
|
|
)
|
|
)
|
|
connection.execute(
|
|
text(
|
|
"""
|
|
INSERT INTO messages (
|
|
id,
|
|
message_id,
|
|
time,
|
|
chat_id,
|
|
chat_info_platform,
|
|
user_id,
|
|
user_nickname,
|
|
chat_info_group_id,
|
|
chat_info_group_name,
|
|
is_mentioned,
|
|
is_at,
|
|
processed_plain_text,
|
|
display_message,
|
|
is_emoji,
|
|
is_picid,
|
|
is_command,
|
|
is_notify,
|
|
additional_config,
|
|
priority_mode
|
|
) VALUES (
|
|
1,
|
|
'msg-1',
|
|
1710000010.0,
|
|
'session-1',
|
|
'qq',
|
|
'user-1',
|
|
'测试用户',
|
|
'group-1',
|
|
'测试群',
|
|
1,
|
|
0,
|
|
'你好',
|
|
'你好呀',
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
'{"source":"legacy"}',
|
|
'high'
|
|
)
|
|
"""
|
|
)
|
|
)
|
|
connection.execute(
|
|
text(
|
|
"""
|
|
INSERT INTO action_records (
|
|
id,
|
|
action_id,
|
|
time,
|
|
action_reasoning,
|
|
action_name,
|
|
action_data,
|
|
action_prompt_display,
|
|
chat_id
|
|
) VALUES (
|
|
1,
|
|
'action-1',
|
|
1710000020.0,
|
|
'需要调用工具',
|
|
'search',
|
|
'{"query":"MaiBot"}',
|
|
'执行搜索',
|
|
'session-1'
|
|
)
|
|
"""
|
|
)
|
|
)
|
|
connection.execute(
|
|
text(
|
|
"""
|
|
INSERT INTO expression (
|
|
id,
|
|
situation,
|
|
style,
|
|
content_list,
|
|
count,
|
|
last_active_time,
|
|
chat_id,
|
|
create_date,
|
|
checked,
|
|
rejected,
|
|
modified_by
|
|
) VALUES (
|
|
1,
|
|
'打招呼',
|
|
'可爱',
|
|
'["你好呀","早上好"]',
|
|
3,
|
|
1710000030.0,
|
|
'session-1',
|
|
1710000040.0,
|
|
1,
|
|
0,
|
|
'ai'
|
|
)
|
|
"""
|
|
)
|
|
)
|
|
connection.execute(
|
|
text(
|
|
"""
|
|
INSERT INTO jargon (
|
|
id,
|
|
content,
|
|
raw_content,
|
|
meaning,
|
|
chat_id,
|
|
is_global,
|
|
count,
|
|
is_jargon,
|
|
last_inference_count,
|
|
is_complete,
|
|
inference_with_context,
|
|
inference_content_only
|
|
) VALUES (
|
|
1,
|
|
'上分',
|
|
'["上分"]',
|
|
'提高排名',
|
|
'session-1',
|
|
0,
|
|
5,
|
|
1,
|
|
2,
|
|
1,
|
|
'{"guess":"context"}',
|
|
'{"guess":"content"}'
|
|
)
|
|
"""
|
|
)
|
|
)
|
|
|
|
|
|
def test_user_version_store_can_read_and_write_versions(tmp_path: Path) -> None:
|
|
"""应支持读取与写入 SQLite ``user_version``。"""
|
|
engine = _create_sqlite_engine(tmp_path / "version_store.db")
|
|
version_store = SQLiteUserVersionStore()
|
|
|
|
with engine.begin() as connection:
|
|
assert version_store.read_version(connection) == 0
|
|
version_store.write_version(connection, 7)
|
|
|
|
with engine.connect() as connection:
|
|
assert version_store.read_version(connection) == 7
|
|
|
|
|
|
def test_schema_inspector_can_extract_tables_and_columns(tmp_path: Path) -> None:
|
|
"""应能提取 SQLite 数据库的表与列结构。"""
|
|
engine = _create_sqlite_engine(tmp_path / "schema_inspector.db")
|
|
inspector = SQLiteSchemaInspector()
|
|
|
|
with engine.begin() as connection:
|
|
connection.execute(
|
|
text(
|
|
"""
|
|
CREATE TABLE legacy_records (
|
|
id INTEGER PRIMARY KEY,
|
|
payload TEXT NOT NULL,
|
|
created_at TEXT
|
|
)
|
|
"""
|
|
)
|
|
)
|
|
|
|
with engine.connect() as connection:
|
|
snapshot = inspector.inspect(connection)
|
|
|
|
assert snapshot.has_table("legacy_records")
|
|
assert snapshot.has_column("legacy_records", "payload")
|
|
assert not snapshot.has_column("legacy_records", "missing_column")
|
|
table_schema = snapshot.get_table("legacy_records")
|
|
|
|
assert table_schema is not None
|
|
assert table_schema.column_names() == ["created_at", "id", "payload"]
|
|
|
|
|
|
def test_resolver_can_identify_empty_database(tmp_path: Path) -> None:
|
|
"""空数据库应被解析为版本 ``0``。"""
|
|
engine = _create_sqlite_engine(tmp_path / "empty_resolver.db")
|
|
resolver = SchemaVersionResolver()
|
|
|
|
with engine.connect() as connection:
|
|
resolved_version = resolver.resolve(connection)
|
|
|
|
assert resolved_version.version == 0
|
|
assert resolved_version.source == SchemaVersionSource.EMPTY_DATABASE
|
|
assert resolved_version.snapshot is not None
|
|
assert resolved_version.snapshot.is_empty()
|
|
|
|
|
|
def test_resolver_can_use_detector_for_unversioned_legacy_database(tmp_path: Path) -> None:
|
|
"""未写入 ``user_version`` 的历史库应支持通过探测器识别版本。"""
|
|
engine = _create_sqlite_engine(tmp_path / "legacy_resolver.db")
|
|
resolver = SchemaVersionResolver(detectors=[FixedVersionDetector()])
|
|
|
|
with engine.begin() as connection:
|
|
connection.execute(text("CREATE TABLE legacy_records (id INTEGER PRIMARY KEY, payload TEXT NOT NULL)"))
|
|
|
|
with engine.connect() as connection:
|
|
resolved_version = resolver.resolve(connection)
|
|
|
|
assert resolved_version.version == 2
|
|
assert resolved_version.source == SchemaVersionSource.DETECTOR
|
|
assert resolved_version.detector_name == "fixed_version_detector"
|
|
|
|
|
|
def test_registry_and_manager_can_execute_registered_steps(tmp_path: Path) -> None:
|
|
"""迁移编排器应能按顺序执行已注册步骤并更新版本号。"""
|
|
engine = _create_sqlite_engine(tmp_path / "manager.db")
|
|
executed_steps: List[str] = []
|
|
|
|
def migrate_0_to_1(context: MigrationExecutionContext) -> None:
|
|
"""测试迁移步骤 0 -> 1。
|
|
|
|
Args:
|
|
context: 当前迁移步骤执行上下文。
|
|
"""
|
|
executed_steps.append(f"{context.current_version}->{context.target_version}:step_0_to_1")
|
|
context.connection.execute(text("CREATE TABLE sample_records (id INTEGER PRIMARY KEY, name TEXT NOT NULL)"))
|
|
|
|
def migrate_1_to_2(context: MigrationExecutionContext) -> None:
|
|
"""测试迁移步骤 1 -> 2。
|
|
|
|
Args:
|
|
context: 当前迁移步骤执行上下文。
|
|
"""
|
|
executed_steps.append(f"{context.current_version}->{context.target_version}:step_1_to_2")
|
|
context.connection.execute(text("ALTER TABLE sample_records ADD COLUMN email TEXT"))
|
|
|
|
registry = MigrationRegistry(
|
|
steps=[
|
|
MigrationStep(
|
|
version_from=0,
|
|
version_to=1,
|
|
name="create_sample_records",
|
|
description="创建示例表。",
|
|
handler=migrate_0_to_1,
|
|
),
|
|
MigrationStep(
|
|
version_from=1,
|
|
version_to=2,
|
|
name="add_sample_email",
|
|
description="为示例表增加邮箱字段。",
|
|
handler=migrate_1_to_2,
|
|
),
|
|
]
|
|
)
|
|
manager = DatabaseMigrationManager(engine=engine, registry=registry)
|
|
|
|
migration_plan = manager.migrate()
|
|
|
|
assert migration_plan.step_count() == 2
|
|
assert executed_steps == ["0->2:step_0_to_1", "1->2:step_1_to_2"]
|
|
|
|
with engine.connect() as connection:
|
|
version_store = SQLiteUserVersionStore()
|
|
snapshot = SQLiteSchemaInspector().inspect(connection)
|
|
recorded_version = version_store.read_version(connection)
|
|
|
|
assert recorded_version == 2
|
|
assert snapshot.has_table("sample_records")
|
|
assert snapshot.has_column("sample_records", "email")
|
|
|
|
|
|
def test_manager_can_report_step_progress(tmp_path: Path) -> None:
|
|
"""迁移编排器应支持通过上下文上报步骤进度。"""
|
|
engine = _create_sqlite_engine(tmp_path / "manager_progress.db")
|
|
reporter_instances: List[FakeMigrationProgressReporter] = []
|
|
|
|
def _build_reporter() -> BaseMigrationProgressReporter:
|
|
"""构建测试用进度上报器。
|
|
|
|
Returns:
|
|
BaseMigrationProgressReporter: 测试用进度上报器实例。
|
|
"""
|
|
reporter = FakeMigrationProgressReporter()
|
|
reporter_instances.append(reporter)
|
|
return reporter
|
|
|
|
def migrate_1_to_2(context: MigrationExecutionContext) -> None:
|
|
"""测试迁移步骤 ``1 -> 2`` 的进度上报。
|
|
|
|
Args:
|
|
context: 当前迁移步骤执行上下文。
|
|
"""
|
|
context.start_progress(total_tables=3, total_records=30, description="总迁移进度")
|
|
context.advance_progress(records=10, completed_tables=1, item_name="chat_sessions")
|
|
context.advance_progress(records=10, completed_tables=1, item_name="mai_messages")
|
|
context.advance_progress(records=10, completed_tables=1, item_name="tool_records")
|
|
context.connection.execute(text("CREATE TABLE progress_records (id INTEGER PRIMARY KEY, value TEXT NOT NULL)"))
|
|
|
|
with engine.begin() as connection:
|
|
SQLiteUserVersionStore().write_version(connection, 1)
|
|
|
|
registry = MigrationRegistry(
|
|
steps=[
|
|
MigrationStep(
|
|
version_from=1,
|
|
version_to=2,
|
|
name="progress_step",
|
|
description="测试进度上报。",
|
|
handler=migrate_1_to_2,
|
|
)
|
|
]
|
|
)
|
|
manager = DatabaseMigrationManager(
|
|
engine=engine,
|
|
registry=registry,
|
|
progress_reporter_factory=_build_reporter,
|
|
)
|
|
|
|
migration_plan = manager.migrate()
|
|
|
|
assert migration_plan.step_count() == 1
|
|
assert len(reporter_instances) == 1
|
|
assert reporter_instances[0].events == [
|
|
("open", None, None, None),
|
|
("start", 30, 3, "总迁移进度"),
|
|
("advance", 10, 1, "chat_sessions"),
|
|
("advance", 10, 1, "mai_messages"),
|
|
("advance", 10, 1, "tool_records"),
|
|
("close", None, None, None),
|
|
]
|
|
|
|
|
|
def test_default_resolver_can_identify_unversioned_latest_database(tmp_path: Path) -> None:
|
|
"""默认解析器应能识别未写入版本号的最新结构数据库。"""
|
|
engine = _create_sqlite_engine(tmp_path / "latest_resolver.db")
|
|
resolver = build_default_schema_version_resolver()
|
|
|
|
with engine.begin() as connection:
|
|
_create_current_schema(connection)
|
|
|
|
with engine.connect() as connection:
|
|
resolved_version = resolver.resolve(connection)
|
|
|
|
assert resolved_version.version == LATEST_SCHEMA_VERSION
|
|
assert resolved_version.source == SchemaVersionSource.DETECTOR
|
|
assert resolved_version.detector_name == "latest_schema_detector"
|
|
|
|
|
|
def test_default_resolver_can_identify_legacy_v1_database(tmp_path: Path) -> None:
|
|
"""默认解析器应能识别未写版本号的旧版 ``0.x`` 数据库。"""
|
|
engine = _create_sqlite_engine(tmp_path / "legacy_v1_resolver.db")
|
|
resolver = build_default_schema_version_resolver()
|
|
|
|
with engine.begin() as connection:
|
|
_create_legacy_v1_schema_with_sample_data(connection)
|
|
|
|
with engine.connect() as connection:
|
|
resolved_version = resolver.resolve(connection)
|
|
|
|
assert resolved_version.version == LEGACY_V1_SCHEMA_VERSION
|
|
assert resolved_version.source == SchemaVersionSource.DETECTOR
|
|
assert resolved_version.detector_name == "legacy_v1_schema_detector"
|
|
|
|
|
|
def test_bootstrapper_can_finalize_unversioned_latest_database(tmp_path: Path) -> None:
|
|
"""已是最新结构但未写版本号的数据库应直接补写 ``user_version``。"""
|
|
engine = _create_sqlite_engine(tmp_path / "latest_finalize.db")
|
|
bootstrapper = create_database_migration_bootstrapper(engine)
|
|
|
|
with engine.begin() as connection:
|
|
_create_current_schema(connection)
|
|
|
|
migration_state = bootstrapper.prepare_database()
|
|
bootstrapper.finalize_database(migration_state)
|
|
|
|
assert not migration_state.requires_migration()
|
|
assert migration_state.resolved_version.version == LATEST_SCHEMA_VERSION
|
|
assert migration_state.resolved_version.source == SchemaVersionSource.DETECTOR
|
|
|
|
with engine.connect() as connection:
|
|
recorded_version = SQLiteUserVersionStore().read_version(connection)
|
|
|
|
assert recorded_version == LATEST_SCHEMA_VERSION
|
|
|
|
|
|
def test_bootstrapper_can_finalize_empty_database_to_latest_version(tmp_path: Path) -> None:
|
|
"""空库在建表完成后应回写最新 ``user_version``。"""
|
|
engine = _create_sqlite_engine(tmp_path / "bootstrap_empty.db")
|
|
bootstrapper = create_database_migration_bootstrapper(engine)
|
|
|
|
migration_state = bootstrapper.prepare_database()
|
|
|
|
assert not migration_state.requires_migration()
|
|
assert migration_state.resolved_version.version == EMPTY_SCHEMA_VERSION
|
|
assert migration_state.target_version == LATEST_SCHEMA_VERSION
|
|
|
|
with engine.begin() as connection:
|
|
_create_current_schema(connection)
|
|
|
|
bootstrapper.finalize_database(migration_state)
|
|
|
|
with engine.connect() as connection:
|
|
recorded_version = SQLiteUserVersionStore().read_version(connection)
|
|
|
|
assert recorded_version == LATEST_SCHEMA_VERSION
|
|
|
|
|
|
def test_bootstrapper_runs_registered_steps_for_versioned_database(tmp_path: Path) -> None:
|
|
"""启动桥接器应在已登记旧版本数据库上执行注册迁移步骤。"""
|
|
engine = _create_sqlite_engine(tmp_path / "bootstrap_registered.db")
|
|
execution_marks: List[str] = []
|
|
|
|
def migrate_1_to_2(context: MigrationExecutionContext) -> None:
|
|
"""测试桥接器迁移步骤 ``1 -> 2``。
|
|
|
|
Args:
|
|
context: 当前迁移步骤执行上下文。
|
|
"""
|
|
execution_marks.append(f"step={context.step_name},index={context.step_index}")
|
|
context.connection.execute(text("ALTER TABLE bootstrap_records ADD COLUMN email TEXT"))
|
|
|
|
with engine.begin() as connection:
|
|
connection.execute(
|
|
text("CREATE TABLE bootstrap_records (id INTEGER PRIMARY KEY, value TEXT NOT NULL)")
|
|
)
|
|
SQLiteUserVersionStore().write_version(connection, 1)
|
|
|
|
registry = MigrationRegistry(
|
|
steps=[
|
|
MigrationStep(
|
|
version_from=1,
|
|
version_to=2,
|
|
name="bootstrap_add_email",
|
|
description="为桥接器测试表增加邮箱字段。",
|
|
handler=migrate_1_to_2,
|
|
)
|
|
]
|
|
)
|
|
bootstrapper = DatabaseMigrationBootstrapper(
|
|
manager=DatabaseMigrationManager(engine=engine, registry=registry),
|
|
latest_schema_version=2,
|
|
)
|
|
|
|
migration_state = bootstrapper.prepare_database()
|
|
|
|
assert migration_state.resolved_version.version == 2
|
|
assert migration_state.target_version == 2
|
|
assert execution_marks == ["step=bootstrap_add_email,index=1"]
|
|
|
|
with engine.connect() as connection:
|
|
snapshot = SQLiteSchemaInspector().inspect(connection)
|
|
recorded_version = SQLiteUserVersionStore().read_version(connection)
|
|
|
|
assert recorded_version == 2
|
|
assert snapshot.has_table("bootstrap_records")
|
|
assert snapshot.has_column("bootstrap_records", "email")
|
|
|
|
|
|
def test_default_bootstrapper_can_migrate_legacy_v1_database(tmp_path: Path) -> None:
|
|
"""默认桥接器应能把旧版 ``0.x`` 数据库整体迁移到最新结构。"""
|
|
engine = _create_sqlite_engine(tmp_path / "legacy_v1_to_v2.db")
|
|
bootstrapper = create_database_migration_bootstrapper(engine)
|
|
|
|
with engine.begin() as connection:
|
|
_create_legacy_v1_schema_with_sample_data(connection)
|
|
|
|
migration_state = bootstrapper.prepare_database()
|
|
bootstrapper.finalize_database(migration_state)
|
|
|
|
assert not migration_state.requires_migration()
|
|
assert migration_state.resolved_version.version == LATEST_SCHEMA_VERSION
|
|
assert migration_state.resolved_version.source == SchemaVersionSource.PRAGMA
|
|
|
|
with engine.connect() as connection:
|
|
recorded_version = SQLiteUserVersionStore().read_version(connection)
|
|
snapshot = SQLiteSchemaInspector().inspect(connection)
|
|
message_row = connection.execute(
|
|
text(
|
|
"""
|
|
SELECT session_id, processed_plain_text, additional_config, raw_content
|
|
FROM mai_messages
|
|
WHERE message_id = 'msg-1'
|
|
"""
|
|
)
|
|
).mappings().one()
|
|
tool_row = connection.execute(
|
|
text(
|
|
"""
|
|
SELECT session_id, tool_name, tool_display_prompt
|
|
FROM tool_records
|
|
WHERE tool_id = 'action-1'
|
|
"""
|
|
)
|
|
).mappings().one()
|
|
expression_row = connection.execute(
|
|
text(
|
|
"""
|
|
SELECT session_id, content_list, modified_by
|
|
FROM expressions
|
|
WHERE id = 1
|
|
"""
|
|
)
|
|
).mappings().one()
|
|
jargon_row = connection.execute(
|
|
text(
|
|
"""
|
|
SELECT session_id_dict, raw_content, inference_with_content_only
|
|
FROM jargons
|
|
WHERE id = 1
|
|
"""
|
|
)
|
|
).mappings().one()
|
|
|
|
assert recorded_version == LATEST_SCHEMA_VERSION
|
|
assert snapshot.has_table("__legacy_v1_messages")
|
|
assert snapshot.has_table("chat_sessions")
|
|
assert snapshot.has_table("mai_messages")
|
|
assert snapshot.has_table("tool_records")
|
|
assert not snapshot.has_table("action_records")
|
|
assert not snapshot.has_column("mai_messages", "display_message")
|
|
|
|
unpacked_raw_content = msgpack.unpackb(message_row["raw_content"], raw=False)
|
|
additional_config = json.loads(message_row["additional_config"])
|
|
expression_content_list = json.loads(expression_row["content_list"])
|
|
jargon_session_id_dict = json.loads(jargon_row["session_id_dict"])
|
|
jargon_raw_content = json.loads(jargon_row["raw_content"])
|
|
|
|
assert message_row["session_id"] == "session-1"
|
|
assert message_row["processed_plain_text"] == "你好"
|
|
assert unpacked_raw_content == [{"type": "text", "data": "你好呀"}]
|
|
assert additional_config == {"priority_mode": "high", "source": "legacy"}
|
|
assert tool_row["session_id"] == "session-1"
|
|
assert tool_row["tool_name"] == "search"
|
|
assert tool_row["tool_display_prompt"] == "执行搜索"
|
|
assert expression_row["session_id"] == "session-1"
|
|
assert expression_row["modified_by"] == "AI"
|
|
assert expression_content_list == ["你好呀", "早上好"]
|
|
assert jargon_session_id_dict == {"session-1": 5}
|
|
assert jargon_raw_content == ["上分"]
|
|
assert jargon_row["inference_with_content_only"] == '{"guess":"content"}'
|
|
|
|
|
|
def test_legacy_v1_migration_reports_table_progress(tmp_path: Path) -> None:
|
|
"""旧版迁移步骤应按目标表数量推进总进度。"""
|
|
engine = _create_sqlite_engine(tmp_path / "legacy_progress.db")
|
|
reporter_instances: List[FakeMigrationProgressReporter] = []
|
|
|
|
def _build_reporter() -> BaseMigrationProgressReporter:
|
|
"""构建测试用进度上报器。
|
|
|
|
Returns:
|
|
BaseMigrationProgressReporter: 测试用进度上报器实例。
|
|
"""
|
|
reporter = FakeMigrationProgressReporter()
|
|
reporter_instances.append(reporter)
|
|
return reporter
|
|
|
|
with engine.begin() as connection:
|
|
_create_legacy_v1_schema_with_sample_data(connection)
|
|
|
|
manager = DatabaseMigrationManager(
|
|
engine=engine,
|
|
registry=build_default_migration_registry(),
|
|
resolver=build_default_schema_version_resolver(),
|
|
progress_reporter_factory=_build_reporter,
|
|
)
|
|
|
|
migration_plan = manager.migrate(target_version=LATEST_SCHEMA_VERSION)
|
|
|
|
assert migration_plan.step_count() == 3
|
|
assert len(reporter_instances) == 3
|
|
reporter_events = reporter_instances[0].events
|
|
|
|
assert reporter_events[0] == ("open", None, None, None)
|
|
assert reporter_events[1] == ("start", 6, 12, "总迁移进度")
|
|
assert reporter_events[-1] == ("close", None, None, None)
|
|
assert reporter_events.count(("advance", 1, 0, None)) == 6
|
|
assert reporter_events.count(("advance", 0, 1, "chat_sessions")) == 1
|
|
assert reporter_events.count(("advance", 0, 1, "thinking_questions")) == 1
|
|
assert len([event for event in reporter_events if event[0] == "advance"]) == 18
|
|
|
|
|
|
def test_initialize_database_calls_bootstrapper_before_create_all(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
tmp_path: Path,
|
|
) -> None:
|
|
"""数据库初始化入口应先准备迁移，再建表、补迁移并收尾。"""
|
|
call_order: List[str] = []
|
|
|
|
def _fake_prepare_database() -> DatabaseMigrationState:
|
|
"""返回测试用迁移状态。
|
|
|
|
Returns:
|
|
DatabaseMigrationState: 不包含迁移步骤的测试状态。
|
|
"""
|
|
call_order.append("prepare_database")
|
|
return DatabaseMigrationState(
|
|
resolved_version=ResolvedSchemaVersion(version=0, source=SchemaVersionSource.EMPTY_DATABASE),
|
|
target_version=LATEST_SCHEMA_VERSION,
|
|
plan=MigrationPlan(
|
|
current_version=EMPTY_SCHEMA_VERSION,
|
|
target_version=LATEST_SCHEMA_VERSION,
|
|
steps=[],
|
|
),
|
|
)
|
|
|
|
def _fake_create_all(bind) -> None:
|
|
"""记录建表调用。
|
|
|
|
Args:
|
|
bind: 传入的数据库绑定对象。
|
|
"""
|
|
del bind
|
|
call_order.append("create_all")
|
|
|
|
def _fake_finalize_database(migration_state: DatabaseMigrationState) -> None:
|
|
"""记录迁移收尾调用。
|
|
|
|
Args:
|
|
migration_state: 当前数据库迁移状态。
|
|
"""
|
|
del migration_state
|
|
call_order.append("finalize_database")
|
|
|
|
monkeypatch.setattr(database_module, "_db_initialized", False)
|
|
monkeypatch.setattr(database_module, "_DB_DIR", tmp_path / "data")
|
|
monkeypatch.setattr(database_module._migration_bootstrapper, "prepare_database", _fake_prepare_database)
|
|
monkeypatch.setattr(database_module._migration_bootstrapper, "finalize_database", _fake_finalize_database)
|
|
monkeypatch.setattr(database_module.SQLModel.metadata, "create_all", _fake_create_all)
|
|
|
|
database_module.initialize_database()
|
|
|
|
assert call_order == [
|
|
"prepare_database",
|
|
"create_all",
|
|
"finalize_database",
|
|
]
|