fix: drop default task_logs; process in log, progress in task center (v1.0.81)

tests/test_display_metadata.py

@@ -6,7 +6,13 @@ import os
 import sqlite3
 import unittest
 
-from _support import IsolatedDataRoot, get_skill_root
+from _support import (
+    DEMO_ITEMS_COLUMN_METADATA,
+    DEMO_ITEMS_TABLE,
+    IsolatedDataRoot,
+    get_skill_root,
+    seed_demo_items,
+)
 
 
 class TestDisplayMetadata(unittest.TestCase):
@@ -20,14 +26,18 @@ class TestDisplayMetadata(unittest.TestCase):
             conn = get_conn()
             try:
                 cur = conn.cursor()
-                cur.execute("SELECT COUNT(*) FROM _jiangchang_tables WHERE table_name = 'task_logs'")
-                self.assertEqual(int(cur.fetchone()[0]), 1)
-                cur.execute("SELECT COUNT(*) FROM _jiangchang_columns WHERE table_name = 'task_logs'")
-                self.assertEqual(int(cur.fetchone()[0]), 10)
+                cur.execute("SELECT COUNT(*) FROM _jiangchang_tables")
+                self.assertEqual(int(cur.fetchone()[0]), 0)
+                cur.execute("SELECT COUNT(*) FROM _jiangchang_columns")
+                self.assertEqual(int(cur.fetchone()[0]), 0)
+                cur.execute(
+                    "SELECT 1 FROM sqlite_master WHERE type='table' AND name='task_logs'"
+                )
+                self.assertIsNone(cur.fetchone())
             finally:
                 conn.close()
 
-    def test_task_logs_has_chinese_table_and_column_names(self) -> None:
+    def test_demo_items_fixture_has_chinese_names(self) -> None:
         with IsolatedDataRoot():
             from db.connection import get_conn, init_db
 
@@ -35,32 +45,35 @@ class TestDisplayMetadata(unittest.TestCase):
             conn = get_conn()
             try:
                 cur = conn.cursor()
+                seed_demo_items(cur)
+                conn.commit()
                 cur.execute(
-                    "SELECT display_name, readonly FROM _jiangchang_tables WHERE table_name = 'task_logs'"
+                    "SELECT display_name, readonly FROM _jiangchang_tables WHERE table_name = ?",
+                    (DEMO_ITEMS_TABLE,),
                 )
                 display_name, readonly = cur.fetchone()
-                self.assertEqual(display_name, "任务日志")
-                self.assertEqual(int(readonly), 1)
+                self.assertEqual(display_name, "示例记录")
+                self.assertEqual(int(readonly), 0)
 
                 cur.execute(
                     """
                     SELECT column_name, display_name, editable
                     FROM _jiangchang_columns
-                    WHERE table_name = 'task_logs'
+                    WHERE table_name = ?
                     ORDER BY column_name
-                    """
+                    """,
+                    (DEMO_ITEMS_TABLE,),
                 )
                 by_name = {row[0]: (row[1], row[2]) for row in cur.fetchall()}
                 self.assertEqual(by_name["status"][0], "状态")
-                self.assertEqual(int(by_name["status"][1]), 0)
-                self.assertEqual(by_name["error_msg"][0], "错误信息")
-                self.assertEqual(int(by_name["error_msg"][1]), 0)
+                self.assertEqual(int(by_name["status"][1]), 1)
+                self.assertEqual(by_name["title"][0], "标题")
                 self.assertEqual(by_name["created_at"][0], "创建时间")
                 self.assertEqual(int(by_name["created_at"][1]), 0)
             finally:
                 conn.close()
 
-    def test_task_logs_not_manual_create_in_host_ui(self) -> None:
+    def test_readonly_table_not_manual_create_in_host_ui(self) -> None:
         with IsolatedDataRoot():
             from db.connection import get_conn, init_db
             from db.display_metadata import table_allows_manual_create
@@ -68,33 +81,34 @@ class TestDisplayMetadata(unittest.TestCase):
             init_db()
             conn = get_conn()
             try:
-                self.assertFalse(table_allows_manual_create(conn.cursor(), "task_logs"))
+                cur = conn.cursor()
+                seed_demo_items(cur, readonly=1)
+                conn.commit()
+                self.assertFalse(table_allows_manual_create(cur, DEMO_ITEMS_TABLE))
             finally:
                 conn.close()
 
-    def test_task_logs_physical_order_matches_pragma_cid(self) -> None:
+    def test_demo_items_physical_order_matches_pragma_cid(self) -> None:
         with IsolatedDataRoot():
-            from db.connection import init_db
-            from db.display_metadata import TASK_LOGS_COLUMN_METADATA, list_physical_column_names
-            from db.connection import get_conn
+            from db.connection import get_conn, init_db
+            from db.display_metadata import list_physical_column_names
 
             init_db()
             conn = get_conn()
             try:
                 cur = conn.cursor()
-                physical = list_physical_column_names(cur, "task_logs")
-                expected = [str(item["column_name"]) for item in TASK_LOGS_COLUMN_METADATA]
-                self.assertEqual(
-                    physical,
-                    expected,
-                )
-                cur.execute("PRAGMA table_info('task_logs')")
+                seed_demo_items(cur)
+                conn.commit()
+                physical = list_physical_column_names(cur, DEMO_ITEMS_TABLE)
+                expected = [str(item["column_name"]) for item in DEMO_ITEMS_COLUMN_METADATA]
+                self.assertEqual(physical, expected)
+                cur.execute("PRAGMA table_info('demo_items')")
                 cid_order = [row[1] for row in sorted(cur.fetchall(), key=lambda row: int(row[0]))]
                 self.assertEqual(cid_order, expected)
             finally:
                 conn.close()
 
-    def test_init_db_sets_task_logs_display_order_null(self) -> None:
+    def test_seed_sets_display_order_null(self) -> None:
         with IsolatedDataRoot():
             from db.connection import get_conn, init_db
 
@@ -102,12 +116,15 @@ class TestDisplayMetadata(unittest.TestCase):
             conn = get_conn()
             try:
                 cur = conn.cursor()
+                seed_demo_items(cur)
+                conn.commit()
                 cur.execute(
                     """
                     SELECT column_name, display_order
                     FROM _jiangchang_columns
-                    WHERE table_name = 'task_logs'
-                    """
+                    WHERE table_name = ?
+                    """,
+                    (DEMO_ITEMS_TABLE,),
                 )
                 for column_name, display_order in cur.fetchall():
                     self.assertIsNone(
@@ -117,33 +134,32 @@ class TestDisplayMetadata(unittest.TestCase):
             finally:
                 conn.close()
 
-    def test_reinit_clears_stale_display_order(self) -> None:
+    def test_reseed_clears_stale_display_order(self) -> None:
         with IsolatedDataRoot():
             from db.connection import get_conn, init_db
 
             init_db()
             conn = get_conn()
             try:
+                cur = conn.cursor()
+                seed_demo_items(cur)
                 conn.execute(
                     """
                     UPDATE _jiangchang_columns
                     SET display_order = 99
-                    WHERE table_name = 'task_logs' AND column_name = 'id'
-                    """
+                    WHERE table_name = ? AND column_name = 'id'
+                    """,
+                    (DEMO_ITEMS_TABLE,),
                 )
                 conn.commit()
-            finally:
-                conn.close()
-
-            init_db()
-            conn = get_conn()
-            try:
-                cur = conn.cursor()
+                seed_demo_items(cur)
+                conn.commit()
                 cur.execute(
                     """
                     SELECT display_order FROM _jiangchang_columns
-                    WHERE table_name = 'task_logs' AND column_name = 'id'
-                    """
+                    WHERE table_name = ? AND column_name = 'id'
+                    """,
+                    (DEMO_ITEMS_TABLE,),
                 )
                 self.assertIsNone(cur.fetchone()[0])
             finally:
@@ -158,22 +174,26 @@ class TestDisplayMetadata(unittest.TestCase):
             conn = get_conn()
             try:
                 cur = conn.cursor()
+                seed_demo_items(cur)
+                conn.commit()
                 cur.execute(
                     """
                     UPDATE _jiangchang_columns
                     SET display_order = 1
-                    WHERE table_name = 'task_logs' AND column_name = 'updated_at'
-                    """
+                    WHERE table_name = ? AND column_name = 'updated_at'
+                    """,
+                    (DEMO_ITEMS_TABLE,),
                 )
                 cur.execute(
                     """
                     UPDATE _jiangchang_columns
                     SET display_order = 99
-                    WHERE table_name = 'task_logs' AND column_name = 'id'
-                    """
+                    WHERE table_name = ? AND column_name = 'id'
+                    """,
+                    (DEMO_ITEMS_TABLE,),
                 )
                 conn.commit()
-                physical = list_physical_column_names(cur, "task_logs")
+                physical = list_physical_column_names(cur, DEMO_ITEMS_TABLE)
                 self.assertEqual(physical[0], "id")
                 self.assertEqual(physical[-1], "updated_at")
             finally:
@@ -188,7 +208,7 @@ class TestDisplayMetadata(unittest.TestCase):
             conn = get_conn()
             try:
                 tables = list(iter_user_tables(conn.cursor()))
-                self.assertEqual(tables, ["task_logs"])
+                self.assertEqual(tables, [])
             finally:
                 conn.close()
 
@@ -271,13 +291,15 @@ class TestDisplayMetadata(unittest.TestCase):
             init_db()
             conn = get_conn()
             try:
+                seed_demo_items(conn.cursor())
                 conn.execute(
-                    "DELETE FROM _jiangchang_columns WHERE table_name = 'task_logs' AND column_name = 'status'"
+                    "DELETE FROM _jiangchang_columns WHERE table_name = ? AND column_name = 'status'",
+                    (DEMO_ITEMS_TABLE,),
                 )
                 conn.commit()
                 report = validate_display_metadata(conn)
                 self.assertFalse(report.ok)
-                self.assertTrue(any("task_logs.status" in err for err in report.errors))
+                self.assertTrue(any("demo_items.status" in err for err in report.errors))
             finally:
                 conn.close()
 
@@ -289,12 +311,14 @@ class TestDisplayMetadata(unittest.TestCase):
             init_db()
             conn = get_conn()
             try:
+                seed_demo_items(conn.cursor())
                 conn.execute(
                     """
                     INSERT INTO _jiangchang_columns
                     (table_name, column_name, display_name, visible, searchable, editable)
-                    VALUES ('task_logs', 'not_exists', '不存在', 1, 1, 1)
-                    """
+                    VALUES (?, 'not_exists', '不存在', 1, 1, 1)
+                    """,
+                    (DEMO_ITEMS_TABLE,),
                 )
                 conn.commit()
                 report = validate_display_metadata(conn)
@@ -498,12 +522,11 @@ metadata:
         finally:
             conn.close()
 
-    def test_schema_md_documents_task_logs_readonly_semantics(self) -> None:
+    def test_schema_md_documents_readonly_and_seed_helpers(self) -> None:
         path = os.path.join(get_skill_root(), "references", "SCHEMA.md")
         with open(path, encoding="utf-8") as f:
             text = f.read()
         self.assertIn("readonly = 1", text)
-        self.assertIn("task_logs", text)
         self.assertIn("seed_column_metadata_batch", text)
         self.assertIn("valid_column_names", text)