更新

backend/tests/test_account_pagination.py

@@ -5,7 +5,7 @@ import sys
 import unittest
 from pathlib import Path
 from types import SimpleNamespace
-from unittest.mock import AsyncMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
 
 from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
 from sqlalchemy.orm import sessionmaker
@@ -20,7 +20,7 @@ if str(BACKEND_DIR) not in sys.path:
 
 import main
 from models.database import Base
-from models.models import Account
+from models.models import Account, MessageLog
 
 
 class _CountResult:
@@ -43,6 +43,160 @@ class _RowsResult:
 
 
 class AccountPaginationTests(unittest.IsolatedAsyncioTestCase):
+    async def test_legacy_cookie_sync_only_reads_accounts_missing_db_cookie(self):
+        engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+        async with engine.begin() as connection:
+            await connection.run_sync(Base.metadata.create_all)
+        session_factory = sessionmaker(
+            engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+        )
+        try:
+            async with session_factory() as db:
+                db.add_all(
+                    [
+                        Account(
+                            id=2301,
+                            username="already-in-db",
+                            cookie_data='{"cookies": [{"value": "large"}]}',
+                            im_session_data="x" * 100_000,
+                        ),
+                        Account(id=2302, username="legacy-file", cookie_data=None),
+                    ]
+                )
+                await db.commit()
+
+            def read_cookie(account_id: int):
+                self.assertEqual(account_id, 2302)
+                return '{"cookies": [{"value": "migrated"}]}'
+
+            with (
+                patch.object(main, "AsyncSessionLocal", session_factory),
+                patch.object(main, "read_cookie_file", side_effect=read_cookie) as read_file,
+                patch.object(main, "get_cookie_path", return_value="legacy-2302.json"),
+            ):
+                await main._sync_legacy_cookie_files()
+
+            read_file.assert_called_once_with(2302)
+            async with session_factory() as db:
+                migrated = await db.get(Account, 2302)
+                self.assertEqual(
+                    migrated.cookie_data,
+                    '{"cookies": [{"value": "migrated"}]}',
+                )
+                self.assertEqual(migrated.cookie_path, "legacy-2302.json")
+        finally:
+            await engine.dispose()
+
+    async def test_account_edit_invalidates_running_follow_config_cache(self):
+        account = SimpleNamespace(id=2201)
+        db = SimpleNamespace(commit=AsyncMock(), refresh=AsyncMock())
+        worker = SimpleNamespace(invalidate_follow_welcome_config=MagicMock())
+        original_workers = main.manager.workers
+        main.manager.workers = {2201: worker}
+        try:
+            with (
+                patch.object(main, "get_owned_account", AsyncMock(return_value=account)),
+                patch.object(main, "_build_account_response", return_value={"id": 2201}),
+            ):
+                response = await main.update_account(
+                    account_id=2201,
+                    body=main.AccountUpdate(follow_welcome_enabled=True),
+                    db=db,
+                    user=SimpleNamespace(id=7, role="operator"),
+                )
+
+            self.assertEqual(response, {"id": 2201})
+            worker.invalidate_follow_welcome_config.assert_called_once_with()
+        finally:
+            main.manager.workers = original_workers
+
+    async def test_log_stats_uses_one_aggregate_and_respects_ownership(self):
+        engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+        async with engine.begin() as connection:
+            await connection.run_sync(Base.metadata.create_all)
+        session_factory = sessionmaker(
+            engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+        )
+        try:
+            async with session_factory() as db:
+                db.add_all(
+                    [
+                        Account(id=2101, owner_id=7, status="offline"),
+                        Account(id=2102, owner_id=8, status="offline"),
+                        MessageLog(account_id=2101, status="received"),
+                        MessageLog(account_id=2101, status="replied"),
+                        MessageLog(account_id=2102, status="replied"),
+                    ]
+                )
+                await db.commit()
+
+                with patch.object(db, "execute", wraps=db.execute) as execute:
+                    stats = await main.get_logs_stats(
+                        account_id=None,
+                        db=db,
+                        user=SimpleNamespace(id=7, role="user"),
+                    )
+
+            self.assertEqual(stats, {"total": 2, "replied": 1})
+            self.assertEqual(execute.await_count, 1)
+        finally:
+            await engine.dispose()
+
+    async def test_account_options_returns_lightweight_runtime_fields(self):
+        engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+        async with engine.begin() as connection:
+            await connection.run_sync(Base.metadata.create_all)
+        session_factory = sessionmaker(
+            engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+        )
+        original_workers = main.manager.workers
+        main.manager.workers = {2001: SimpleNamespace(is_running=True)}
+        try:
+            async with session_factory() as db:
+                db.add_all(
+                    [
+                        Account(
+                            id=2001,
+                            owner_id=7,
+                            username="owned",
+                            status="offline",
+                            cookie_data='{"cookies": []}',
+                            im_session_data="x" * 100_000,
+                            reply_cooldown_seconds=12,
+                        ),
+                        Account(
+                            id=2002,
+                            owner_id=8,
+                            username="other",
+                            status="online",
+                            cookie_data='{"cookies": []}',
+                        ),
+                    ]
+                )
+                await db.commit()
+
+                options = await main.get_account_options(
+                    db=db,
+                    user=SimpleNamespace(id=7, role="user"),
+                )
+
+            self.assertEqual(len(options), 1)
+            self.assertEqual(options[0].id, 2001)
+            self.assertEqual(options[0].status, "online")
+            self.assertTrue(options[0].has_cookie)
+            self.assertEqual(options[0].reply_cooldown_seconds, 12)
+            self.assertEqual(options[0].reply_cooldown_effective, 12)
+            self.assertFalse(hasattr(options[0], "im_session_data"))
+        finally:
+            main.manager.workers = original_workers
+            await engine.dispose()
+
     async def test_paginated_list_counts_then_loads_only_current_page(self):
         page_rows = [
             SimpleNamespace(id=10, status="offline"),