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"] accessory = conn.execute( """ SELECT parent_id, category_type FROM material_categories WHERE category_id = 'cat_imagestudio_accessory_头部' """ ).fetchone() finally: conn.close() self.assertEqual(count, len(DEFAULT_MATERIAL_CATEGORIES)) self.assertEqual(accessory["parent_id"], "cat_imagestudio_配饰") self.assertEqual(accessory["category_type"], "accessory_group") 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()