Merge remote-tracking branch 'upstream/main' into feat/human-input-merge-again

api/tests/integration_tests/.env.example

@@ -103,6 +103,8 @@ SMTP_USERNAME=123
 SMTP_PASSWORD=abc
 SMTP_USE_TLS=true
 SMTP_OPPORTUNISTIC_TLS=false
+# Optional: override the local hostname used for SMTP HELO/EHLO
+SMTP_LOCAL_HOSTNAME=
 
 # Sentry configuration
 SENTRY_DSN=

api/tests/integration_tests/model_runtime/__mock/plugin_model.py

@@ -48,10 +48,6 @@ class MockModelClass(PluginModelClient):
                         en_US="https://example.com/icon_small.png",
                         zh_Hans="https://example.com/icon_small.png",
                     ),
-                    icon_large=I18nObject(
-                        en_US="https://example.com/icon_large.png",
-                        zh_Hans="https://example.com/icon_large.png",
-                    ),
                     supported_model_types=[ModelType.LLM],
                     configurate_methods=[ConfigurateMethod.PREDEFINED_MODEL],
                     models=[

api/tests/integration_tests/tasks/test_remove_app_and_related_data_task.py

@@ -4,8 +4,8 @@ from unittest.mock import patch
 import pytest
 from sqlalchemy import delete
 
+from core.db.session_factory import session_factory
 from core.variables.segments import StringSegment
-from extensions.ext_database import db
 from models import Tenant
 from models.enums import CreatorUserRole
 from models.model import App, UploadFile
@@ -16,26 +16,23 @@ from tasks.remove_app_and_related_data_task import _delete_draft_variables, dele
 @pytest.fixture
 def app_and_tenant(flask_req_ctx):
     tenant_id = uuid.uuid4()
-    tenant = Tenant(
-        id=tenant_id,
-        name="test_tenant",
-    )
-    db.session.add(tenant)
+    with session_factory.create_session() as session:
+        tenant = Tenant(name="test_tenant")
+        session.add(tenant)
+        session.flush()
 
-    app = App(
-        tenant_id=tenant_id,  # Now tenant.id will have a value
-        name=f"Test App for tenant {tenant.id}",
-        mode="workflow",
-        enable_site=True,
-        enable_api=True,
-    )
-    db.session.add(app)
-    db.session.flush()
-    yield (tenant, app)
+        app = App(
+            tenant_id=tenant.id,
+            name=f"Test App for tenant {tenant.id}",
+            mode="workflow",
+            enable_site=True,
+            enable_api=True,
+        )
+        session.add(app)
+        session.flush()
 
-    # Cleanup with proper error handling
-    db.session.delete(app)
-    db.session.delete(tenant)
+    # return detached objects (ids will be used by tests)
+    return (tenant, app)
 
 
 class TestDeleteDraftVariablesIntegration:
@@ -44,334 +41,285 @@ class TestDeleteDraftVariablesIntegration:
         """Create test data with apps and draft variables."""
         tenant, app = app_and_tenant
 
-        # Create a second app for testing
-        app2 = App(
-            tenant_id=tenant.id,
-            name="Test App 2",
-            mode="workflow",
-            enable_site=True,
-            enable_api=True,
-        )
-        db.session.add(app2)
-        db.session.commit()
-
-        # Create draft variables for both apps
-        variables_app1 = []
-        variables_app2 = []
-
-        for i in range(5):
-            var1 = WorkflowDraftVariable.new_node_variable(
-                app_id=app.id,
-                node_id=f"node_{i}",
-                name=f"var_{i}",
-                value=StringSegment(value="test_value"),
-                node_execution_id=str(uuid.uuid4()),
+        with session_factory.create_session() as session:
+            app2 = App(
+                tenant_id=tenant.id,
+                name="Test App 2",
+                mode="workflow",
+                enable_site=True,
+                enable_api=True,
             )
-            db.session.add(var1)
-            variables_app1.append(var1)
+            session.add(app2)
+            session.flush()
 
-            var2 = WorkflowDraftVariable.new_node_variable(
-                app_id=app2.id,
-                node_id=f"node_{i}",
-                name=f"var_{i}",
-                value=StringSegment(value="test_value"),
-                node_execution_id=str(uuid.uuid4()),
-            )
-            db.session.add(var2)
-            variables_app2.append(var2)
+            variables_app1 = []
+            variables_app2 = []
+            for i in range(5):
+                var1 = WorkflowDraftVariable.new_node_variable(
+                    app_id=app.id,
+                    node_id=f"node_{i}",
+                    name=f"var_{i}",
+                    value=StringSegment(value="test_value"),
+                    node_execution_id=str(uuid.uuid4()),
+                )
+                session.add(var1)
+                variables_app1.append(var1)
 
-        # Commit all the variables to the database
-        db.session.commit()
+                var2 = WorkflowDraftVariable.new_node_variable(
+                    app_id=app2.id,
+                    node_id=f"node_{i}",
+                    name=f"var_{i}",
+                    value=StringSegment(value="test_value"),
+                    node_execution_id=str(uuid.uuid4()),
+                )
+                session.add(var2)
+                variables_app2.append(var2)
+            session.commit()
+
+            app2_id = app2.id
 
         yield {
             "app1": app,
-            "app2": app2,
+            "app2": App(id=app2_id),  # dummy with id to avoid open session
             "tenant": tenant,
             "variables_app1": variables_app1,
             "variables_app2": variables_app2,
         }
 
-        # Cleanup - refresh session and check if objects still exist
-        db.session.rollback()  # Clear any pending changes
-
-        # Clean up remaining variables
-        cleanup_query = (
-            delete(WorkflowDraftVariable)
-            .where(
-                WorkflowDraftVariable.app_id.in_([app.id, app2.id]),
+        with session_factory.create_session() as session:
+            cleanup_query = (
+                delete(WorkflowDraftVariable)
+                .where(WorkflowDraftVariable.app_id.in_([app.id, app2_id]))
+                .execution_options(synchronize_session=False)
             )
-            .execution_options(synchronize_session=False)
-        )
-        db.session.execute(cleanup_query)
-
-        # Clean up app2
-        app2_obj = db.session.get(App, app2.id)
-        if app2_obj:
-            db.session.delete(app2_obj)
-
-        db.session.commit()
+            session.execute(cleanup_query)
+            app2_obj = session.get(App, app2_id)
+            if app2_obj:
+                session.delete(app2_obj)
+            session.commit()
 
     def test_delete_draft_variables_batch_removes_correct_variables(self, setup_test_data):
-        """Test that batch deletion only removes variables for the specified app."""
         data = setup_test_data
         app1_id = data["app1"].id
         app2_id = data["app2"].id
 
-        # Verify initial state
-        app1_vars_before = db.session.query(WorkflowDraftVariable).filter_by(app_id=app1_id).count()
-        app2_vars_before = db.session.query(WorkflowDraftVariable).filter_by(app_id=app2_id).count()
+        with session_factory.create_session() as session:
+            app1_vars_before = session.query(WorkflowDraftVariable).filter_by(app_id=app1_id).count()
+            app2_vars_before = session.query(WorkflowDraftVariable).filter_by(app_id=app2_id).count()
         assert app1_vars_before == 5
         assert app2_vars_before == 5
 
-        # Delete app1 variables
         deleted_count = delete_draft_variables_batch(app1_id, batch_size=10)
-
-        # Verify results
         assert deleted_count == 5
 
-        app1_vars_after = db.session.query(WorkflowDraftVariable).filter_by(app_id=app1_id).count()
-        app2_vars_after = db.session.query(WorkflowDraftVariable).filter_by(app_id=app2_id).count()
-
-        assert app1_vars_after == 0  # All app1 variables deleted
-        assert app2_vars_after == 5  # App2 variables unchanged
+        with session_factory.create_session() as session:
+            app1_vars_after = session.query(WorkflowDraftVariable).filter_by(app_id=app1_id).count()
+            app2_vars_after = session.query(WorkflowDraftVariable).filter_by(app_id=app2_id).count()
+        assert app1_vars_after == 0
+        assert app2_vars_after == 5
 
     def test_delete_draft_variables_batch_with_small_batch_size(self, setup_test_data):
-        """Test batch deletion with small batch size processes all records."""
         data = setup_test_data
         app1_id = data["app1"].id
 
-        # Use small batch size to force multiple batches
         deleted_count = delete_draft_variables_batch(app1_id, batch_size=2)
-
         assert deleted_count == 5
 
-        # Verify all variables are deleted
-        remaining_vars = db.session.query(WorkflowDraftVariable).filter_by(app_id=app1_id).count()
+        with session_factory.create_session() as session:
+            remaining_vars = session.query(WorkflowDraftVariable).filter_by(app_id=app1_id).count()
         assert remaining_vars == 0
 
     def test_delete_draft_variables_batch_nonexistent_app(self, setup_test_data):
-        """Test that deleting variables for nonexistent app returns 0."""
-        nonexistent_app_id = str(uuid.uuid4())  # Use a valid UUID format
-
+        nonexistent_app_id = str(uuid.uuid4())
         deleted_count = delete_draft_variables_batch(nonexistent_app_id, batch_size=100)
-
         assert deleted_count == 0
 
     def test_delete_draft_variables_wrapper_function(self, setup_test_data):
-        """Test that _delete_draft_variables wrapper function works correctly."""
         data = setup_test_data
         app1_id = data["app1"].id
 
-        # Verify initial state
-        vars_before = db.session.query(WorkflowDraftVariable).filter_by(app_id=app1_id).count()
+        with session_factory.create_session() as session:
+            vars_before = session.query(WorkflowDraftVariable).filter_by(app_id=app1_id).count()
         assert vars_before == 5
 
-        # Call wrapper function
         deleted_count = _delete_draft_variables(app1_id)
-
-        # Verify results
         assert deleted_count == 5
 
-        vars_after = db.session.query(WorkflowDraftVariable).filter_by(app_id=app1_id).count()
+        with session_factory.create_session() as session:
+            vars_after = session.query(WorkflowDraftVariable).filter_by(app_id=app1_id).count()
         assert vars_after == 0
 
     def test_batch_deletion_handles_large_dataset(self, app_and_tenant):
-        """Test batch deletion with larger dataset to verify batching logic."""
         tenant, app = app_and_tenant
-
-        # Create many draft variables
-        variables = []
-        for i in range(25):
-            var = WorkflowDraftVariable.new_node_variable(
-                app_id=app.id,
-                node_id=f"node_{i}",
-                name=f"var_{i}",
-                value=StringSegment(value="test_value"),
-                node_execution_id=str(uuid.uuid4()),
-            )
-            db.session.add(var)
-            variables.append(var)
-        variable_ids = [i.id for i in variables]
-
-        # Commit the variables to the database
-        db.session.commit()
+        variable_ids: list[str] = []
+        with session_factory.create_session() as session:
+            variables = []
+            for i in range(25):
+                var = WorkflowDraftVariable.new_node_variable(
+                    app_id=app.id,
+                    node_id=f"node_{i}",
+                    name=f"var_{i}",
+                    value=StringSegment(value="test_value"),
+                    node_execution_id=str(uuid.uuid4()),
+                )
+                session.add(var)
+                variables.append(var)
+            session.commit()
+            variable_ids = [v.id for v in variables]
 
         try:
-            # Use small batch size to force multiple batches
             deleted_count = delete_draft_variables_batch(app.id, batch_size=8)
-
             assert deleted_count == 25
-
-            # Verify all variables are deleted
-            remaining_vars = db.session.query(WorkflowDraftVariable).filter_by(app_id=app.id).count()
-            assert remaining_vars == 0
-
+            with session_factory.create_session() as session:
+                remaining = session.query(WorkflowDraftVariable).filter_by(app_id=app.id).count()
+            assert remaining == 0
         finally:
-            query = (
-                delete(WorkflowDraftVariable)
-                .where(
-                    WorkflowDraftVariable.id.in_(variable_ids),
+            with session_factory.create_session() as session:
+                query = (
+                    delete(WorkflowDraftVariable)
+                    .where(WorkflowDraftVariable.id.in_(variable_ids))
+                    .execution_options(synchronize_session=False)
                 )
-                .execution_options(synchronize_session=False)
-            )
-            db.session.execute(query)
+                session.execute(query)
+                session.commit()
 
 
 class TestDeleteDraftVariablesWithOffloadIntegration:
-    """Integration tests for draft variable deletion with Offload data."""
-
     @pytest.fixture
     def setup_offload_test_data(self, app_and_tenant):
-        """Create test data with draft variables that have associated Offload files."""
         tenant, app = app_and_tenant
-
-        # Create UploadFile records
+        from core.variables.types import SegmentType
         from libs.datetime_utils import naive_utc_now
 
-        upload_file1 = UploadFile(
-            tenant_id=tenant.id,
-            storage_type="local",
-            key="test/file1.json",
-            name="file1.json",
-            size=1024,
-            extension="json",
-            mime_type="application/json",
-            created_by_role=CreatorUserRole.ACCOUNT,
-            created_by=str(uuid.uuid4()),
-            created_at=naive_utc_now(),
-            used=False,
-        )
-        upload_file2 = UploadFile(
-            tenant_id=tenant.id,
-            storage_type="local",
-            key="test/file2.json",
-            name="file2.json",
-            size=2048,
-            extension="json",
-            mime_type="application/json",
-            created_by_role=CreatorUserRole.ACCOUNT,
-            created_by=str(uuid.uuid4()),
-            created_at=naive_utc_now(),
-            used=False,
-        )
-        db.session.add(upload_file1)
-        db.session.add(upload_file2)
-        db.session.flush()
+        with session_factory.create_session() as session:
+            upload_file1 = UploadFile(
+                tenant_id=tenant.id,
+                storage_type="local",
+                key="test/file1.json",
+                name="file1.json",
+                size=1024,
+                extension="json",
+                mime_type="application/json",
+                created_by_role=CreatorUserRole.ACCOUNT,
+                created_by=str(uuid.uuid4()),
+                created_at=naive_utc_now(),
+                used=False,
+            )
+            upload_file2 = UploadFile(
+                tenant_id=tenant.id,
+                storage_type="local",
+                key="test/file2.json",
+                name="file2.json",
+                size=2048,
+                extension="json",
+                mime_type="application/json",
+                created_by_role=CreatorUserRole.ACCOUNT,
+                created_by=str(uuid.uuid4()),
+                created_at=naive_utc_now(),
+                used=False,
+            )
+            session.add(upload_file1)
+            session.add(upload_file2)
+            session.flush()
 
-        # Create WorkflowDraftVariableFile records
-        from core.variables.types import SegmentType
+            var_file1 = WorkflowDraftVariableFile(
+                tenant_id=tenant.id,
+                app_id=app.id,
+                user_id=str(uuid.uuid4()),
+                upload_file_id=upload_file1.id,
+                size=1024,
+                length=10,
+                value_type=SegmentType.STRING,
+            )
+            var_file2 = WorkflowDraftVariableFile(
+                tenant_id=tenant.id,
+                app_id=app.id,
+                user_id=str(uuid.uuid4()),
+                upload_file_id=upload_file2.id,
+                size=2048,
+                length=20,
+                value_type=SegmentType.OBJECT,
+            )
+            session.add(var_file1)
+            session.add(var_file2)
+            session.flush()
 
-        var_file1 = WorkflowDraftVariableFile(
-            tenant_id=tenant.id,
-            app_id=app.id,
-            user_id=str(uuid.uuid4()),
-            upload_file_id=upload_file1.id,
-            size=1024,
-            length=10,
-            value_type=SegmentType.STRING,
-        )
-        var_file2 = WorkflowDraftVariableFile(
-            tenant_id=tenant.id,
-            app_id=app.id,
-            user_id=str(uuid.uuid4()),
-            upload_file_id=upload_file2.id,
-            size=2048,
-            length=20,
-            value_type=SegmentType.OBJECT,
-        )
-        db.session.add(var_file1)
-        db.session.add(var_file2)
-        db.session.flush()
+            draft_var1 = WorkflowDraftVariable.new_node_variable(
+                app_id=app.id,
+                node_id="node_1",
+                name="large_var_1",
+                value=StringSegment(value="truncated..."),
+                node_execution_id=str(uuid.uuid4()),
+                file_id=var_file1.id,
+            )
+            draft_var2 = WorkflowDraftVariable.new_node_variable(
+                app_id=app.id,
+                node_id="node_2",
+                name="large_var_2",
+                value=StringSegment(value="truncated..."),
+                node_execution_id=str(uuid.uuid4()),
+                file_id=var_file2.id,
+            )
+            draft_var3 = WorkflowDraftVariable.new_node_variable(
+                app_id=app.id,
+                node_id="node_3",
+                name="regular_var",
+                value=StringSegment(value="regular_value"),
+                node_execution_id=str(uuid.uuid4()),
+            )
+            session.add(draft_var1)
+            session.add(draft_var2)
+            session.add(draft_var3)
+            session.commit()
 
-        # Create WorkflowDraftVariable records with file associations
-        draft_var1 = WorkflowDraftVariable.new_node_variable(
-            app_id=app.id,
-            node_id="node_1",
-            name="large_var_1",
-            value=StringSegment(value="truncated..."),
-            node_execution_id=str(uuid.uuid4()),
-            file_id=var_file1.id,
-        )
-        draft_var2 = WorkflowDraftVariable.new_node_variable(
-            app_id=app.id,
-            node_id="node_2",
-            name="large_var_2",
-            value=StringSegment(value="truncated..."),
-            node_execution_id=str(uuid.uuid4()),
-            file_id=var_file2.id,
-        )
-        # Create a regular variable without Offload data
-        draft_var3 = WorkflowDraftVariable.new_node_variable(
-            app_id=app.id,
-            node_id="node_3",
-            name="regular_var",
-            value=StringSegment(value="regular_value"),
-            node_execution_id=str(uuid.uuid4()),
-        )
+            data = {
+                "app": app,
+                "tenant": tenant,
+                "upload_files": [upload_file1, upload_file2],
+                "variable_files": [var_file1, var_file2],
+                "draft_variables": [draft_var1, draft_var2, draft_var3],
+            }
 
-        db.session.add(draft_var1)
-        db.session.add(draft_var2)
-        db.session.add(draft_var3)
-        db.session.commit()
+        yield data
 
-        yield {
-            "app": app,
-            "tenant": tenant,
-            "upload_files": [upload_file1, upload_file2],
-            "variable_files": [var_file1, var_file2],
-            "draft_variables": [draft_var1, draft_var2, draft_var3],
-        }
-
-        # Cleanup
-        db.session.rollback()
-
-        # Clean up any remaining records
-        for table, ids in [
-            (WorkflowDraftVariable, [v.id for v in [draft_var1, draft_var2, draft_var3]]),
-            (WorkflowDraftVariableFile, [vf.id for vf in [var_file1, var_file2]]),
-            (UploadFile, [uf.id for uf in [upload_file1, upload_file2]]),
-        ]:
-            cleanup_query = delete(table).where(table.id.in_(ids)).execution_options(synchronize_session=False)
-            db.session.execute(cleanup_query)
-
-        db.session.commit()
+        with session_factory.create_session() as session:
+            session.rollback()
+            for table, ids in [
+                (WorkflowDraftVariable, [v.id for v in data["draft_variables"]]),
+                (WorkflowDraftVariableFile, [vf.id for vf in data["variable_files"]]),
+                (UploadFile, [uf.id for uf in data["upload_files"]]),
+            ]:
+                cleanup_query = delete(table).where(table.id.in_(ids)).execution_options(synchronize_session=False)
+                session.execute(cleanup_query)
+            session.commit()
 
     @patch("extensions.ext_storage.storage")
     def test_delete_draft_variables_with_offload_data(self, mock_storage, setup_offload_test_data):
-        """Test that deleting draft variables also cleans up associated Offload data."""
         data = setup_offload_test_data
         app_id = data["app"].id
-
-        # Mock storage deletion to succeed
         mock_storage.delete.return_value = None
 
-        # Verify initial state
-        draft_vars_before = db.session.query(WorkflowDraftVariable).filter_by(app_id=app_id).count()
-        var_files_before = db.session.query(WorkflowDraftVariableFile).count()
-        upload_files_before = db.session.query(UploadFile).count()
-
-        assert draft_vars_before == 3  # 2 with files + 1 regular
+        with session_factory.create_session() as session:
+            draft_vars_before = session.query(WorkflowDraftVariable).filter_by(app_id=app_id).count()
+            var_files_before = session.query(WorkflowDraftVariableFile).count()
+            upload_files_before = session.query(UploadFile).count()
+        assert draft_vars_before == 3
         assert var_files_before == 2
         assert upload_files_before == 2
 
-        # Delete draft variables
         deleted_count = delete_draft_variables_batch(app_id, batch_size=10)
-
-        # Verify results
         assert deleted_count == 3
 
-        # Check that all draft variables are deleted
-        draft_vars_after = db.session.query(WorkflowDraftVariable).filter_by(app_id=app_id).count()
+        with session_factory.create_session() as session:
+            draft_vars_after = session.query(WorkflowDraftVariable).filter_by(app_id=app_id).count()
         assert draft_vars_after == 0
 
-        # Check that associated Offload data is cleaned up
-        var_files_after = db.session.query(WorkflowDraftVariableFile).count()
-        upload_files_after = db.session.query(UploadFile).count()
+        with session_factory.create_session() as session:
+            var_files_after = session.query(WorkflowDraftVariableFile).count()
+            upload_files_after = session.query(UploadFile).count()
+        assert var_files_after == 0
+        assert upload_files_after == 0
 
-        assert var_files_after == 0  # All variable files should be deleted
-        assert upload_files_after == 0  # All upload files should be deleted
-
-        # Verify storage deletion was called for both files
         assert mock_storage.delete.call_count == 2
         storage_keys_deleted = [call.args[0] for call in mock_storage.delete.call_args_list]
         assert "test/file1.json" in storage_keys_deleted
@@ -379,92 +327,71 @@ class TestDeleteDraftVariablesWithOffloadIntegration:
 
     @patch("extensions.ext_storage.storage")
     def test_delete_draft_variables_storage_failure_continues_cleanup(self, mock_storage, setup_offload_test_data):
-        """Test that database cleanup continues even when storage deletion fails."""
         data = setup_offload_test_data
         app_id = data["app"].id
-
-        # Mock storage deletion to fail for first file, succeed for second
         mock_storage.delete.side_effect = [Exception("Storage error"), None]
 
-        # Delete draft variables
         deleted_count = delete_draft_variables_batch(app_id, batch_size=10)
-
-        # Verify that all draft variables are still deleted
         assert deleted_count == 3
 
-        draft_vars_after = db.session.query(WorkflowDraftVariable).filter_by(app_id=app_id).count()
+        with session_factory.create_session() as session:
+            draft_vars_after = session.query(WorkflowDraftVariable).filter_by(app_id=app_id).count()
         assert draft_vars_after == 0
 
-        # Database cleanup should still succeed even with storage errors
-        var_files_after = db.session.query(WorkflowDraftVariableFile).count()
-        upload_files_after = db.session.query(UploadFile).count()
-
+        with session_factory.create_session() as session:
+            var_files_after = session.query(WorkflowDraftVariableFile).count()
+            upload_files_after = session.query(UploadFile).count()
         assert var_files_after == 0
         assert upload_files_after == 0
 
-        # Verify storage deletion was attempted for both files
         assert mock_storage.delete.call_count == 2
 
     @patch("extensions.ext_storage.storage")
     def test_delete_draft_variables_partial_offload_data(self, mock_storage, setup_offload_test_data):
-        """Test deletion with mix of variables with and without Offload data."""
         data = setup_offload_test_data
         app_id = data["app"].id
-
-        # Create additional app with only regular variables (no offload data)
         tenant = data["tenant"]
-        app2 = App(
-            tenant_id=tenant.id,
-            name="Test App 2",
-            mode="workflow",
-            enable_site=True,
-            enable_api=True,
-        )
-        db.session.add(app2)
-        db.session.flush()
 
-        # Add regular variables to app2
-        regular_vars = []
-        for i in range(3):
-            var = WorkflowDraftVariable.new_node_variable(
-                app_id=app2.id,
-                node_id=f"node_{i}",
-                name=f"var_{i}",
-                value=StringSegment(value="regular_value"),
-                node_execution_id=str(uuid.uuid4()),
+        with session_factory.create_session() as session:
+            app2 = App(
+                tenant_id=tenant.id,
+                name="Test App 2",
+                mode="workflow",
+                enable_site=True,
+                enable_api=True,
             )
-            db.session.add(var)
-            regular_vars.append(var)
-        db.session.commit()
+            session.add(app2)
+            session.flush()
+
+            for i in range(3):
+                var = WorkflowDraftVariable.new_node_variable(
+                    app_id=app2.id,
+                    node_id=f"node_{i}",
+                    name=f"var_{i}",
+                    value=StringSegment(value="regular_value"),
+                    node_execution_id=str(uuid.uuid4()),
+                )
+                session.add(var)
+            session.commit()
 
         try:
-            # Mock storage deletion
             mock_storage.delete.return_value = None
-
-            # Delete variables for app2 (no offload data)
             deleted_count_app2 = delete_draft_variables_batch(app2.id, batch_size=10)
             assert deleted_count_app2 == 3
-
-            # Verify storage wasn't called for app2 (no offload files)
             mock_storage.delete.assert_not_called()
 
-            # Delete variables for original app (with offload data)
             deleted_count_app1 = delete_draft_variables_batch(app_id, batch_size=10)
             assert deleted_count_app1 == 3
-
-            # Now storage should be called for the offload files
             assert mock_storage.delete.call_count == 2
-
         finally:
-            # Cleanup app2 and its variables
-            cleanup_vars_query = (
-                delete(WorkflowDraftVariable)
-                .where(WorkflowDraftVariable.app_id == app2.id)
-                .execution_options(synchronize_session=False)
-            )
-            db.session.execute(cleanup_vars_query)
-
-            app2_obj = db.session.get(App, app2.id)
-            if app2_obj:
-                db.session.delete(app2_obj)
-            db.session.commit()
+            with session_factory.create_session() as session:
+                cleanup_vars_query = (
+                    delete(WorkflowDraftVariable)
+                    .where(WorkflowDraftVariable.app_id == app2.id)
+                    .execution_options(synchronize_session=False)
+                )
+                session.execute(cleanup_vars_query)
+                app2_obj = session.get(App, app2.id)
+                if app2_obj:
+                    session.delete(app2_obj)
+                session.commit()

api/tests/integration_tests/workflow/nodes/code_executor/test_code_jinja2.py

@@ -7,11 +7,14 @@ CODE_LANGUAGE = CodeLanguage.JINJA2
 
 
 def test_jinja2():
+    """Test basic Jinja2 template rendering."""
     template = "Hello {{template}}"
+    # Template must be base64 encoded to match the new safe embedding approach
+    template_b64 = base64.b64encode(template.encode("utf-8")).decode("utf-8")
     inputs = base64.b64encode(b'{"template": "World"}').decode("utf-8")
     code = (
         Jinja2TemplateTransformer.get_runner_script()
-        .replace(Jinja2TemplateTransformer._code_placeholder, template)
+        .replace(Jinja2TemplateTransformer._template_b64_placeholder, template_b64)
         .replace(Jinja2TemplateTransformer._inputs_placeholder, inputs)
     )
     result = CodeExecutor.execute_code(
@@ -21,6 +24,7 @@ def test_jinja2():
 
 
 def test_jinja2_with_code_template():
+    """Test template rendering via the high-level workflow API."""
     result = CodeExecutor.execute_workflow_code_template(
         language=CODE_LANGUAGE, code="Hello {{template}}", inputs={"template": "World"}
     )
@@ -28,7 +32,64 @@ def test_jinja2_with_code_template():
 
 
 def test_jinja2_get_runner_script():
+    """Test that runner script contains required placeholders."""
     runner_script = Jinja2TemplateTransformer.get_runner_script()
-    assert runner_script.count(Jinja2TemplateTransformer._code_placeholder) == 1
+    assert runner_script.count(Jinja2TemplateTransformer._template_b64_placeholder) == 1
     assert runner_script.count(Jinja2TemplateTransformer._inputs_placeholder) == 1
     assert runner_script.count(Jinja2TemplateTransformer._result_tag) == 2
+
+
+def test_jinja2_template_with_special_characters():
+    """
+    Test that templates with special characters (quotes, newlines) render correctly.
+    This is a regression test for issue #26818 where textarea pre-fill values
+    containing special characters would break template rendering.
+    """
+    # Template with triple quotes, single quotes, double quotes, and newlines
+    template = """<html>
+<body>
+    <input value="{{ task.get('Task ID', '') }}"/>
+    <textarea>{{ task.get('Issues', 'No issues reported') }}</textarea>
+    <p>Status: "{{ status }}"</p>
+    <pre>'''code block'''</pre>
+</body>
+</html>"""
+    inputs = {"task": {"Task ID": "TASK-123", "Issues": "Line 1\nLine 2\nLine 3"}, "status": "completed"}
+
+    result = CodeExecutor.execute_workflow_code_template(language=CODE_LANGUAGE, code=template, inputs=inputs)
+
+    # Verify the template rendered correctly with all special characters
+    output = result["result"]
+    assert 'value="TASK-123"' in output
+    assert "<textarea>Line 1\nLine 2\nLine 3</textarea>" in output
+    assert 'Status: "completed"' in output
+    assert "'''code block'''" in output
+
+
+def test_jinja2_template_with_html_textarea_prefill():
+    """
+    Specific test for HTML textarea with Jinja2 variable pre-fill.
+    Verifies fix for issue #26818.
+    """
+    template = "<textarea name='notes'>{{ notes }}</textarea>"
+    notes_content = "This is a multi-line note.\nWith special chars: 'single' and \"double\" quotes."
+    inputs = {"notes": notes_content}
+
+    result = CodeExecutor.execute_workflow_code_template(language=CODE_LANGUAGE, code=template, inputs=inputs)
+
+    expected_output = f"<textarea name='notes'>{notes_content}</textarea>"
+    assert result["result"] == expected_output
+
+
+def test_jinja2_assemble_runner_script_encodes_template():
+    """Test that assemble_runner_script properly base64 encodes the template."""
+    template = "Hello {{ name }}!"
+    inputs = {"name": "World"}
+
+    script = Jinja2TemplateTransformer.assemble_runner_script(template, inputs)
+
+    # The template should be base64 encoded in the script
+    template_b64 = base64.b64encode(template.encode("utf-8")).decode("utf-8")
+    assert template_b64 in script
+    # The raw template should NOT appear in the script (it's encoded)
+    assert "Hello {{ name }}!" not in script

api/tests/integration_tests/workflow/nodes/test_code.py

@@ -5,12 +5,13 @@ import pytest
 
 from configs import dify_config
 from core.app.entities.app_invoke_entities import InvokeFrom
+from core.app.workflow.node_factory import DifyNodeFactory
 from core.workflow.entities import GraphInitParams
 from core.workflow.enums import WorkflowNodeExecutionStatus
 from core.workflow.graph import Graph
 from core.workflow.node_events import NodeRunResult
 from core.workflow.nodes.code.code_node import CodeNode
-from core.workflow.nodes.node_factory import DifyNodeFactory
+from core.workflow.nodes.code.limits import CodeNodeLimits
 from core.workflow.runtime import GraphRuntimeState, VariablePool
 from core.workflow.system_variable import SystemVariable
 from models.enums import UserFrom
@@ -67,6 +68,16 @@ def init_code_node(code_config: dict):
         config=code_config,
         graph_init_params=init_params,
         graph_runtime_state=graph_runtime_state,
+        code_limits=CodeNodeLimits(
+            max_string_length=dify_config.CODE_MAX_STRING_LENGTH,
+            max_number=dify_config.CODE_MAX_NUMBER,
+            min_number=dify_config.CODE_MIN_NUMBER,
+            max_precision=dify_config.CODE_MAX_PRECISION,
+            max_depth=dify_config.CODE_MAX_DEPTH,
+            max_number_array_length=dify_config.CODE_MAX_NUMBER_ARRAY_LENGTH,
+            max_string_array_length=dify_config.CODE_MAX_STRING_ARRAY_LENGTH,
+            max_object_array_length=dify_config.CODE_MAX_OBJECT_ARRAY_LENGTH,
+        ),
     )
 
     return node

api/tests/integration_tests/workflow/nodes/test_http.py

@@ -5,11 +5,11 @@ from urllib.parse import urlencode
 import pytest
 
 from core.app.entities.app_invoke_entities import InvokeFrom
+from core.app.workflow.node_factory import DifyNodeFactory
 from core.workflow.entities import GraphInitParams
 from core.workflow.enums import WorkflowNodeExecutionStatus
 from core.workflow.graph import Graph
 from core.workflow.nodes.http_request.node import HttpRequestNode
-from core.workflow.nodes.node_factory import DifyNodeFactory
 from core.workflow.runtime import GraphRuntimeState, VariablePool
 from core.workflow.system_variable import SystemVariable
 from models.enums import UserFrom

api/tests/integration_tests/workflow/nodes/test_llm.py

@@ -5,13 +5,13 @@ from collections.abc import Generator
 from unittest.mock import MagicMock, patch
 
 from core.app.entities.app_invoke_entities import InvokeFrom
+from core.app.workflow.node_factory import DifyNodeFactory
 from core.llm_generator.output_parser.structured_output import _parse_structured_output
 from core.workflow.entities import GraphInitParams
 from core.workflow.enums import WorkflowNodeExecutionStatus
 from core.workflow.graph import Graph
 from core.workflow.node_events import StreamCompletedEvent
 from core.workflow.nodes.llm.node import LLMNode
-from core.workflow.nodes.node_factory import DifyNodeFactory
 from core.workflow.runtime import GraphRuntimeState, VariablePool
 from core.workflow.system_variable import SystemVariable
 from extensions.ext_database import db

api/tests/integration_tests/workflow/nodes/test_parameter_extractor.py

@@ -4,11 +4,11 @@ import uuid
 from unittest.mock import MagicMock
 
 from core.app.entities.app_invoke_entities import InvokeFrom
+from core.app.workflow.node_factory import DifyNodeFactory
 from core.model_runtime.entities import AssistantPromptMessage
 from core.workflow.entities import GraphInitParams
 from core.workflow.enums import WorkflowNodeExecutionStatus
 from core.workflow.graph import Graph
-from core.workflow.nodes.node_factory import DifyNodeFactory
 from core.workflow.nodes.parameter_extractor.parameter_extractor_node import ParameterExtractorNode
 from core.workflow.runtime import GraphRuntimeState, VariablePool
 from core.workflow.system_variable import SystemVariable

api/tests/integration_tests/workflow/nodes/test_template_transform.py

@@ -4,10 +4,10 @@ import uuid
 import pytest
 
 from core.app.entities.app_invoke_entities import InvokeFrom
+from core.app.workflow.node_factory import DifyNodeFactory
 from core.workflow.entities import GraphInitParams
 from core.workflow.enums import WorkflowNodeExecutionStatus
 from core.workflow.graph import Graph
-from core.workflow.nodes.node_factory import DifyNodeFactory
 from core.workflow.nodes.template_transform.template_transform_node import TemplateTransformNode
 from core.workflow.runtime import GraphRuntimeState, VariablePool
 from core.workflow.system_variable import SystemVariable

api/tests/integration_tests/workflow/nodes/test_tool.py

@@ -3,12 +3,12 @@ import uuid
 from unittest.mock import MagicMock
 
 from core.app.entities.app_invoke_entities import InvokeFrom
+from core.app.workflow.node_factory import DifyNodeFactory
 from core.tools.utils.configuration import ToolParameterConfigurationManager
 from core.workflow.entities import GraphInitParams
 from core.workflow.enums import WorkflowNodeExecutionStatus
 from core.workflow.graph import Graph
 from core.workflow.node_events import StreamCompletedEvent
-from core.workflow.nodes.node_factory import DifyNodeFactory
 from core.workflow.nodes.tool.tool_node import ToolNode
 from core.workflow.runtime import GraphRuntimeState, VariablePool
 from core.workflow.system_variable import SystemVariable