astrbot_plugin_imagestudio/tests/test_s0_infrastructure.py

262 行
8.5 KiB
Python

from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.dto.common import ErrorCode, error_response, success_response
from core.audit_service import AuditService
from core.identity import RequestContext
from database.db_helper import (
Database,
DatabaseSettings,
PostgresSettings,
SqliteSettings,
_Psycopg2ConnectionAdapter,
_load_yaml_subset,
load_database_settings,
set_runtime_config_overrides,
)
from database.models import table_spec
from database.seed import DEFAULT_MATERIAL_CATEGORIES, seed_default_material_categories
class CommonDtoTests(unittest.TestCase):
def test_success_response_matches_contract(self):
response = success_response({"ready": True}, request_id="req_test")
self.assertEqual(
response,
{
"ok": True,
"data": {"ready": True},
"warnings": [],
"request_id": "req_test",
},
)
def test_error_response_matches_contract(self):
response = error_response(
error_code=ErrorCode.VALIDATION_FAILED,
message="缺少字段",
details={"field": "name"},
request_id="req_test",
)
self.assertEqual(response["ok"], False)
self.assertEqual(response["error_code"], "VALIDATION_FAILED")
self.assertEqual(response["message"], "缺少字段")
self.assertEqual(response["details"], {"field": "name"})
self.assertEqual(response["request_id"], "req_test")
class DatabaseSettingsTests(unittest.TestCase):
def tearDown(self):
set_runtime_config_overrides({})
def test_sqlite_is_default_backend(self):
settings = DatabaseSettings()
self.assertEqual(settings.selected_backend, "sqlite")
def test_yaml_subset_parses_nested_lists(self):
payload = _load_yaml_subset(
"""
review_policy:
version: custom-v2
require_selected_image_for_statuses:
- selected
workflow_terminal_statuses:
- selected
- skipped
"""
)
self.assertEqual(payload["review_policy"]["require_selected_image_for_statuses"], ["selected"])
self.assertEqual(payload["review_policy"]["workflow_terminal_statuses"], ["selected", "skipped"])
def test_runtime_overrides_apply_to_default_config_only(self):
set_runtime_config_overrides(
{
"database": {
"backend": "postgresql",
"postgresql": {
"enabled": True,
"host": "127.0.0.1",
"database": "imagestudio_test",
"user": "imagestudio",
},
}
}
)
settings = load_database_settings()
self.assertEqual(settings.selected_backend, "postgresql")
self.assertEqual(settings.postgresql.host, "127.0.0.1")
with tempfile.TemporaryDirectory() as tmp:
config_path = Path(tmp) / "config.yaml"
config_path.write_text(
"""
database:
backend: sqlite
sqlite:
path: local.db
""",
encoding="utf-8",
)
isolated_settings = load_database_settings(config_path)
self.assertEqual(isolated_settings.selected_backend, "sqlite")
class DatabaseMetadataTests(unittest.TestCase):
def test_table_spec_exposes_known_tables(self):
workflow_nodes = table_spec("workflow_nodes")
self.assertIsNotNone(workflow_nodes)
self.assertEqual(workflow_nodes.primary_key, "node_id")
self.assertIn("status", workflow_nodes.column_names())
self.assertEqual(table_spec("config_snapshots").sensitive_columns(), ["config_json"])
def test_seed_default_material_categories_is_idempotent(self):
with tempfile.TemporaryDirectory() as tmp:
db_path = Path(tmp) / "imagestudio.db"
database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(db_path))))
database.initialize()
first = seed_default_material_categories(database)
second = seed_default_material_categories(database)
self.assertEqual(first["total"], len(DEFAULT_MATERIAL_CATEGORIES))
self.assertEqual(second["total"], 0)
conn = database.connect()
try:
count = conn.execute("SELECT COUNT(*) AS total FROM material_categories").fetchone()["total"]
finally:
conn.close()
self.assertEqual(count, len(DEFAULT_MATERIAL_CATEGORIES))
def test_postgres_is_selected_when_configured(self):
settings = DatabaseSettings(
backend="auto",
postgresql=PostgresSettings(
enabled=True,
host="localhost",
database="imagestudio",
user="imagestudio",
),
)
self.assertEqual(settings.selected_backend, "postgresql")
def test_forced_sqlite_ignores_configured_postgres(self):
settings = DatabaseSettings(
backend="sqlite",
postgresql=PostgresSettings(enabled=True, dsn="postgresql://example"),
)
self.assertEqual(settings.selected_backend, "sqlite")
def test_postgres_migration_runner_executes_split_statements(self):
class FakeConnection:
def __init__(self):
self.statements = []
def execute(self, statement):
self.statements.append(statement)
database = Database(
DatabaseSettings(
backend="postgresql",
postgresql=PostgresSettings(enabled=True, dsn="postgresql://example"),
)
)
conn = FakeConnection()
database._execute_script(
conn,
"""
CREATE TABLE IF NOT EXISTS demo (id TEXT PRIMARY KEY);
CREATE INDEX IF NOT EXISTS idx_demo_id ON demo(id);
""",
)
self.assertEqual(len(conn.statements), 2)
self.assertTrue(conn.statements[0].startswith("CREATE TABLE"))
self.assertTrue(conn.statements[1].startswith("CREATE INDEX"))
def test_psycopg2_adapter_exposes_connection_execute_shape(self):
class FakeCursor:
def __init__(self):
self.calls = []
def execute(self, query, params):
self.calls.append((query, params))
def fetchone(self):
return {"ok": True}
class FakeConnection:
def __init__(self):
self.cursor_instance = FakeCursor()
self.committed = False
self.closed = False
def cursor(self):
return self.cursor_instance
def commit(self):
self.committed = True
def close(self):
self.closed = True
raw = FakeConnection()
adapter = _Psycopg2ConnectionAdapter(raw)
cursor = adapter.execute("SELECT * FROM demo WHERE id = %s", ("demo_1",))
adapter.commit()
adapter.close()
self.assertEqual(cursor.fetchone(), {"ok": True})
self.assertEqual(raw.cursor_instance.calls, [("SELECT * FROM demo WHERE id = %s", ("demo_1",))])
self.assertTrue(raw.committed)
self.assertTrue(raw.closed)
class AuditServiceTests(unittest.TestCase):
def test_record_writes_audit_log_to_sqlite(self):
with tempfile.TemporaryDirectory() as tmp:
db_path = Path(tmp) / "imagestudio.db"
settings = DatabaseSettings(sqlite=SqliteSettings(path=str(db_path)))
database = Database(settings)
database.initialize()
ctx = RequestContext.system()
record = AuditService(database).record(
ctx=ctx,
action="unit_test",
target_type="test_target",
target_id="target_001",
after_snapshot={"ok": True},
)
conn = database.connect()
try:
row = conn.execute(
"SELECT action, target_type, target_id FROM audit_logs WHERE audit_id = ?",
(record.audit_id,),
).fetchone()
finally:
conn.close()
self.assertIsNotNone(row)
self.assertEqual(row["action"], "unit_test")
self.assertEqual(row["target_type"], "test_target")
self.assertEqual(row["target_id"], "target_001")
if __name__ == "__main__":
unittest.main()