fix: use synchronous getByText assertion while in fake timer mode before restoring real timers

Co-authored-by: hyoban <[email protected]>

.github/workflows/web-tests.yml

@@ -39,7 +39,7 @@ jobs:
         run: pnpm install --frozen-lockfile
 
       - name: Run tests
-        run: pnpm test:ci
+        run: pnpm test:coverage
 
       - name: Coverage Summary
         if: always()

api/.env.example

@@ -715,6 +715,5 @@ ANNOTATION_IMPORT_MAX_CONCURRENT=5
 # Sandbox expired records clean configuration
 SANDBOX_EXPIRED_RECORDS_CLEAN_GRACEFUL_PERIOD=21
 SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_SIZE=1000
-SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_MAX_INTERVAL=200
 SANDBOX_EXPIRED_RECORDS_RETENTION_DAYS=30
 SANDBOX_EXPIRED_RECORDS_CLEAN_TASK_LOCK_TTL=90000

api/configs/feature/__init__.py

@@ -1309,10 +1309,6 @@ class SandboxExpiredRecordsCleanConfig(BaseSettings):
         description="Maximum number of records to process in each batch",
         default=1000,
     )
-    SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_MAX_INTERVAL: PositiveInt = Field(
-        description="Maximum interval in milliseconds between batches",
-        default=200,
-    )
     SANDBOX_EXPIRED_RECORDS_RETENTION_DAYS: PositiveInt = Field(
         description="Retention days for sandbox expired workflow_run records and message records",
         default=30,

api/models/model.py

@@ -1038,6 +1038,7 @@ class Message(Base):
         Index("message_end_user_idx", "app_id", "from_source", "from_end_user_id"),
         Index("message_account_idx", "app_id", "from_source", "from_account_id"),
         Index("message_workflow_run_id_idx", "conversation_id", "workflow_run_id"),
+        Index("message_created_at_idx", "created_at"),
         Index("message_app_mode_idx", "app_mode"),
         Index("message_created_at_id_idx", "created_at", "id"),
     )

api/models/web.py

@@ -16,7 +16,6 @@ class SavedMessage(TypeBase):
     __table_args__ = (
         sa.PrimaryKeyConstraint("id", name="saved_message_pkey"),
         sa.Index("saved_message_message_idx", "app_id", "message_id", "created_by_role", "created_by"),
-        sa.Index("saved_message_message_id_idx", "message_id"),
     )
 
     id: Mapped[str] = mapped_column(

api/services/account_service.py

@@ -327,17 +327,6 @@ class AccountService:
     @staticmethod
     def delete_account(account: Account):
         """Delete account. This method only adds a task to the queue for deletion."""
-        # Queue account deletion sync tasks for all workspaces BEFORE account deletion (enterprise only)
-        from services.enterprise.account_deletion_sync import sync_account_deletion
-
-        sync_success = sync_account_deletion(account_id=account.id, source="account_deleted")
-        if not sync_success:
-            logger.warning(
-                "Enterprise account deletion sync failed for account %s; proceeding with local deletion.",
-                account.id,
-            )
-
-        # Now proceed with async account deletion
         delete_account_task.delay(account.id)
 
     @staticmethod
@@ -1241,19 +1230,6 @@ class TenantService:
         if dify_config.BILLING_ENABLED:
             BillingService.clean_billing_info_cache(tenant.id)
 
-        # Queue account deletion sync task for enterprise backend to reassign resources (enterprise only)
-        from services.enterprise.account_deletion_sync import sync_workspace_member_removal
-
-        sync_success = sync_workspace_member_removal(
-            workspace_id=tenant.id, member_id=account.id, source="workspace_member_removed"
-        )
-        if not sync_success:
-            logger.warning(
-                "Enterprise workspace member removal sync failed: workspace_id=%s, member_id=%s",
-                tenant.id,
-                account.id,
-            )
-
     @staticmethod
     def update_member_role(tenant: Tenant, member: Account, new_role: str, operator: Account):
         """Update member role"""

api/services/enterprise/account_deletion_sync.py

@@ -1,115 +0,0 @@
-import json
-import logging
-import uuid
-from datetime import UTC, datetime
-
-from redis import RedisError
-
-from configs import dify_config
-from extensions.ext_database import db
-from extensions.ext_redis import redis_client
-from models.account import TenantAccountJoin
-
-logger = logging.getLogger(__name__)
-
-ACCOUNT_DELETION_SYNC_QUEUE = "enterprise:member:sync:queue"
-ACCOUNT_DELETION_SYNC_TASK_TYPE = "sync_member_deletion_from_workspace"
-
-
-def _queue_task(workspace_id: str, member_id: str, *, source: str) -> bool:
-    """
-    Queue an account deletion sync task to Redis.
-
-    Internal helper function. Do not call directly - use the public functions instead.
-
-    Args:
-        workspace_id: The workspace/tenant ID to sync
-        member_id: The member/account ID that was removed
-        source: Source of the sync request (for debugging/tracking)
-
-    Returns:
-        bool: True if task was queued successfully, False otherwise
-    """
-    try:
-        task = {
-            "task_id": str(uuid.uuid4()),
-            "workspace_id": workspace_id,
-            "member_id": member_id,
-            "retry_count": 0,
-            "created_at": datetime.now(UTC).isoformat(),
-            "source": source,
-            "type": ACCOUNT_DELETION_SYNC_TASK_TYPE,
-        }
-
-        # Push to Redis list (queue) - LPUSH adds to the head, worker consumes from tail with RPOP
-        redis_client.lpush(ACCOUNT_DELETION_SYNC_QUEUE, json.dumps(task))
-
-        logger.info(
-            "Queued account deletion sync task for workspace %s, member %s, task_id: %s, source: %s",
-            workspace_id,
-            member_id,
-            task["task_id"],
-            source,
-        )
-        return True
-
-    except (RedisError, TypeError) as e:
-        logger.error(
-            "Failed to queue account deletion sync for workspace %s, member %s: %s",
-            workspace_id,
-            member_id,
-            str(e),
-            exc_info=True,
-        )
-        # Don't raise - we don't want to fail member deletion if queueing fails
-        return False
-
-
-def sync_workspace_member_removal(workspace_id: str, member_id: str, *, source: str) -> bool:
-    """
-    Sync a single workspace member removal (enterprise only).
-
-    Queues a task for the enterprise backend to reassign resources from the removed member.
-    Handles enterprise edition check internally. Safe to call in community edition (no-op).
-
-    Args:
-        workspace_id: The workspace/tenant ID
-        member_id: The member/account ID that was removed
-        source: Source of the sync request (e.g., "workspace_member_removed")
-
-    Returns:
-        bool: True if task was queued (or skipped in community), False if queueing failed
-    """
-    if not dify_config.ENTERPRISE_ENABLED:
-        return True
-
-    return _queue_task(workspace_id=workspace_id, member_id=member_id, source=source)
-
-
-def sync_account_deletion(account_id: str, *, source: str) -> bool:
-    """
-    Sync full account deletion across all workspaces (enterprise only).
-
-    Fetches all workspace memberships for the account and queues a sync task for each.
-    Handles enterprise edition check internally. Safe to call in community edition (no-op).
-
-    Args:
-        account_id: The account ID being deleted
-        source: Source of the sync request (e.g., "account_deleted")
-
-    Returns:
-        bool: True if all tasks were queued (or skipped in community), False if any queueing failed
-    """
-    if not dify_config.ENTERPRISE_ENABLED:
-        return True
-
-    # Fetch all workspaces the account belongs to
-    workspace_joins = db.session.query(TenantAccountJoin).filter_by(account_id=account_id).all()
-
-    # Queue sync task for each workspace
-    success = True
-    for join in workspace_joins:
-        if not _queue_task(workspace_id=join.tenant_id, member_id=account_id, source=source):
-            success = False
-
-    return success

api/services/retention/conversation/messages_clean_service.py

@@ -1,12 +1,10 @@
 import datetime
 import logging
-import os
 import random
-import time
 from collections.abc import Sequence
 from typing import cast
 
-from sqlalchemy import delete, select, tuple_
+from sqlalchemy import delete, select
 from sqlalchemy.engine import CursorResult
 from sqlalchemy.orm import Session
 
@@ -195,15 +193,11 @@ class MessagesCleanService:
             self._end_before,
         )
 
-        max_batch_interval_ms = int(os.environ.get("SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_MAX_INTERVAL", 200))
-
         while True:
             stats["batches"] += 1
-            batch_start = time.monotonic()
 
             # Step 1: Fetch a batch of messages using cursor
             with Session(db.engine, expire_on_commit=False) as session:
-                fetch_messages_start = time.monotonic()
                 msg_stmt = (
                     select(Message.id, Message.app_id, Message.created_at)
                     .where(Message.created_at < self._end_before)
@@ -215,9 +209,13 @@ class MessagesCleanService:
                     msg_stmt = msg_stmt.where(Message.created_at >= self._start_from)
 
                 # Apply cursor condition: (created_at, id) > (last_created_at, last_message_id)
+                # This translates to:
+                #   created_at > last_created_at OR (created_at = last_created_at AND id > last_message_id)
                 if _cursor:
+                    # Continuing from previous batch
                     msg_stmt = msg_stmt.where(
-                        tuple_(Message.created_at, Message.id) > tuple_(_cursor[0], _cursor[1])
+                        (Message.created_at > _cursor[0])
+                        | ((Message.created_at == _cursor[0]) & (Message.id > _cursor[1]))
                     )
 
                 raw_messages = list(session.execute(msg_stmt).all())
@@ -225,12 +223,6 @@ class MessagesCleanService:
                     SimpleMessage(id=msg_id, app_id=app_id, created_at=msg_created_at)
                     for msg_id, app_id, msg_created_at in raw_messages
                 ]
-                logger.info(
-                    "clean_messages (batch %s): fetched %s messages in %sms",
-                    stats["batches"],
-                    len(messages),
-                    int((time.monotonic() - fetch_messages_start) * 1000),
-                )
 
                 # Track total messages fetched across all batches
                 stats["total_messages"] += len(messages)
@@ -249,16 +241,8 @@ class MessagesCleanService:
                     logger.info("clean_messages (batch %s): no app_ids found, skip", stats["batches"])
                     continue
 
-                fetch_apps_start = time.monotonic()
                 app_stmt = select(App.id, App.tenant_id).where(App.id.in_(app_ids))
                 apps = list(session.execute(app_stmt).all())
-                logger.info(
-                    "clean_messages (batch %s): fetched %s apps for %s app_ids in %sms",
-                    stats["batches"],
-                    len(apps),
-                    len(app_ids),
-                    int((time.monotonic() - fetch_apps_start) * 1000),
-                )
 
             if not apps:
                 logger.info("clean_messages (batch %s): no apps found, skip", stats["batches"])
@@ -268,15 +252,7 @@ class MessagesCleanService:
             app_to_tenant: dict[str, str] = {app.id: app.tenant_id for app in apps}
 
             # Step 3: Delegate to policy to determine which messages to delete
-            policy_start = time.monotonic()
             message_ids_to_delete = self._policy.filter_message_ids(messages, app_to_tenant)
-            logger.info(
-                "clean_messages (batch %s): policy selected %s/%s messages in %sms",
-                stats["batches"],
-                len(message_ids_to_delete),
-                len(messages),
-                int((time.monotonic() - policy_start) * 1000),
-            )
 
             if not message_ids_to_delete:
                 logger.info("clean_messages (batch %s): no messages to delete, skip", stats["batches"])
@@ -287,20 +263,14 @@ class MessagesCleanService:
             # Step 4: Batch delete messages and their relations
             if not self._dry_run:
                 with Session(db.engine, expire_on_commit=False) as session:
-                    delete_relations_start = time.monotonic()
                     # Delete related records first
                     self._batch_delete_message_relations(session, message_ids_to_delete)
-                    delete_relations_ms = int((time.monotonic() - delete_relations_start) * 1000)
 
                     # Delete messages
-                    delete_messages_start = time.monotonic()
                     delete_stmt = delete(Message).where(Message.id.in_(message_ids_to_delete))
                     delete_result = cast(CursorResult, session.execute(delete_stmt))
                     messages_deleted = delete_result.rowcount
-                    delete_messages_ms = int((time.monotonic() - delete_messages_start) * 1000)
-                    commit_start = time.monotonic()
                     session.commit()
-                    commit_ms = int((time.monotonic() - commit_start) * 1000)
 
                     stats["total_deleted"] += messages_deleted
 
@@ -310,19 +280,6 @@ class MessagesCleanService:
                         len(messages),
                         messages_deleted,
                     )
-                    logger.info(
-                        "clean_messages (batch %s): relations %sms,  messages %sms, commit %sms, batch total %sms",
-                        stats["batches"],
-                        delete_relations_ms,
-                        delete_messages_ms,
-                        commit_ms,
-                        int((time.monotonic() - batch_start) * 1000),
-                    )
-
-                # Random sleep between batches to avoid overwhelming the database
-                sleep_ms = random.uniform(0, max_batch_interval_ms)  # noqa: S311
-                logger.info("clean_messages (batch %s): sleeping for %.2fms", stats["batches"], sleep_ms)
-                time.sleep(sleep_ms / 1000)
             else:
                 # Log random sample of message IDs that would be deleted (up to 10)
                 sample_size = min(10, len(message_ids_to_delete))

api/services/retention/workflow_run/clear_free_plan_expired_workflow_run_logs.py

@@ -1,8 +1,5 @@
 import datetime
 import logging
-import os
-import random
-import time
 from collections.abc import Iterable, Sequence
 
 import click
@@ -75,12 +72,7 @@ class WorkflowRunCleanup:
         batch_index = 0
         last_seen: tuple[datetime.datetime, str] | None = None
 
-        max_batch_interval_ms = int(os.environ.get("SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_MAX_INTERVAL", 200))
-
         while True:
-            batch_start = time.monotonic()
-
-            fetch_start = time.monotonic()
             run_rows = self.workflow_run_repo.get_runs_batch_by_time_range(
                 start_from=self.window_start,
                 end_before=self.window_end,
@@ -88,30 +80,12 @@ class WorkflowRunCleanup:
                 batch_size=self.batch_size,
             )
             if not run_rows:
-                logger.info("workflow_run_cleanup (batch #%s): no more rows to process", batch_index + 1)
                 break
 
             batch_index += 1
             last_seen = (run_rows[-1].created_at, run_rows[-1].id)
-            logger.info(
-                "workflow_run_cleanup (batch #%s): fetched %s rows in %sms",
-                batch_index,
-                len(run_rows),
-                int((time.monotonic() - fetch_start) * 1000),
-            )
-
             tenant_ids = {row.tenant_id for row in run_rows}
-
-            filter_start = time.monotonic()
             free_tenants = self._filter_free_tenants(tenant_ids)
-            logger.info(
-                "workflow_run_cleanup (batch #%s): filtered %s free tenants from %s tenants in %sms",
-                batch_index,
-                len(free_tenants),
-                len(tenant_ids),
-                int((time.monotonic() - filter_start) * 1000),
-            )
-
             free_runs = [row for row in run_rows if row.tenant_id in free_tenants]
             paid_or_skipped = len(run_rows) - len(free_runs)
 
@@ -130,17 +104,11 @@ class WorkflowRunCleanup:
             total_runs_targeted += len(free_runs)
 
             if self.dry_run:
-                count_start = time.monotonic()
                 batch_counts = self.workflow_run_repo.count_runs_with_related(
                     free_runs,
                     count_node_executions=self._count_node_executions,
                     count_trigger_logs=self._count_trigger_logs,
                 )
-                logger.info(
-                    "workflow_run_cleanup (batch #%s, dry_run): counted related records in %sms",
-                    batch_index,
-                    int((time.monotonic() - count_start) * 1000),
-                )
                 if related_totals is not None:
                     for key in related_totals:
                         related_totals[key] += batch_counts.get(key, 0)
@@ -152,21 +120,14 @@ class WorkflowRunCleanup:
                         fg="yellow",
                     )
                 )
-                logger.info(
-                    "workflow_run_cleanup (batch #%s, dry_run): batch total %sms",
-                    batch_index,
-                    int((time.monotonic() - batch_start) * 1000),
-                )
                 continue
 
             try:
-                delete_start = time.monotonic()
                 counts = self.workflow_run_repo.delete_runs_with_related(
                     free_runs,
                     delete_node_executions=self._delete_node_executions,
                     delete_trigger_logs=self._delete_trigger_logs,
                 )
-                delete_ms = int((time.monotonic() - delete_start) * 1000)
             except Exception:
                 logger.exception("Failed to delete workflow runs batch ending at %s", last_seen[0])
                 raise
@@ -182,17 +143,6 @@ class WorkflowRunCleanup:
                     fg="green",
                 )
             )
-            logger.info(
-                "workflow_run_cleanup (batch #%s): delete %sms, batch total %sms",
-                batch_index,
-                delete_ms,
-                int((time.monotonic() - batch_start) * 1000),
-            )
-
-            # Random sleep between batches to avoid overwhelming the database
-            sleep_ms = random.uniform(0, max_batch_interval_ms)  # noqa: S311
-            logger.info("workflow_run_cleanup (batch #%s): sleeping for %.2fms", batch_index, sleep_ms)
-            time.sleep(sleep_ms / 1000)
 
         if self.dry_run:
             if self.window_start:

api/tasks/document_indexing_update_task.py

@@ -8,6 +8,7 @@ from sqlalchemy import delete, select
 from core.db.session_factory import session_factory
 from core.indexing_runner import DocumentIsPausedError, IndexingRunner
 from core.rag.index_processor.index_processor_factory import IndexProcessorFactory
+from extensions.ext_database import db
 from libs.datetime_utils import naive_utc_now
 from models.dataset import Dataset, Document, DocumentSegment
 
@@ -26,7 +27,7 @@ def document_indexing_update_task(dataset_id: str, document_id: str):
     logger.info(click.style(f"Start update document: {document_id}", fg="green"))
     start_at = time.perf_counter()
 
-    with session_factory.create_session() as session, session.begin():
+    with session_factory.create_session() as session:
         document = session.query(Document).where(Document.id == document_id, Document.dataset_id == dataset_id).first()
 
         if not document:
@@ -35,6 +36,7 @@ def document_indexing_update_task(dataset_id: str, document_id: str):
 
         document.indexing_status = "parsing"
         document.processing_started_at = naive_utc_now()
+        session.commit()
 
         # delete all document segment and index
         try:
@@ -54,7 +56,7 @@ def document_indexing_update_task(dataset_id: str, document_id: str):
                 segment_ids = [segment.id for segment in segments]
                 segment_delete_stmt = delete(DocumentSegment).where(DocumentSegment.id.in_(segment_ids))
                 session.execute(segment_delete_stmt)
-
+                db.session.commit()
             end_at = time.perf_counter()
             logger.info(
                 click.style(

api/tests/test_containers_integration_tests/services/test_account_service.py

@@ -1016,7 +1016,7 @@ class TestAccountService:
 
     def test_delete_account(self, db_session_with_containers, mock_external_service_dependencies):
         """
-        Test account deletion (should add task to queue and sync to enterprise).
+        Test account deletion (should add task to queue).
         """
         fake = Faker()
         email = fake.email()
@@ -1034,18 +1034,10 @@ class TestAccountService:
             password=password,
         )
 
-        with (
-            patch("services.account_service.delete_account_task") as mock_delete_task,
-            patch("services.enterprise.account_deletion_sync.sync_account_deletion") as mock_sync,
-        ):
-            mock_sync.return_value = True
-
+        with patch("services.account_service.delete_account_task") as mock_delete_task:
             # Delete account
             AccountService.delete_account(account)
 
-            # Verify sync was called
-            mock_sync.assert_called_once_with(account_id=account.id, source="account_deleted")
-
             # Verify task was added to queue
             mock_delete_task.delay.assert_called_once_with(account.id)
 
@@ -1724,7 +1716,7 @@ class TestTenantService:
 
     def test_remove_member_from_tenant_success(self, db_session_with_containers, mock_external_service_dependencies):
         """
-        Test successful member removal from tenant (should sync to enterprise).
+        Test successful member removal from tenant.
         """
         fake = Faker()
         tenant_name = fake.company()
@@ -1759,15 +1751,7 @@ class TestTenantService:
         TenantService.create_tenant_member(tenant, member_account, role="normal")
 
         # Remove member
-        with patch("services.enterprise.account_deletion_sync.sync_workspace_member_removal") as mock_sync:
-            mock_sync.return_value = True
-
-            TenantService.remove_member_from_tenant(tenant, member_account, owner_account)
-
-            # Verify sync was called
-            mock_sync.assert_called_once_with(
-                workspace_id=tenant.id, member_id=member_account.id, source="workspace_member_removed"
-            )
+        TenantService.remove_member_from_tenant(tenant, member_account, owner_account)
 
         # Verify member was removed
         from extensions.ext_database import db

api/tests/test_containers_integration_tests/tasks/test_document_indexing_update_task.py

@@ -1,182 +0,0 @@
-from unittest.mock import MagicMock, patch
-
-import pytest
-from faker import Faker
-
-from models import Account, Tenant, TenantAccountJoin, TenantAccountRole
-from models.dataset import Dataset, Document, DocumentSegment
-from tasks.document_indexing_update_task import document_indexing_update_task
-
-
-class TestDocumentIndexingUpdateTask:
-    @pytest.fixture
-    def mock_external_dependencies(self):
-        """Patch external collaborators used by the update task.
-        - IndexProcessorFactory.init_index_processor().clean(...)
-        - IndexingRunner.run([...])
-        """
-        with (
-            patch("tasks.document_indexing_update_task.IndexProcessorFactory") as mock_factory,
-            patch("tasks.document_indexing_update_task.IndexingRunner") as mock_runner,
-        ):
-            processor_instance = MagicMock()
-            mock_factory.return_value.init_index_processor.return_value = processor_instance
-
-            runner_instance = MagicMock()
-            mock_runner.return_value = runner_instance
-
-            yield {
-                "factory": mock_factory,
-                "processor": processor_instance,
-                "runner": mock_runner,
-                "runner_instance": runner_instance,
-            }
-
-    def _create_dataset_document_with_segments(self, db_session_with_containers, *, segment_count: int = 2):
-        fake = Faker()
-
-        # Account and tenant
-        account = Account(
-            email=fake.email(),
-            name=fake.name(),
-            interface_language="en-US",
-            status="active",
-        )
-        db_session_with_containers.add(account)
-        db_session_with_containers.commit()
-
-        tenant = Tenant(name=fake.company(), status="normal")
-        db_session_with_containers.add(tenant)
-        db_session_with_containers.commit()
-
-        join = TenantAccountJoin(
-            tenant_id=tenant.id,
-            account_id=account.id,
-            role=TenantAccountRole.OWNER,
-            current=True,
-        )
-        db_session_with_containers.add(join)
-        db_session_with_containers.commit()
-
-        # Dataset and document
-        dataset = Dataset(
-            tenant_id=tenant.id,
-            name=fake.company(),
-            description=fake.text(max_nb_chars=64),
-            data_source_type="upload_file",
-            indexing_technique="high_quality",
-            created_by=account.id,
-        )
-        db_session_with_containers.add(dataset)
-        db_session_with_containers.commit()
-
-        document = Document(
-            tenant_id=tenant.id,
-            dataset_id=dataset.id,
-            position=0,
-            data_source_type="upload_file",
-            batch="test_batch",
-            name=fake.file_name(),
-            created_from="upload_file",
-            created_by=account.id,
-            indexing_status="waiting",
-            enabled=True,
-            doc_form="text_model",
-        )
-        db_session_with_containers.add(document)
-        db_session_with_containers.commit()
-
-        # Segments
-        node_ids = []
-        for i in range(segment_count):
-            node_id = f"node-{i + 1}"
-            seg = DocumentSegment(
-                tenant_id=tenant.id,
-                dataset_id=dataset.id,
-                document_id=document.id,
-                position=i,
-                content=fake.text(max_nb_chars=32),
-                answer=None,
-                word_count=10,
-                tokens=5,
-                index_node_id=node_id,
-                status="completed",
-                created_by=account.id,
-            )
-            db_session_with_containers.add(seg)
-            node_ids.append(node_id)
-        db_session_with_containers.commit()
-
-        # Refresh to ensure ORM state
-        db_session_with_containers.refresh(dataset)
-        db_session_with_containers.refresh(document)
-
-        return dataset, document, node_ids
-
-    def test_cleans_segments_and_reindexes(self, db_session_with_containers, mock_external_dependencies):
-        dataset, document, node_ids = self._create_dataset_document_with_segments(db_session_with_containers)
-
-        # Act
-        document_indexing_update_task(dataset.id, document.id)
-
-        # Ensure we see committed changes from another session
-        db_session_with_containers.expire_all()
-
-        # Assert document status updated before reindex
-        updated = db_session_with_containers.query(Document).where(Document.id == document.id).first()
-        assert updated.indexing_status == "parsing"
-        assert updated.processing_started_at is not None
-
-        # Segments should be deleted
-        remaining = (
-            db_session_with_containers.query(DocumentSegment).where(DocumentSegment.document_id == document.id).count()
-        )
-        assert remaining == 0
-
-        # Assert index processor clean was called with expected args
-        clean_call = mock_external_dependencies["processor"].clean.call_args
-        assert clean_call is not None
-        args, kwargs = clean_call
-        # args[0] is a Dataset instance (from another session) — validate by id
-        assert getattr(args[0], "id", None) == dataset.id
-        # args[1] should contain our node_ids
-        assert set(args[1]) == set(node_ids)
-        assert kwargs.get("with_keywords") is True
-        assert kwargs.get("delete_child_chunks") is True
-
-        # Assert indexing runner invoked with the updated document
-        run_call = mock_external_dependencies["runner_instance"].run.call_args
-        assert run_call is not None
-        run_docs = run_call[0][0]
-        assert len(run_docs) == 1
-        first = run_docs[0]
-        assert getattr(first, "id", None) == document.id
-
-    def test_clean_error_is_logged_and_indexing_continues(self, db_session_with_containers, mock_external_dependencies):
-        dataset, document, node_ids = self._create_dataset_document_with_segments(db_session_with_containers)
-
-        # Force clean to raise; task should continue to indexing
-        mock_external_dependencies["processor"].clean.side_effect = Exception("boom")
-
-        document_indexing_update_task(dataset.id, document.id)
-
-        # Ensure we see committed changes from another session
-        db_session_with_containers.expire_all()
-
-        # Indexing should still be triggered
-        mock_external_dependencies["runner_instance"].run.assert_called_once()
-
-        # Segments should remain (since clean failed before DB delete)
-        remaining = (
-            db_session_with_containers.query(DocumentSegment).where(DocumentSegment.document_id == document.id).count()
-        )
-        assert remaining > 0
-
-    def test_document_not_found_noop(self, db_session_with_containers, mock_external_dependencies):
-        fake = Faker()
-        # Act with non-existent document id
-        document_indexing_update_task(dataset_id=fake.uuid4(), document_id=fake.uuid4())
-
-        # Neither processor nor runner should be called
-        mock_external_dependencies["processor"].clean.assert_not_called()
-        mock_external_dependencies["runner_instance"].run.assert_not_called()

api/tests/unit_tests/services/enterprise/test_account_deletion_sync.py

@@ -1,276 +0,0 @@
-"""Unit tests for account deletion synchronization.
-
-This test module verifies the enterprise account deletion sync functionality,
-including Redis queuing, error handling, and community vs enterprise behavior.
-"""
-
-from unittest.mock import MagicMock, patch
-
-import pytest
-from redis import RedisError
-
-from services.enterprise.account_deletion_sync import (
-    _queue_task,
-    sync_account_deletion,
-    sync_workspace_member_removal,
-)
-
-
-class TestQueueTask:
-    """Unit tests for the _queue_task helper function."""
-
-    @pytest.fixture
-    def mock_redis_client(self):
-        """Mock redis_client for testing."""
-        with patch("services.enterprise.account_deletion_sync.redis_client") as mock_redis:
-            yield mock_redis
-
-    @pytest.fixture
-    def mock_uuid(self):
-        """Mock UUID generation for predictable task IDs."""
-        with patch("services.enterprise.account_deletion_sync.uuid.uuid4") as mock_uuid_gen:
-            mock_uuid_gen.return_value = MagicMock(hex="test-task-id-1234")
-            yield mock_uuid_gen
-
-    def test_queue_task_success(self, mock_redis_client, mock_uuid):
-        """Test successful task queueing to Redis."""
-        # Arrange
-        workspace_id = "ws-123"
-        member_id = "member-456"
-        source = "test_source"
-
-        # Act
-        result = _queue_task(workspace_id=workspace_id, member_id=member_id, source=source)
-
-        # Assert
-        assert result is True
-        mock_redis_client.lpush.assert_called_once()
-
-        # Verify the task payload structure
-        call_args = mock_redis_client.lpush.call_args[0]
-        assert call_args[0] == "enterprise:member:sync:queue"
-
-        import json
-
-        task_data = json.loads(call_args[1])
-        assert task_data["workspace_id"] == workspace_id
-        assert task_data["member_id"] == member_id
-        assert task_data["source"] == source
-        assert task_data["type"] == "sync_member_deletion_from_workspace"
-        assert task_data["retry_count"] == 0
-        assert "task_id" in task_data
-        assert "created_at" in task_data
-
-    def test_queue_task_redis_error(self, mock_redis_client, caplog):
-        """Test handling of Redis connection errors."""
-        # Arrange
-        mock_redis_client.lpush.side_effect = RedisError("Connection failed")
-
-        # Act
-        result = _queue_task(workspace_id="ws-123", member_id="member-456", source="test_source")
-
-        # Assert
-        assert result is False
-        assert "Failed to queue account deletion sync" in caplog.text
-
-    def test_queue_task_type_error(self, mock_redis_client, caplog):
-        """Test handling of JSON serialization errors."""
-        # Arrange
-        mock_redis_client.lpush.side_effect = TypeError("Cannot serialize")
-
-        # Act
-        result = _queue_task(workspace_id="ws-123", member_id="member-456", source="test_source")
-
-        # Assert
-        assert result is False
-        assert "Failed to queue account deletion sync" in caplog.text
-
-
-class TestSyncWorkspaceMemberRemoval:
-    """Unit tests for sync_workspace_member_removal function."""
-
-    @pytest.fixture
-    def mock_queue_task(self):
-        """Mock _queue_task for testing."""
-        with patch("services.enterprise.account_deletion_sync._queue_task") as mock_queue:
-            mock_queue.return_value = True
-            yield mock_queue
-
-    def test_sync_workspace_member_removal_enterprise_enabled(self, mock_queue_task):
-        """Test sync when ENTERPRISE_ENABLED is True."""
-        # Arrange
-        workspace_id = "ws-123"
-        member_id = "member-456"
-        source = "workspace_member_removed"
-
-        with patch("services.enterprise.account_deletion_sync.dify_config") as mock_config:
-            mock_config.ENTERPRISE_ENABLED = True
-
-            # Act
-            result = sync_workspace_member_removal(workspace_id=workspace_id, member_id=member_id, source=source)
-
-            # Assert
-            assert result is True
-            mock_queue_task.assert_called_once_with(workspace_id=workspace_id, member_id=member_id, source=source)
-
-    def test_sync_workspace_member_removal_enterprise_disabled(self, mock_queue_task):
-        """Test sync when ENTERPRISE_ENABLED is False (community edition)."""
-        # Arrange
-        with patch("services.enterprise.account_deletion_sync.dify_config") as mock_config:
-            mock_config.ENTERPRISE_ENABLED = False
-
-            # Act
-            result = sync_workspace_member_removal(workspace_id="ws-123", member_id="member-456", source="test_source")
-
-            # Assert
-            assert result is True
-            mock_queue_task.assert_not_called()
-
-    def test_sync_workspace_member_removal_queue_failure(self, mock_queue_task):
-        """Test handling of queue task failures."""
-        # Arrange
-        mock_queue_task.return_value = False
-
-        with patch("services.enterprise.account_deletion_sync.dify_config") as mock_config:
-            mock_config.ENTERPRISE_ENABLED = True
-
-            # Act
-            result = sync_workspace_member_removal(workspace_id="ws-123", member_id="member-456", source="test_source")
-
-            # Assert
-            assert result is False
-
-
-class TestSyncAccountDeletion:
-    """Unit tests for sync_account_deletion function."""
-
-    @pytest.fixture
-    def mock_db_session(self):
-        """Mock database session for testing."""
-        with patch("services.enterprise.account_deletion_sync.db.session") as mock_session:
-            yield mock_session
-
-    @pytest.fixture
-    def mock_queue_task(self):
-        """Mock _queue_task for testing."""
-        with patch("services.enterprise.account_deletion_sync._queue_task") as mock_queue:
-            mock_queue.return_value = True
-            yield mock_queue
-
-    def test_sync_account_deletion_enterprise_disabled(self, mock_db_session, mock_queue_task):
-        """Test sync when ENTERPRISE_ENABLED is False (community edition)."""
-        # Arrange
-        with patch("services.enterprise.account_deletion_sync.dify_config") as mock_config:
-            mock_config.ENTERPRISE_ENABLED = False
-
-            # Act
-            result = sync_account_deletion(account_id="acc-123", source="account_deleted")
-
-            # Assert
-            assert result is True
-            mock_db_session.query.assert_not_called()
-            mock_queue_task.assert_not_called()
-
-    def test_sync_account_deletion_multiple_workspaces(self, mock_db_session, mock_queue_task):
-        """Test sync for account with multiple workspace memberships."""
-        # Arrange
-        account_id = "acc-123"
-
-        # Mock workspace joins
-        mock_join1 = MagicMock()
-        mock_join1.tenant_id = "tenant-1"
-        mock_join2 = MagicMock()
-        mock_join2.tenant_id = "tenant-2"
-        mock_join3 = MagicMock()
-        mock_join3.tenant_id = "tenant-3"
-
-        mock_query = MagicMock()
-        mock_query.filter_by.return_value.all.return_value = [mock_join1, mock_join2, mock_join3]
-        mock_db_session.query.return_value = mock_query
-
-        with patch("services.enterprise.account_deletion_sync.dify_config") as mock_config:
-            mock_config.ENTERPRISE_ENABLED = True
-
-            # Act
-            result = sync_account_deletion(account_id=account_id, source="account_deleted")
-
-            # Assert
-            assert result is True
-            assert mock_queue_task.call_count == 3
-
-            # Verify each workspace was queued
-            mock_queue_task.assert_any_call(workspace_id="tenant-1", member_id=account_id, source="account_deleted")
-            mock_queue_task.assert_any_call(workspace_id="tenant-2", member_id=account_id, source="account_deleted")
-            mock_queue_task.assert_any_call(workspace_id="tenant-3", member_id=account_id, source="account_deleted")
-
-    def test_sync_account_deletion_no_workspaces(self, mock_db_session, mock_queue_task):
-        """Test sync for account with no workspace memberships."""
-        # Arrange
-        mock_query = MagicMock()
-        mock_query.filter_by.return_value.all.return_value = []
-        mock_db_session.query.return_value = mock_query
-
-        with patch("services.enterprise.account_deletion_sync.dify_config") as mock_config:
-            mock_config.ENTERPRISE_ENABLED = True
-
-            # Act
-            result = sync_account_deletion(account_id="acc-123", source="account_deleted")
-
-            # Assert
-            assert result is True
-            mock_queue_task.assert_not_called()
-
-    def test_sync_account_deletion_partial_failure(self, mock_db_session, mock_queue_task):
-        """Test sync when some tasks fail to queue."""
-        # Arrange
-        account_id = "acc-123"
-
-        # Mock workspace joins
-        mock_join1 = MagicMock()
-        mock_join1.tenant_id = "tenant-1"
-        mock_join2 = MagicMock()
-        mock_join2.tenant_id = "tenant-2"
-        mock_join3 = MagicMock()
-        mock_join3.tenant_id = "tenant-3"
-
-        mock_query = MagicMock()
-        mock_query.filter_by.return_value.all.return_value = [mock_join1, mock_join2, mock_join3]
-        mock_db_session.query.return_value = mock_query
-
-        # Mock queue_task to fail for second workspace
-        def queue_side_effect(workspace_id, member_id, source):
-            return workspace_id != "tenant-2"
-
-        mock_queue_task.side_effect = queue_side_effect
-
-        with patch("services.enterprise.account_deletion_sync.dify_config") as mock_config:
-            mock_config.ENTERPRISE_ENABLED = True
-
-            # Act
-            result = sync_account_deletion(account_id=account_id, source="account_deleted")
-
-            # Assert
-            assert result is False  # Should return False if any task fails
-            assert mock_queue_task.call_count == 3
-
-    def test_sync_account_deletion_all_failures(self, mock_db_session, mock_queue_task):
-        """Test sync when all tasks fail to queue."""
-        # Arrange
-        mock_join = MagicMock()
-        mock_join.tenant_id = "tenant-1"
-
-        mock_query = MagicMock()
-        mock_query.filter_by.return_value.all.return_value = [mock_join]
-        mock_db_session.query.return_value = mock_query
-
-        mock_queue_task.return_value = False
-
-        with patch("services.enterprise.account_deletion_sync.dify_config") as mock_config:
-            mock_config.ENTERPRISE_ENABLED = True
-
-            # Act
-            result = sync_account_deletion(account_id="acc-123", source="account_deleted")
-
-            # Assert
-            assert result is False
-            mock_queue_task.assert_called_once()

docker/.env.example

@@ -1518,6 +1518,5 @@ AMPLITUDE_API_KEY=
 # Sandbox expired records clean configuration
 SANDBOX_EXPIRED_RECORDS_CLEAN_GRACEFUL_PERIOD=21
 SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_SIZE=1000
-SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_MAX_INTERVAL=200
 SANDBOX_EXPIRED_RECORDS_RETENTION_DAYS=30
 SANDBOX_EXPIRED_RECORDS_CLEAN_TASK_LOCK_TTL=90000

docker/docker-compose.yaml

@@ -682,7 +682,6 @@ x-shared-env: &shared-api-worker-env
   AMPLITUDE_API_KEY: ${AMPLITUDE_API_KEY:-}
   SANDBOX_EXPIRED_RECORDS_CLEAN_GRACEFUL_PERIOD: ${SANDBOX_EXPIRED_RECORDS_CLEAN_GRACEFUL_PERIOD:-21}
   SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_SIZE: ${SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_SIZE:-1000}
-  SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_MAX_INTERVAL: ${SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_MAX_INTERVAL:-200}
   SANDBOX_EXPIRED_RECORDS_RETENTION_DAYS: ${SANDBOX_EXPIRED_RECORDS_RETENTION_DAYS:-30}
   SANDBOX_EXPIRED_RECORDS_CLEAN_TASK_LOCK_TTL: ${SANDBOX_EXPIRED_RECORDS_CLEAN_TASK_LOCK_TTL:-90000}
 

web/app/components/base/tooltip/index.tsx

@@ -4,7 +4,7 @@ import type { FC } from 'react'
 import { RiQuestionLine } from '@remixicon/react'
 import { useBoolean } from 'ahooks'
 import * as React from 'react'
-import { useCallback, useEffect, useRef, useState } from 'react'
+import { useEffect, useRef, useState } from 'react'
 import { PortalToFollowElem, PortalToFollowElemContent, PortalToFollowElemTrigger } from '@/app/components/base/portal-to-follow-elem'
 import { cn } from '@/utils/classnames'
 import { tooltipManager } from './TooltipManager'
@@ -61,20 +61,6 @@ const Tooltip: FC<TooltipProps> = ({
     isHoverTriggerRef.current = isHoverTrigger
   }, [isHoverTrigger])
 
-  const closeTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null)
-  const clearCloseTimeout = useCallback(() => {
-    if (closeTimeoutRef.current) {
-      clearTimeout(closeTimeoutRef.current)
-      closeTimeoutRef.current = null
-    }
-  }, [])
-
-  useEffect(() => {
-    return () => {
-      clearCloseTimeout()
-    }
-  }, [clearCloseTimeout])
-
   const close = () => setOpen(false)
 
   const handleLeave = (isTrigger: boolean) => {
@@ -85,9 +71,7 @@ const Tooltip: FC<TooltipProps> = ({
 
     // give time to move to the popup
     if (needsDelay) {
-      clearCloseTimeout()
-      closeTimeoutRef.current = setTimeout(() => {
-        closeTimeoutRef.current = null
+      setTimeout(() => {
         if (!isHoverPopupRef.current && !isHoverTriggerRef.current) {
           setOpen(false)
           tooltipManager.clear(close)
@@ -95,7 +79,6 @@ const Tooltip: FC<TooltipProps> = ({
       }, 300)
     }
     else {
-      clearCloseTimeout()
       setOpen(false)
       tooltipManager.clear(close)
     }
@@ -112,7 +95,6 @@ const Tooltip: FC<TooltipProps> = ({
         onClick={() => triggerMethod === 'click' && setOpen(v => !v)}
         onMouseEnter={() => {
           if (triggerMethod === 'hover') {
-            clearCloseTimeout()
             setHoverTrigger()
             tooltipManager.register(close)
             setOpen(true)
@@ -133,12 +115,7 @@ const Tooltip: FC<TooltipProps> = ({
               !noDecoration && 'system-xs-regular relative max-w-[300px] break-words rounded-md bg-components-panel-bg px-3 py-2 text-left text-text-tertiary shadow-lg',
               popupClassName,
             )}
-            onMouseEnter={() => {
-              if (triggerMethod === 'hover') {
-                clearCloseTimeout()
-                setHoverPopup()
-              }
-            }}
+            onMouseEnter={() => triggerMethod === 'hover' && setHoverPopup()}
             onMouseLeave={() => triggerMethod === 'hover' && handleLeave(false)}
           >
             {popupContent}

web/app/components/explore/app-list/index.tsx

@@ -159,74 +159,69 @@ const Apps = ({
 
   return (
     <div className={cn(
-      'flex h-full min-h-0 flex-col overflow-hidden border-l-[0.5px] border-divider-regular',
+      'flex h-full flex-col border-l-[0.5px] border-divider-regular',
     )}
     >
-      <div className="flex flex-1 flex-col overflow-y-auto">
-        {systemFeatures.enable_explore_banner && (
-          <div className="mt-4 px-12">
-            <Banner />
-          </div>
-        )}
-
-        <div className="sticky top-0 z-10 bg-background-body">
-          <div className={cn(
-            'flex items-center justify-between px-12 pt-6',
+      {systemFeatures.enable_explore_banner && (
+        <div className="mt-4 px-12">
+          <Banner />
+        </div>
+      )}
+      <div className={cn(
+        'mt-6 flex items-center justify-between px-12',
+      )}
+      >
+        <div className="flex items-center">
+          <div className="system-xl-semibold grow truncate text-text-primary">{!hasFilterCondition ? t('apps.title', { ns: 'explore' }) : t('apps.resultNum', { num: searchFilteredList.length, ns: 'explore' })}</div>
+          {hasFilterCondition && (
+            <>
+              <div className="mx-3 h-4 w-px bg-divider-regular"></div>
+              <Button size="medium" onClick={handleResetFilter}>{t('apps.resetFilter', { ns: 'explore' })}</Button>
+            </>
           )}
-          >
-            <div className="flex items-center">
-              <div className="system-xl-semibold grow truncate text-text-primary">{!hasFilterCondition ? t('apps.title', { ns: 'explore' }) : t('apps.resultNum', { num: searchFilteredList.length, ns: 'explore' })}</div>
-              {hasFilterCondition && (
-                <>
-                  <div className="mx-3 h-4 w-px bg-divider-regular"></div>
-                  <Button size="medium" onClick={handleResetFilter}>{t('apps.resetFilter', { ns: 'explore' })}</Button>
-                </>
-              )}
-            </div>
-            <Input
-              showLeftIcon
-              showClearIcon
-              wrapperClassName="w-[200px] self-start"
-              value={keywords}
-              onChange={e => handleKeywordsChange(e.target.value)}
-              onClear={() => handleKeywordsChange('')}
-            />
-          </div>
-
-          <div className="px-12 pb-4 pt-2">
-            <Category
-              list={categories}
-              value={currCategory}
-              onChange={setCurrCategory}
-              allCategoriesEn={allCategoriesEn}
-            />
-          </div>
         </div>
+        <Input
+          showLeftIcon
+          showClearIcon
+          wrapperClassName="w-[200px] self-start"
+          value={keywords}
+          onChange={e => handleKeywordsChange(e.target.value)}
+          onClear={() => handleKeywordsChange('')}
+        />
+      </div>
 
-        <div className={cn(
-          'relative flex flex-1 shrink-0 grow flex-col pb-6',
-        )}
+      <div className="mt-2 px-12">
+        <Category
+          list={categories}
+          value={currCategory}
+          onChange={setCurrCategory}
+          allCategoriesEn={allCategoriesEn}
+        />
+      </div>
+
+      <div className={cn(
+        'relative mt-4 flex flex-1 shrink-0 grow flex-col overflow-auto pb-6',
+      )}
+      >
+        <nav
+          className={cn(
+            s.appList,
+            'grid shrink-0 content-start gap-4 px-6 sm:px-12',
+          )}
         >
-          <nav
-            className={cn(
-              s.appList,
-              'grid shrink-0 content-start gap-4 px-6 sm:px-12',
-            )}
-          >
-            {searchFilteredList.map(app => (
-              <AppCard
-                key={app.app_id}
-                isExplore
-                app={app}
-                canCreate={hasEditPermission}
-                onCreate={() => {
-                  setCurrApp(app)
-                  setIsShowCreateModal(true)
-                }}
-              />
-            ))}
-          </nav>
-        </div>
+          {searchFilteredList.map(app => (
+            <AppCard
+              key={app.app_id}
+              isExplore
+              app={app}
+              canCreate={hasEditPermission}
+              onCreate={() => {
+                setCurrApp(app)
+                setIsShowCreateModal(true)
+              }}
+            />
+          ))}
+        </nav>
       </div>
       {isShowCreateModal && (
         <CreateAppModal

web/app/components/explore/index.tsx

@@ -71,7 +71,7 @@ const Explore: FC<IExploreProps> = ({
         }
       >
         <Sidebar controlUpdateInstalledApps={controlUpdateInstalledApps} />
-        <div className="h-full min-h-0 w-0 grow">
+        <div className="w-0 grow">
           {children}
         </div>
       </ExploreContext.Provider>

web/app/components/plugins/plugin-detail-panel/subscription-list/create/common-modal.spec.tsx

@@ -599,30 +599,20 @@ describe('CommonCreateModal', () => {
         },
       })
       mockUsePluginStore.mockReturnValue(detailWithCredentials)
-      const existingBuilder = createMockSubscriptionBuilder()
       mockVerifyCredentials.mockImplementation((params, { onSuccess }) => {
         onSuccess()
       })
 
-      render(<CommonCreateModal {...defaultProps} builder={existingBuilder} />)
+      render(<CommonCreateModal {...defaultProps} />)
+
+      await waitFor(() => {
+        expect(mockCreateBuilder).toHaveBeenCalled()
+      })
 
       fireEvent.click(screen.getByTestId('modal-confirm'))
 
       await waitFor(() => {
-        expect(mockVerifyCredentials).toHaveBeenCalledWith(
-          expect.objectContaining({
-            provider: 'test-provider',
-            subscriptionBuilderId: existingBuilder.id,
-          }),
-          expect.objectContaining({
-            onSuccess: expect.any(Function),
-            onError: expect.any(Function),
-          }),
-        )
-      })
-
-      await waitFor(() => {
-        expect(screen.getByTestId('modal-confirm')).toHaveTextContent('pluginTrigger.modal.common.create')
+        expect(mockVerifyCredentials).toHaveBeenCalled()
       })
     })
 
@@ -639,12 +629,15 @@ describe('CommonCreateModal', () => {
         },
       })
       mockUsePluginStore.mockReturnValue(detailWithCredentials)
-      const existingBuilder = createMockSubscriptionBuilder()
       mockVerifyCredentials.mockImplementation((params, { onError }) => {
         onError(new Error('Verification failed'))
       })
 
-      render(<CommonCreateModal {...defaultProps} builder={existingBuilder} />)
+      render(<CommonCreateModal {...defaultProps} />)
+
+      await waitFor(() => {
+        expect(mockCreateBuilder).toHaveBeenCalled()
+      })
 
       fireEvent.click(screen.getByTestId('modal-confirm'))
 

web/app/components/rag-pipeline/components/update-dsl-modal.spec.tsx

@@ -4,17 +4,6 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { DSLImportStatus } from '@/models/app'
 import UpdateDSLModal from './update-dsl-modal'
 
-class MockFileReader {
-  onload: ((this: FileReader, event: ProgressEvent<FileReader>) => void) | null = null
-
-  readAsText(_file: Blob) {
-    const event = { target: { result: 'test content' } } as unknown as ProgressEvent<FileReader>
-    this.onload?.call(this as unknown as FileReader, event)
-  }
-}
-
-vi.stubGlobal('FileReader', MockFileReader as unknown as typeof FileReader)
-
 // Mock react-i18next
 vi.mock('react-i18next', () => ({
   useTranslation: () => ({
@@ -148,6 +137,7 @@ vi.mock('@/app/components/workflow/constants', () => ({
 afterEach(() => {
   cleanup()
   vi.clearAllMocks()
+  vi.useRealTimers()
 })
 
 describe('UpdateDSLModal', () => {
@@ -161,6 +151,11 @@ describe('UpdateDSLModal', () => {
     onImport: mockOnImport,
   }
 
+  // Helper function to flush FileReader microtasks
+  const flushFileReader = async () => {
+    await new Promise<void>(resolve => queueMicrotask(resolve))
+  }
+
   beforeEach(() => {
     vi.clearAllMocks()
     mockImportDSL.mockResolvedValue({
@@ -370,7 +365,11 @@ describe('UpdateDSLModal', () => {
       // Select a file
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        await flushFileReader()
+      })
 
       // Wait for FileReader to process
       await waitFor(() => {
@@ -380,12 +379,15 @@ describe('UpdateDSLModal', () => {
 
       // Click import button
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       // Wait for import to be called
       await waitFor(() => {
         expect(mockImportDSL).toHaveBeenCalled()
-      })
+      }, { timeout: 5000 })
     })
 
     it('should show success notification on completed import', async () => {
@@ -400,7 +402,12 @@ describe('UpdateDSLModal', () => {
       // Select a file and click import
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        // Wait for FileReader to process
+        await flushFileReader()
+      })
 
       await waitFor(() => {
         const importButton = screen.getByText('common.overwriteAndImport')
@@ -408,13 +415,16 @@ describe('UpdateDSLModal', () => {
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       await waitFor(() => {
         expect(mockNotify).toHaveBeenCalledWith(expect.objectContaining({
           type: 'success',
         }))
-      })
+      }, { timeout: 5000 })
     })
 
     it('should call onCancel after successful import', async () => {
@@ -428,7 +438,12 @@ describe('UpdateDSLModal', () => {
 
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        // Wait for FileReader to process
+        await flushFileReader()
+      })
 
       await waitFor(() => {
         const importButton = screen.getByText('common.overwriteAndImport')
@@ -436,7 +451,10 @@ describe('UpdateDSLModal', () => {
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       await waitFor(() => {
         expect(mockOnCancel).toHaveBeenCalled()
@@ -454,7 +472,11 @@ describe('UpdateDSLModal', () => {
 
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        await flushFileReader()
+      })
 
       await waitFor(() => {
         const importButton = screen.getByText('common.overwriteAndImport')
@@ -462,7 +484,10 @@ describe('UpdateDSLModal', () => {
       }, { timeout: 1000 })
 
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       await waitFor(() => {
         expect(mockOnImport).toHaveBeenCalled()
@@ -480,7 +505,11 @@ describe('UpdateDSLModal', () => {
 
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        await flushFileReader()
+      })
 
       await waitFor(() => {
         const importButton = screen.getByText('common.overwriteAndImport')
@@ -488,7 +517,10 @@ describe('UpdateDSLModal', () => {
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       await waitFor(() => {
         expect(mockNotify).toHaveBeenCalledWith(expect.objectContaining({
@@ -508,7 +540,11 @@ describe('UpdateDSLModal', () => {
 
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        await flushFileReader()
+      })
 
       await waitFor(() => {
         const importButton = screen.getByText('common.overwriteAndImport')
@@ -516,7 +552,10 @@ describe('UpdateDSLModal', () => {
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       await waitFor(() => {
         expect(mockNotify).toHaveBeenCalledWith(expect.objectContaining({
@@ -536,7 +575,11 @@ describe('UpdateDSLModal', () => {
 
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        await flushFileReader()
+      })
 
       // Wait for FileReader to process and button to be enabled
       await waitFor(() => {
@@ -545,7 +588,10 @@ describe('UpdateDSLModal', () => {
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       await waitFor(() => {
         expect(mockNotify).toHaveBeenCalledWith(expect.objectContaining({
@@ -561,7 +607,11 @@ describe('UpdateDSLModal', () => {
 
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        await flushFileReader()
+      })
 
       // Wait for FileReader to complete and button to be enabled
       await waitFor(() => {
@@ -570,7 +620,10 @@ describe('UpdateDSLModal', () => {
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       await waitFor(() => {
         expect(mockNotify).toHaveBeenCalledWith(expect.objectContaining({
@@ -599,7 +652,7 @@ describe('UpdateDSLModal', () => {
 
       // Flush the FileReader microtask to ensure fileContent is set
       await act(async () => {
-        await new Promise<void>(resolve => queueMicrotask(resolve))
+        await flushFileReader()
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
@@ -655,7 +708,7 @@ describe('UpdateDSLModal', () => {
       await act(async () => {
         fireEvent.change(fileInput, { target: { files: [file] } })
         // Flush microtasks scheduled by the FileReader mock (which uses queueMicrotask)
-        await new Promise<void>(resolve => queueMicrotask(resolve))
+        await flushFileReader()
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
@@ -667,12 +720,13 @@ describe('UpdateDSLModal', () => {
         await Promise.resolve()
         // Advance past the 300ms setTimeout in the component
         await vi.advanceTimersByTimeAsync(350)
+        // Flush any pending state updates
+        await Promise.resolve()
       })
 
-      await waitFor(() => {
-        expect(screen.getByText('newApp.appCreateDSLErrorTitle')).toBeInTheDocument()
-      })
-
+      // Element should be visible immediately after advancing timers
+      expect(screen.getByText('newApp.appCreateDSLErrorTitle')).toBeInTheDocument()
+      
       vi.useRealTimers()
     })
 
@@ -689,7 +743,11 @@ describe('UpdateDSLModal', () => {
 
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        await flushFileReader()
+      })
 
       await waitFor(() => {
         const importButton = screen.getByText('common.overwriteAndImport')
@@ -697,7 +755,10 @@ describe('UpdateDSLModal', () => {
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       // Wait for error modal with version info
       await waitFor(() => {
@@ -719,7 +780,11 @@ describe('UpdateDSLModal', () => {
 
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        await flushFileReader()
+      })
 
       await waitFor(() => {
         const importButton = screen.getByText('common.overwriteAndImport')
@@ -727,7 +792,10 @@ describe('UpdateDSLModal', () => {
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       // Wait for error modal
       await waitFor(() => {
@@ -773,7 +841,7 @@ describe('UpdateDSLModal', () => {
       await act(async () => {
         fireEvent.change(fileInput, { target: { files: [file] } })
         // Flush microtasks scheduled by the FileReader mock (which uses queueMicrotask)
-        await new Promise<void>(resolve => queueMicrotask(resolve))
+        await flushFileReader()
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
@@ -785,21 +853,25 @@ describe('UpdateDSLModal', () => {
         await Promise.resolve()
         // Advance past the 300ms setTimeout in the component
         await vi.advanceTimersByTimeAsync(350)
+        // Flush any pending state updates
+        await Promise.resolve()
       })
 
-      await waitFor(() => {
-        expect(screen.getByText('newApp.appCreateDSLErrorTitle')).toBeInTheDocument()
-      }, { timeout: 1000 })
+      // Element should be visible immediately after advancing timers
+      expect(screen.getByText('newApp.appCreateDSLErrorTitle')).toBeInTheDocument()
+      
+      vi.useRealTimers()
 
       // Click confirm button
       const confirmButton = screen.getByText('newApp.Confirm')
-      fireEvent.click(confirmButton)
+
+      await act(async () => {
+        fireEvent.click(confirmButton)
+      })
 
       await waitFor(() => {
         expect(mockImportDSLConfirm).toHaveBeenCalledWith('import-id')
-      })
-
-      vi.useRealTimers()
+      }, { timeout: 5000 })
     })
 
     it('should show success notification after confirm completes', async () => {
@@ -862,7 +934,11 @@ describe('UpdateDSLModal', () => {
 
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        await flushFileReader()
+      })
 
       await waitFor(() => {
         const importButton = screen.getByText('common.overwriteAndImport')
@@ -870,20 +946,26 @@ describe('UpdateDSLModal', () => {
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       await waitFor(() => {
         expect(screen.getByText('newApp.appCreateDSLErrorTitle')).toBeInTheDocument()
-      }, { timeout: 1000 })
+      }, { timeout: 5000 })
 
       const confirmButton = screen.getByText('newApp.Confirm')
-      fireEvent.click(confirmButton)
+
+      await act(async () => {
+        fireEvent.click(confirmButton)
+      })
 
       await waitFor(() => {
         expect(mockNotify).toHaveBeenCalledWith(expect.objectContaining({
           type: 'error',
         }))
-      })
+      }, { timeout: 5000 })
     })
 
     it('should show error notification when confirm throws exception', async () => {
@@ -901,7 +983,11 @@ describe('UpdateDSLModal', () => {
 
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        await flushFileReader()
+      })
 
       await waitFor(() => {
         const importButton = screen.getByText('common.overwriteAndImport')
@@ -909,20 +995,26 @@ describe('UpdateDSLModal', () => {
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       await waitFor(() => {
         expect(screen.getByText('newApp.appCreateDSLErrorTitle')).toBeInTheDocument()
-      }, { timeout: 1000 })
+      }, { timeout: 5000 })
 
       const confirmButton = screen.getByText('newApp.Confirm')
-      fireEvent.click(confirmButton)
+
+      await act(async () => {
+        fireEvent.click(confirmButton)
+      })
 
       await waitFor(() => {
         expect(mockNotify).toHaveBeenCalledWith(expect.objectContaining({
           type: 'error',
         }))
-      })
+      }, { timeout: 5000 })
     })
 
     it('should show error when confirm completes but pipeline_id is missing', async () => {
@@ -943,7 +1035,11 @@ describe('UpdateDSLModal', () => {
 
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        await flushFileReader()
+      })
 
       await waitFor(() => {
         const importButton = screen.getByText('common.overwriteAndImport')
@@ -951,20 +1047,26 @@ describe('UpdateDSLModal', () => {
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       await waitFor(() => {
         expect(screen.getByText('newApp.appCreateDSLErrorTitle')).toBeInTheDocument()
-      }, { timeout: 1000 })
+      }, { timeout: 5000 })
 
       const confirmButton = screen.getByText('newApp.Confirm')
-      fireEvent.click(confirmButton)
+
+      await act(async () => {
+        fireEvent.click(confirmButton)
+      })
 
       await waitFor(() => {
         expect(mockNotify).toHaveBeenCalledWith(expect.objectContaining({
           type: 'error',
         }))
-      })
+      }, { timeout: 5000 })
     })
 
     it('should call onImport after confirm completes successfully', async () => {
@@ -985,7 +1087,11 @@ describe('UpdateDSLModal', () => {
 
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        await flushFileReader()
+      })
 
       await waitFor(() => {
         const importButton = screen.getByText('common.overwriteAndImport')
@@ -993,18 +1099,24 @@ describe('UpdateDSLModal', () => {
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       await waitFor(() => {
         expect(screen.getByText('newApp.appCreateDSLErrorTitle')).toBeInTheDocument()
-      }, { timeout: 1000 })
+      }, { timeout: 5000 })
 
       const confirmButton = screen.getByText('newApp.Confirm')
-      fireEvent.click(confirmButton)
+
+      await act(async () => {
+        fireEvent.click(confirmButton)
+      })
 
       await waitFor(() => {
         expect(mockOnImport).toHaveBeenCalled()
-      })
+      }, { timeout: 5000 })
     })
 
     it('should call handleCheckPluginDependencies after confirm', async () => {
@@ -1031,7 +1143,7 @@ describe('UpdateDSLModal', () => {
       await act(async () => {
         fireEvent.change(fileInput, { target: { files: [file] } })
         // Flush microtasks scheduled by the FileReader mock (which uses queueMicrotask)
-        await new Promise<void>(resolve => queueMicrotask(resolve))
+        await flushFileReader()
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
@@ -1043,20 +1155,24 @@ describe('UpdateDSLModal', () => {
         await Promise.resolve()
         // Advance past the 300ms setTimeout in the component
         await vi.advanceTimersByTimeAsync(350)
+        // Flush any pending state updates
+        await Promise.resolve()
       })
 
-      await waitFor(() => {
-        expect(screen.getByText('newApp.appCreateDSLErrorTitle')).toBeInTheDocument()
-      }, { timeout: 1000 })
+      // Element should be visible immediately after advancing timers
+      expect(screen.getByText('newApp.appCreateDSLErrorTitle')).toBeInTheDocument()
+      
+      vi.useRealTimers()
 
       const confirmButton = screen.getByText('newApp.Confirm')
-      fireEvent.click(confirmButton)
+
+      await act(async () => {
+        fireEvent.click(confirmButton)
+      })
 
       await waitFor(() => {
         expect(mockHandleCheckPluginDependencies).toHaveBeenCalledWith('test-pipeline-id', true)
-      })
-
-      vi.useRealTimers()
+      }, { timeout: 5000 })
     })
 
     it('should handle undefined imported_dsl_version and current_dsl_version', async () => {
@@ -1072,7 +1188,11 @@ describe('UpdateDSLModal', () => {
 
       const fileInput = screen.getByTestId('file-input')
       const file = new File(['test content'], 'test.pipeline', { type: 'text/yaml' })
-      fireEvent.change(fileInput, { target: { files: [file] } })
+
+      await act(async () => {
+        fireEvent.change(fileInput, { target: { files: [file] } })
+        await flushFileReader()
+      })
 
       await waitFor(() => {
         const importButton = screen.getByText('common.overwriteAndImport')
@@ -1080,12 +1200,15 @@ describe('UpdateDSLModal', () => {
       })
 
       const importButton = screen.getByText('common.overwriteAndImport')
-      fireEvent.click(importButton)
+
+      await act(async () => {
+        fireEvent.click(importButton)
+      })
 
       // Should show error modal even with undefined versions
       await waitFor(() => {
         expect(screen.getByText('newApp.appCreateDSLErrorTitle')).toBeInTheDocument()
-      }, { timeout: 1000 })
+      }, { timeout: 5000 })
     })
 
     it('should not call importDSLConfirm when importId is not set', async () => {

web/package.json

@@ -46,8 +46,7 @@
     "uglify-embed": "node ./bin/uglify-embed",
     "i18n:check": "tsx ./scripts/check-i18n.js",
     "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "test:ci": "vitest run --coverage --reporter vitest-tiny-reporter --silent=passed-only",
+    "test:coverage": "vitest run --coverage --reporter=dot --silent=passed-only",
     "test:watch": "vitest --watch",
     "analyze-component": "node ./scripts/analyze-component.js",
     "refactor-component": "node ./scripts/refactor-component.js",
@@ -235,8 +234,7 @@
     "vite": "7.3.1",
     "vite-tsconfig-paths": "6.0.4",
     "vitest": "4.0.17",
-    "vitest-canvas-mock": "1.1.3",
-    "vitest-tiny-reporter": "1.3.1"
+    "vitest-canvas-mock": "1.1.3"
   },
   "pnpm": {
     "overrides": {

web/pnpm-lock.yaml

@@ -582,9 +582,6 @@ importers:
       vitest-canvas-mock:
         specifier: 1.1.3
         version: 1.1.3([email protected])
-      vitest-tiny-reporter:
-        specifier: 1.3.1
-        version: 1.3.1(@vitest/[email protected])([email protected])
 
 packages:
 
@@ -7233,12 +7230,6 @@ packages:
     peerDependencies:
       vitest: ^3.0.0 || ^4.0.0
 
-  [email protected]:
-    resolution: {integrity: sha512-9WfLruQBbxm4EqMIS0jDZmQjvMgsWgHUso9mHQWgjA6hM3tEVhjdG8wYo7ePFh1XbwEFzEo3XUQqkGoKZ/Td2Q==}
-    peerDependencies:
-      '@vitest/runner': ^2.0.0 || ^3.0.2 || ^4.0.0
-      vitest: ^2.0.0 || ^3.0.2 || ^4.0.0
-
   [email protected]:
     resolution: {integrity: sha512-FQMeF0DJdWY0iOnbv466n/0BudNdKj1l5jYgl5JVTwjSsZSlqyXFt/9+1sEyhR6CLowbZpV7O1sCHrzBhucKKg==}
     engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
@@ -15237,12 +15228,6 @@ snapshots:
       moo-color: 1.0.3
       vitest: 4.0.17(@types/[email protected])(@vitest/[email protected])([email protected])([email protected]([email protected]))([email protected])([email protected])([email protected])([email protected])
 
-  [email protected](@vitest/[email protected])([email protected]):
-    dependencies:
-      '@vitest/runner': 4.0.17
-      tinyrainbow: 3.0.3
-      vitest: 4.0.17(@types/[email protected])(@vitest/[email protected])([email protected])([email protected]([email protected]))([email protected])([email protected])([email protected])([email protected])
-
   [email protected](@types/[email protected])(@vitest/[email protected])([email protected])([email protected]([email protected]))([email protected])([email protected])([email protected])([email protected]):
     dependencies:
       '@vitest/expect': 4.0.17