Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

test(api): remove duplicate and implementation-only coverage (#42803)

-LAN-1d76929d5aad
diff --git a/api/tests/unit_tests/controllers/service_api/app/test_workflow.py b/api/tests/unit_tests/controllers/service_api/app/test_workflow.py
index ba8f2d8582a..1f8e56a348f 100644
--- a/api/tests/unit_tests/controllers/service_api/app/test_workflow.py
+++ b/api/tests/unit_tests/controllers/service_api/app/test_workflow.py
@@ -20,7 +20,7 @@ from collections.abc import Callable
from datetime import UTC, datetime
from inspect import unwrap
from types import SimpleNamespace
-from unittest.mock import MagicMock, Mock, patch
+from unittest.mock import MagicMock, Mock
import pytest
from flask import Flask
@@ -47,7 +47,6 @@ from controllers.service_api.app.workflow import (
WorkflowTaskStopApi,
)
from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError
-from core.app.entities.app_invoke_entities import InvokeFrom
from enums import CloudPlan, DeploymentEdition
from graphon.enums import WorkflowExecutionStatus
from graphon.model_runtime.errors.invoke import InvokeRateLimitError as ProviderInvokeRateLimitError
@@ -377,123 +376,9 @@ class TestWorkflowRunResponse:
}
-class TestWorkflowExecutionStatus:
- """Test WorkflowExecutionStatus enum."""
-
- def test_succeeded_status_exists(self):
- """Test succeeded status value exists."""
- status = WorkflowExecutionStatus("succeeded")
- assert status.value == "succeeded"
-
- def test_failed_status_exists(self):
- """Test failed status value exists."""
- status = WorkflowExecutionStatus("failed")
- assert status.value == "failed"
-
- def test_stopped_status_exists(self):
- """Test stopped status value exists."""
- status = WorkflowExecutionStatus("stopped")
- assert status.value == "stopped"
-
-
-class TestAppGenerateServiceWorkflow:
- """Test AppGenerateService workflow integration."""
-
- @pytest.mark.parametrize("sqlite_session", [()], indirect=True)
- @patch.object(AppGenerateService, "generate")
- def test_generate_accepts_workflow_args(self, mock_generate: MagicMock, sqlite_session: Session):
- """Test generate accepts workflow-specific args."""
- mock_generate.return_value = {"result": "success"}
-
- result = AppGenerateService.generate(
- app_model=_make_app_model(),
- user=_make_end_user(),
- args={"inputs": {"key": "value"}, "workflow_id": "workflow_123"},
- invoke_from=InvokeFrom.SERVICE_API,
- session=sqlite_session,
- streaming=False,
- )
-
- assert result == {"result": "success"}
- mock_generate.assert_called_once()
- assert mock_generate.call_args.kwargs["session"] is sqlite_session
-
- @pytest.mark.parametrize("sqlite_session", [()], indirect=True)
- @patch.object(AppGenerateService, "generate")
- def test_generate_raises_workflow_not_found_error(self, mock_generate: MagicMock, sqlite_session: Session):
- """Test generate raises WorkflowNotFoundError."""
- mock_generate.side_effect = WorkflowNotFoundError("Workflow not found")
-
- with pytest.raises(WorkflowNotFoundError):
- AppGenerateService.generate(
- app_model=_make_app_model(),
- user=_make_end_user(),
- args={"workflow_id": "invalid_id"},
- invoke_from=InvokeFrom.SERVICE_API,
- session=sqlite_session,
- streaming=False,
- )
-
- @pytest.mark.parametrize("sqlite_session", [()], indirect=True)
- @patch.object(AppGenerateService, "generate")
- def test_generate_raises_is_draft_workflow_error(self, mock_generate: MagicMock, sqlite_session: Session):
- """Test generate raises IsDraftWorkflowError."""
- mock_generate.side_effect = IsDraftWorkflowError("Workflow is draft")
-
- with pytest.raises(IsDraftWorkflowError):
- AppGenerateService.generate(
- app_model=_make_app_model(),
- user=_make_end_user(),
- args={"workflow_id": "draft_workflow"},
- invoke_from=InvokeFrom.SERVICE_API,
- session=sqlite_session,
- streaming=False,
- )
-
- @pytest.mark.parametrize("sqlite_session", [()], indirect=True)
- @patch.object(AppGenerateService, "generate")
- def test_generate_supports_streaming_mode(self, mock_generate: MagicMock, sqlite_session: Session):
- """Test generate supports streaming response mode."""
- mock_stream = Mock()
- mock_generate.return_value = mock_stream
-
- result = AppGenerateService.generate(
- app_model=_make_app_model(),
- user=_make_end_user(),
- args={"inputs": {}, "response_mode": "streaming"},
- invoke_from=InvokeFrom.SERVICE_API,
- session=sqlite_session,
- streaming=True,
- )
-
- assert result == mock_stream
-
-
-class TestWorkflowStopMechanism:
- """Test workflow stop mechanisms."""
-
- def test_app_queue_manager_has_stop_flag_method(self):
- """Test AppQueueManager has set_stop_flag_no_user_check method."""
- from core.app.apps.base_app_queue_manager import AppQueueManager
-
- assert hasattr(AppQueueManager, "set_stop_flag_no_user_check")
-
- def test_graph_engine_manager_has_send_stop_command(self):
- """Test GraphEngineManager has send_stop_command method."""
- from graphon.graph_engine.manager import GraphEngineManager
-
- assert hasattr(GraphEngineManager, "send_stop_command")
-
-
class TestWorkflowRunRepository:
"""Test workflow run repository interface."""
- def test_repository_factory_can_create_workflow_run_repository(self):
- """Test DifyAPIRepositoryFactory can create workflow run repository."""
- from repositories.factory import DifyAPIRepositoryFactory
-
- assert hasattr(DifyAPIRepositoryFactory, "create_api_workflow_run_repository")
-
@pytest.mark.parametrize("sqlite_session", [(WorkflowRun,)], indirect=True)
def test_workflow_run_repository_get_by_id(self, sqlite_engine: Engine, sqlite_session: Session):
"""Test repository lookup against committed tenant-scoped state."""
@@ -827,10 +712,11 @@ class TestWorkflowRunByIdApi:
class TestWorkflowTaskStopApi:
- def test_wrong_mode(self, app: Flask) -> None:
+ @pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.COMPLETION])
+ def test_wrong_mode(self, app: Flask, mode: AppMode) -> None:
api = WorkflowTaskStopApi()
handler = unwrap(api.post)
- app_model = _make_app_model(mode=AppMode.CHAT)
+ app_model = _make_app_model(mode=mode)
end_user = _make_end_user()
with app.test_request_context("/workflows/tasks/1/stop", method="POST"):
@@ -960,50 +846,6 @@ class TestWorkflowRunDetailApiGet:
unwrap(api.get)(api, app_model=app_model, workflow_run_id="run-1")
-class TestWorkflowTaskStopApiPost:
- """Test suite for WorkflowTaskStopApi.post() endpoint.
-
- ``post`` is wrapped by ``@validate_app_token(fetch_user_arg=...)``.
- """
-
- @patch("controllers.service_api.app.workflow.GraphEngineManager")
- @patch("controllers.service_api.app.workflow.AppQueueManager")
- def test_stop_workflow_task_success(
- self,
- mock_queue_mgr,
- mock_graph_mgr,
- app: Flask,
- workflow_app: App,
- ):
- """Test successful workflow task stop."""
- from controllers.service_api.app.workflow import WorkflowTaskStopApi
-
- with app.test_request_context("/workflows/tasks/task-1/stop", method="POST"):
- api = WorkflowTaskStopApi()
- result = unwrap(api.post)(
- api,
- app_model=workflow_app,
- end_user=_make_end_user(),
- task_id="task-1",
- )
-
- assert result == {"result": "success"}
- mock_queue_mgr.set_stop_flag_no_user_check.assert_called_once_with("task-1")
- mock_graph_mgr.assert_called_once()
- mock_graph_mgr.return_value.send_stop_command.assert_called_once_with("task-1")
-
- def test_stop_workflow_task_wrong_app_mode(self, app: Flask):
- """Test NotWorkflowAppError when app mode is not workflow."""
- from controllers.service_api.app.workflow import WorkflowTaskStopApi
-
- app_model = _make_app_model(mode=AppMode.COMPLETION)
-
- with app.test_request_context("/workflows/tasks/task-1/stop", method="POST"):
- api = WorkflowTaskStopApi()
- with pytest.raises(NotWorkflowAppError):
- unwrap(api.post)(api, app_model=app_model, end_user=_make_end_user(), task_id="task-1")
-
-
class TestWorkflowAppLogApiGet:
"""Test suite for WorkflowAppLogApi.get() endpoint.
diff --git a/api/tests/unit_tests/core/app/apps/workflow/test_app_queue_manager.py b/api/tests/unit_tests/core/app/apps/workflow/test_app_queue_manager.py
index fb92e098702..6d329724fc5 100644
--- a/api/tests/unit_tests/core/app/apps/workflow/test_app_queue_manager.py
+++ b/api/tests/unit_tests/core/app/apps/workflow/test_app_queue_manager.py
@@ -1,7 +1,7 @@
from __future__ import annotations
from collections.abc import Callable
-from unittest.mock import Mock, patch
+from unittest.mock import patch
from core.app.apps.base_app_queue_manager import PublishFrom
from core.app.apps.execution_coordinator import AppExecutionState
@@ -33,29 +33,6 @@ class TestWorkflowAppQueueManager:
stop_listen.assert_called_once()
is_stopped.assert_not_called()
- def test_publish_non_stop_event_does_not_raise(self):
- manager = WorkflowAppQueueManager(
- task_id="task",
- user_id="user",
- invoke_from=InvokeFrom.DEBUGGER,
- app_mode="workflow",
- )
-
- manager._publish(QueuePingEvent(), PublishFrom.TASK_PIPELINE)
-
- def test_publish_pause_event_marks_listener_as_paused(self):
- manager = WorkflowAppQueueManager(
- task_id="task",
- user_id="user",
- invoke_from=InvokeFrom.DEBUGGER,
- app_mode="workflow",
- )
- manager.stop_listen = Mock()
-
- manager._publish(QueueWorkflowPausedEvent(), PublishFrom.APPLICATION_MANAGER)
-
- manager.stop_listen.assert_called_once_with(execution_state=AppExecutionState.PAUSED)
-
def test_listener_close_does_not_abort_unfinished_execution(self):
with (
patch("core.app.apps.base_app_queue_manager.redis_client") as queue_redis,
diff --git a/api/tests/unit_tests/core/app/apps/workflow/test_command_channels.py b/api/tests/unit_tests/core/app/apps/workflow/test_command_channels.py
index 30d0afe6cfa..f555fe945c1 100644
--- a/api/tests/unit_tests/core/app/apps/workflow/test_command_channels.py
+++ b/api/tests/unit_tests/core/app/apps/workflow/test_command_channels.py
@@ -97,18 +97,6 @@ def test_celery_signal_command_channel_emits_abort_once_per_instance() -> None:
assert channel.fetch_commands() == []
-def test_celery_signal_command_channel_send_command_is_noop() -> None:
- channel = CelerySignalCommandChannel(
- shutdown_state_getter=lambda: False,
- abort_reason="worker shutdown",
- )
- command = PauseCommand(reason="pause")
-
- channel.send_command(command)
-
- assert channel.fetch_commands() == []
-
-
def test_stop_flag_command_channel_emits_abort_when_flag_is_set() -> None:
channel = StopFlagCommandChannel(task_id="task-1", abort_reason="User requested stop")
@@ -129,13 +117,3 @@ def test_stop_flag_command_channel_emits_abort_once_per_instance() -> None:
with patch("core.app.apps.workflow.command_channels.is_app_task_stop_flag_set", return_value=True):
assert len(channel.fetch_commands()) == 1
assert channel.fetch_commands() == []
-
-
-def test_stop_flag_command_channel_send_command_is_noop() -> None:
- channel = StopFlagCommandChannel(task_id="task-1")
- command = PauseCommand(reason="pause")
-
- channel.send_command(command)
-
- with patch("core.app.apps.workflow.command_channels.is_app_task_stop_flag_set", return_value=False):
- assert channel.fetch_commands() == []
diff --git a/api/tests/unit_tests/core/app/apps/workflow/test_stop_aware_ready_queue.py b/api/tests/unit_tests/core/app/apps/workflow/test_stop_aware_ready_queue.py
index 90737cd25ff..6dc1781cc00 100644
--- a/api/tests/unit_tests/core/app/apps/workflow/test_stop_aware_ready_queue.py
+++ b/api/tests/unit_tests/core/app/apps/workflow/test_stop_aware_ready_queue.py
@@ -76,23 +76,3 @@ def test_attach_stop_aware_ready_queue_wraps_once() -> None:
assert isinstance(first, StopAwareReadyQueue)
assert runtime_state.ready_queue is first
-
-
-def test_stop_aware_queue_delegates_reads() -> None:
- inner = Mock()
- inner.get.return_value = _start_task("queued")
- inner.qsize.return_value = 1
- inner.drain.return_value = [_start_task("queued")]
- inner.dumps.return_value = "{}"
- queue = StopAwareReadyQueue(inner, task_id="task-1", graph_execution=_graph_execution())
-
- assert queue.get(timeout=0.1) == _start_task("queued")
- queue.task_done()
- assert queue.qsize() == 1
- assert queue.drain() == [_start_task("queued")]
- assert queue.dumps() == "{}"
- queue.loads("{}")
-
- inner.get.assert_called_once_with(timeout=0.1)
- inner.task_done.assert_called_once()
- inner.loads.assert_called_once_with("{}")
diff --git a/api/tests/unit_tests/core/app/workflow/test_observability_layer_extra.py b/api/tests/unit_tests/core/app/workflow/test_observability_layer_extra.py
index d13dea0c7b7..53f2763e4a3 100644
--- a/api/tests/unit_tests/core/app/workflow/test_observability_layer_extra.py
+++ b/api/tests/unit_tests/core/app/workflow/test_observability_layer_extra.py
@@ -10,17 +10,6 @@ from tests.unit_tests.config_override import apply_config_overrides
class TestObservabilityLayerExtras:
- def test_init_tracer_enabled_sets_tracer(self, monkeypatch: pytest.MonkeyPatch):
- tracer = object()
- apply_config_overrides(monkeypatch, ENABLE_OTEL=True)
- monkeypatch.setattr("core.app.workflow.layers.observability.is_instrument_flag_enabled", lambda: False)
- monkeypatch.setattr("core.app.workflow.layers.observability.get_tracer", lambda _: tracer)
-
- layer = ObservabilityLayer()
-
- assert layer._is_disabled is False
- assert layer._tracer is tracer
-
def test_init_tracer_disables_when_get_tracer_fails(
self, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
):
@@ -38,14 +27,6 @@ class TestObservabilityLayerExtras:
assert layer._tracer is None
assert "Failed to get OpenTelemetry tracer" in caplog.text
- def test_init_tracer_disables_when_otel_disabled(self, monkeypatch: pytest.MonkeyPatch):
- apply_config_overrides(monkeypatch, ENABLE_OTEL=False)
- monkeypatch.setattr("core.app.workflow.layers.observability.is_instrument_flag_enabled", lambda: False)
-
- layer = ObservabilityLayer()
-
- assert layer._is_disabled is True
-
def test_get_parser_uses_registry_when_node_type_matches(self):
layer = ObservabilityLayer()
diff --git a/api/tests/unit_tests/core/workflow/nodes/agent/test_agent_entities.py b/api/tests/unit_tests/core/workflow/nodes/agent/test_agent_entities.py
index 023fccbefd3..e94a728b68c 100644
--- a/api/tests/unit_tests/core/workflow/nodes/agent/test_agent_entities.py
+++ b/api/tests/unit_tests/core/workflow/nodes/agent/test_agent_entities.py
@@ -1,6 +1,5 @@
from core.app.entities.app_invoke_entities import InvokeFrom, UserFrom, build_dify_run_context
from core.workflow.node_factory import DifyNodeFactory
-from core.workflow.nodes.agent.entities import AgentNodeData
from graphon.entities import GraphInitParams
from graphon.graph import Graph
from graphon.graph_engine import GraphEngine, GraphEngineConfig
@@ -9,15 +8,6 @@ from graphon.graph_events import GraphNodeEventBase, GraphRunSucceededEvent
from graphon.runtime import GraphRuntimeState, VariablePool
-def test_agent_node_data_unconfigured_defaults() -> None:
- data = AgentNodeData.model_validate({"title": "Agent"})
-
- assert data.agent_strategy_provider_name == ""
- assert data.agent_strategy_name == ""
- assert data.agent_strategy_label == ""
- assert not data.agent_parameters
-
-
def test_unconfigured_disconnected_agent_does_not_block_workflow() -> None:
graph_config: dict[str, object] = {
"nodes": [
diff --git a/api/tests/unit_tests/core/workflow/nodes/code/code_node_spec.py b/api/tests/unit_tests/core/workflow/nodes/code/code_node_spec.py
index ce0c9b79c68..01018555c0b 100644
--- a/api/tests/unit_tests/core/workflow/nodes/code/code_node_spec.py
+++ b/api/tests/unit_tests/core/workflow/nodes/code/code_node_spec.py
@@ -144,27 +144,6 @@ class TestCodeNodeCheckMethods:
assert result == "你好世界🌍"
- def test_check_boolean_none_value(self):
- """Test _check_boolean with None value."""
- node = CodeNode.__new__(CodeNode)
- result = node._check_boolean(None, "test_var")
-
- assert result is None
-
- def test_check_boolean_true_value(self):
- """Test _check_boolean with True value."""
- node = CodeNode.__new__(CodeNode)
- result = node._check_boolean(True, "test_var")
-
- assert result is True
-
- def test_check_boolean_false_value(self):
- """Test _check_boolean with False value."""
- node = CodeNode.__new__(CodeNode)
- result = node._check_boolean(False, "test_var")
-
- assert result is False
-
def test_check_number_none_value(self):
"""Test _check_number with None value."""
node = CodeNode.__new__(CodeNode)
diff --git a/api/tests/unit_tests/core/workflow/nodes/knowledge_index/test_knowledge_index_node.py b/api/tests/unit_tests/core/workflow/nodes/knowledge_index/test_knowledge_index_node.py
index f131987c189..5906a555343 100644
--- a/api/tests/unit_tests/core/workflow/nodes/knowledge_index/test_knowledge_index_node.py
+++ b/api/tests/unit_tests/core/workflow/nodes/knowledge_index/test_knowledge_index_node.py
@@ -120,35 +120,6 @@ class TestKnowledgeIndexNode:
Test suite for KnowledgeIndexNode.
"""
- def test_node_initialization(
- self, mock_graph_init_params, mock_graph_runtime_state, mock_index_processor, mock_summary_index_service
- ):
- """Test KnowledgeIndexNode initialization."""
- # Arrange
- node_id = str(uuid.uuid4())
- config = {
- "id": node_id,
- "data": {
- "title": "Knowledge Index",
- "type": "knowledge-index",
- "chunk_structure": "general_structure",
- "index_chunk_variable_selector": ["start", "chunks"],
- },
- }
-
- # Act
- node = _build_node(
- node_id=node_id,
- node_data=config["data"],
- graph_init_params=mock_graph_init_params,
- graph_runtime_state=mock_graph_runtime_state,
- )
-
- # Assert
- assert node.id == node_id
- assert node.index_processor == mock_index_processor
- assert node.summary_index_service == mock_summary_index_service
-
def test_run_without_dataset_id(
self,
mock_graph_init_params,
@@ -586,14 +557,6 @@ class TestKnowledgeIndexNode:
assert commits == ["commit"]
assert result == {"status": "indexed"}
- def test_version_method(self):
- """Test version class method."""
- # Act
- version = KnowledgeIndexNode.version()
-
- # Assert
- assert version == "1"
-
def test_get_streaming_template(
self,
mock_graph_init_params,
diff --git a/api/tests/unit_tests/core/workflow/nodes/knowledge_retrieval/test_knowledge_retrieval_node.py b/api/tests/unit_tests/core/workflow/nodes/knowledge_retrieval/test_knowledge_retrieval_node.py
index ce7984ea26f..66948b66017 100644
--- a/api/tests/unit_tests/core/workflow/nodes/knowledge_retrieval/test_knowledge_retrieval_node.py
+++ b/api/tests/unit_tests/core/workflow/nodes/knowledge_retrieval/test_knowledge_retrieval_node.py
@@ -101,32 +101,6 @@ class TestKnowledgeRetrievalNode:
Test suite for KnowledgeRetrievalNode.
"""
- def test_node_initialization(self, mock_graph_init_params, mock_graph_runtime_state, mock_rag_retrieval):
- """Test KnowledgeRetrievalNode initialization."""
- # Arrange
- node_id = str(uuid.uuid4())
- config = {
- "id": node_id,
- "data": {
- "title": "Knowledge Retrieval",
- "type": "knowledge-retrieval",
- "dataset_ids": [str(uuid.uuid4())],
- "retrieval_mode": "multiple",
- },
- }
-
- # Act
- node = KnowledgeRetrievalNode(
- node_id=node_id,
- data=KnowledgeRetrievalNodeData.model_validate(config["data"]),
- graph_init_params=mock_graph_init_params,
- graph_runtime_state=mock_graph_runtime_state,
- )
-
- # Assert
- assert node.id == node_id
- assert node._rag_retrieval == mock_rag_retrieval
-
def test_run_with_no_query_or_attachment(
self,
mock_graph_init_params,
@@ -591,14 +565,6 @@ class TestFetchDatasetRetriever:
request = call_args[1]["request"]
assert request.reranking_enable is False
- def test_version_method(self):
- """Test version class method."""
- # Act
- version = KnowledgeRetrievalNode.version()
-
- # Assert
- assert version == "1"
-
def test_resolve_metadata_filtering_conditions_templates(
self,
mock_graph_init_params,
diff --git a/api/tests/unit_tests/core/workflow/nodes/list_operator/node_spec.py b/api/tests/unit_tests/core/workflow/nodes/list_operator/node_spec.py
index 2c47ba93926..4d841cd1441 100644
--- a/api/tests/unit_tests/core/workflow/nodes/list_operator/node_spec.py
+++ b/api/tests/unit_tests/core/workflow/nodes/list_operator/node_spec.py
@@ -4,7 +4,7 @@ import pytest
from core.app.entities.app_invoke_entities import DIFY_RUN_CONTEXT_KEY
from graphon.entities import GraphInitParams
-from graphon.enums import BuiltinNodeTypes, WorkflowNodeExecutionStatus
+from graphon.enums import WorkflowNodeExecutionStatus
from graphon.nodes.list_operator.entities import ListOperatorNodeData
from graphon.nodes.list_operator.node import ListOperatorNode
from graphon.runtime import GraphRuntimeState
@@ -70,29 +70,6 @@ class TestListOperatorNode:
return _create_node
- def test_node_initialization(self, mock_graph_runtime_state, graph_init_params):
- """Test node initializes correctly."""
- config = {
- "title": "List Operator",
- "variable": ["sys", "list"],
- "filter_by": {"enabled": False},
- "order_by": {"enabled": False},
- "limit": {"enabled": False},
- }
-
- node = self._build_node(
- data=config,
- graph_init_params=graph_init_params,
- graph_runtime_state=mock_graph_runtime_state,
- )
-
- assert node.node_type == BuiltinNodeTypes.LIST_OPERATOR
- assert node._node_data.title == "List Operator"
-
- def test_version(self):
- """Test version returns correct value."""
- assert ListOperatorNode.version() == "1"
-
def test_run_with_string_array(self, list_operator_node_factory):
"""Test with string array."""
config = {
diff --git a/api/tests/unit_tests/core/workflow/nodes/template_transform/template_transform_node_spec.py b/api/tests/unit_tests/core/workflow/nodes/template_transform/template_transform_node_spec.py
index dd57dde1fed..b1dc364942b 100644
--- a/api/tests/unit_tests/core/workflow/nodes/template_transform/template_transform_node_spec.py
+++ b/api/tests/unit_tests/core/workflow/nodes/template_transform/template_transform_node_spec.py
@@ -3,7 +3,7 @@ from unittest.mock import MagicMock
import pytest
from core.app.entities.app_invoke_entities import InvokeFrom, UserFrom
-from graphon.enums import BuiltinNodeTypes, ErrorStrategy, WorkflowNodeExecutionStatus
+from graphon.enums import WorkflowNodeExecutionStatus
from graphon.graph import Graph
from graphon.nodes.base.entities import VariableSelector
from graphon.nodes.template_transform.entities import TemplateTransformNodeData
@@ -78,78 +78,6 @@ class TestTemplateTransformNode:
"template": "Hello {{ name }}, you are {{ age }} years old!",
}
- def test_node_initialization(self, basic_node_data, mock_graph_runtime_state, graph_init_params):
- """Test that TemplateTransformNode initializes correctly."""
- mock_renderer = MagicMock()
- node = _build_template_transform_node(
- node_data=basic_node_data,
- graph_init_params=graph_init_params,
- graph_runtime_state=mock_graph_runtime_state,
- jinja2_template_renderer=mock_renderer,
- )
-
- assert node.node_type == BuiltinNodeTypes.TEMPLATE_TRANSFORM
- assert node._node_data.title == "Template Transform"
- assert len(node._node_data.variables) == 2
- assert node._node_data.template == "Hello {{ name }}, you are {{ age }} years old!"
-
- def test_get_title(self, basic_node_data, mock_graph_runtime_state, graph_init_params):
- """Test _get_title method."""
- mock_renderer = MagicMock()
- node = _build_template_transform_node(
- node_data=basic_node_data,
- graph_init_params=graph_init_params,
- graph_runtime_state=mock_graph_runtime_state,
- jinja2_template_renderer=mock_renderer,
- )
-
- assert node._get_title() == "Template Transform"
-
- def test_get_description(self, basic_node_data, mock_graph_runtime_state, graph_init_params):
- """Test _get_description method."""
- mock_renderer = MagicMock()
- node = _build_template_transform_node(
- node_data=basic_node_data,
- graph_init_params=graph_init_params,
- graph_runtime_state=mock_graph_runtime_state,
- jinja2_template_renderer=mock_renderer,
- )
-
- assert node._get_description() == "Transform data using template"
-
- def test_get_error_strategy(self, mock_graph_runtime_state, graph_init_params):
- """Test _get_error_strategy method."""
- node_data = {
- "title": "Test",
- "variables": [],
- "template": "test",
- "error_strategy": "fail-branch",
- }
-
- mock_renderer = MagicMock()
- node = _build_template_transform_node(
- node_data=node_data,
- graph_init_params=graph_init_params,
- graph_runtime_state=mock_graph_runtime_state,
- jinja2_template_renderer=mock_renderer,
- )
-
- assert node._get_error_strategy() == ErrorStrategy.FAIL_BRANCH
-
- def test_get_default_config(self):
- """Test get_default_config class method."""
- config = TemplateTransformNode.get_default_config()
-
- assert config["type"] == "template-transform"
- assert "config" in config
- assert "variables" in config["config"]
- assert "template" in config["config"]
- assert config["config"]["template"] == "{{ arg1 }}"
-
- def test_version(self):
- """Test version class method."""
- assert TemplateTransformNode.version() == "1"
-
@pytest.mark.parametrize("max_output_length", [0, -1])
def test_node_initialization_rejects_non_positive_max_output_length(
self,
diff --git a/api/tests/unit_tests/core/workflow/nodes/template_transform/test_template_transform_node.py b/api/tests/unit_tests/core/workflow/nodes/template_transform/test_template_transform_node.py
index c25ac7da0f6..8f53ec0f25a 100644
--- a/api/tests/unit_tests/core/workflow/nodes/template_transform/test_template_transform_node.py
+++ b/api/tests/unit_tests/core/workflow/nodes/template_transform/test_template_transform_node.py
@@ -1,58 +1,11 @@
-from unittest.mock import MagicMock
-
-import pytest
-
-from core.app.entities.app_invoke_entities import InvokeFrom, UserFrom
from graphon.nodes.base.entities import VariableSelector
-from graphon.nodes.template_transform.entities import TemplateTransformNodeData
from graphon.nodes.template_transform.template_transform_node import (
- DEFAULT_TEMPLATE_TRANSFORM_MAX_OUTPUT_LENGTH,
TemplateTransformNode,
)
-from graphon.runtime import GraphRuntimeState
-from tests.workflow_test_utils import build_test_graph_init_params
from .template_transform_node_spec import TestTemplateTransformNode # noqa: F401
-def graph_init_params():
- return build_test_graph_init_params(
- workflow_id="test_workflow",
- graph_config={},
- tenant_id="test_tenant",
- app_id="test_app",
- user_id="test_user",
- user_from=UserFrom.ACCOUNT,
- invoke_from=InvokeFrom.DEBUGGER,
- call_depth=0,
- )
-
-
-def mock_graph_runtime_state():
- mock_state = MagicMock(spec=GraphRuntimeState)
- mock_state.variable_pool = MagicMock()
- return mock_state
-
-
-def test_node_uses_default_max_output_length_when_not_overridden(graph_init_params, mock_graph_runtime_state):
- node = TemplateTransformNode(
- node_id="test_node",
- data=TemplateTransformNodeData(
- title="Template Transform",
- type="template-transform",
- variables=[],
- template="hello",
- ),
- graph_init_params=graph_init_params,
- graph_runtime_state=mock_graph_runtime_state,
- jinja2_template_renderer=MagicMock(),
- )
-
- assert node._max_output_length == DEFAULT_TEMPLATE_TRANSFORM_MAX_OUTPUT_LENGTH
-
-
def test_extract_variable_selector_to_variable_mapping_accepts_mixed_valid_entries():
mapping = TemplateTransformNode._extract_variable_selector_to_variable_mapping(
graph_config={"ignored": True},
diff --git a/api/tests/unit_tests/core/workflow/nodes/webhook/test_webhook_node.py b/api/tests/unit_tests/core/workflow/nodes/webhook/test_webhook_node.py
index c5ae542d8bd..d99189c446c 100644
--- a/api/tests/unit_tests/core/workflow/nodes/webhook/test_webhook_node.py
+++ b/api/tests/unit_tests/core/workflow/nodes/webhook/test_webhook_node.py
@@ -4,7 +4,6 @@ from unittest.mock import patch
import pytest
from core.app.entities.app_invoke_entities import DIFY_RUN_CONTEXT_KEY, InvokeFrom, UserFrom
-from core.trigger.constants import TRIGGER_WEBHOOK_NODE_TYPE
from core.workflow.nodes.trigger_webhook.entities import (
ContentType,
Method,
@@ -63,34 +62,6 @@ def build_webhook_variable_pool(inputs: dict[str, Any]) -> VariablePool:
)
-def test_webhook_node_basic_initialization():
- """Test basic webhook node initialization and configuration."""
- data = WebhookData(
- title="Test Webhook",
- method=Method.POST,
- content_type=ContentType.JSON,
- headers=[WebhookParameter(name="X-API-Key", required=True)],
- params=[WebhookParameter(name="version", required=False)],
- body=[WebhookBodyParameter(name="message", type="string", required=True)],
- status_code=200,
- response_body="OK",
- timeout=30,
- )
-
- variable_pool = build_webhook_variable_pool({})
-
- node = create_webhook_node(data, variable_pool)
-
- assert node.node_type == TRIGGER_WEBHOOK_NODE_TYPE
- assert node.version() == "1"
- assert node._get_title() == "Test Webhook"
- assert node._node_data.method == Method.POST
- assert node._node_data.content_type == ContentType.JSON
- assert len(node._node_data.headers) == 1
- assert len(node._node_data.params) == 1
- assert len(node._node_data.body) == 1
-
-
def test_webhook_node_default_config():
"""Test webhook node default configuration."""
config = TriggerWebhookNode.get_default_config()
diff --git a/api/tests/unit_tests/core/workflow/test_node_factory.py b/api/tests/unit_tests/core/workflow/test_node_factory.py
index c92c6a0e588..f5c7b022740 100644
--- a/api/tests/unit_tests/core/workflow/test_node_factory.py
+++ b/api/tests/unit_tests/core/workflow/test_node_factory.py
@@ -307,134 +307,6 @@ class TestCodeExecutorJinja2TemplateRenderer:
renderer.render_template("{{ broken }}", {})
-class TestDifyNodeFactoryInit:
- def test_from_graph_init_context_translates_before_init(self):
- graph_init_context = MagicMock()
- graph_init_context.to_graph_init_params.return_value = sentinel.graph_init_params
-
- with patch.object(node_factory.DifyNodeFactory, "__init__", return_value=None) as init:
- factory = node_factory.DifyNodeFactory.from_graph_init_context(
- graph_init_context=graph_init_context,
- graph_runtime_state=sentinel.graph_runtime_state,
- )
-
- assert isinstance(factory, node_factory.DifyNodeFactory)
- graph_init_context.to_graph_init_params.assert_called_once_with()
- init.assert_called_once_with(
- graph_init_params=sentinel.graph_init_params,
- graph_runtime_state=sentinel.graph_runtime_state,
- )
-
- def test_with_runtime_state_rebinds_factory(self):
- factory = object.__new__(node_factory.DifyNodeFactory)
- factory.graph_init_params = sentinel.graph_init_params
-
- with patch.object(node_factory, "DifyNodeFactory", return_value=sentinel.factory) as factory_cls:
- rebound = factory.with_runtime_state(sentinel.graph_runtime_state)
-
- assert rebound is sentinel.factory
- factory_cls.assert_called_once_with(
- graph_init_params=sentinel.graph_init_params,
- graph_runtime_state=sentinel.graph_runtime_state,
- )
-
- def test_init_builds_default_dependencies(self):
- graph_init_params = SimpleNamespace(run_context={"context": "value"})
- graph_runtime_state = sentinel.graph_runtime_state
- dify_context = SimpleNamespace(tenant_id="tenant-id", app_id="app-id", user_id="user-id")
- jinja2_template_renderer = sentinel.jinja2_template_renderer
- unstructured_api_config = sentinel.unstructured_api_config
- http_request_config = sentinel.http_request_config
- file_reference_factory = sentinel.file_reference_factory
- prompt_message_serializer = sentinel.prompt_message_serializer
- retriever_attachment_loader = sentinel.retriever_attachment_loader
- llm_file_saver = sentinel.llm_file_saver
- credentials_provider = sentinel.credentials_provider
- model_factory = sentinel.model_factory
- human_input_runtime = sentinel.human_input_runtime
- tool_runtime = sentinel.tool_runtime
-
- with (
- patch.object(
- node_factory.DifyNodeFactory,
- "_resolve_dify_context",
- return_value=dify_context,
- ) as resolve_dify_context,
- patch.object(
- node_factory,
- "CodeExecutorJinja2TemplateRenderer",
- return_value=jinja2_template_renderer,
- ) as renderer_factory,
- patch.object(
- node_factory,
- "UnstructuredApiConfig",
- return_value=unstructured_api_config,
- ),
- patch.object(
- node_factory,
- "build_http_request_config",
- return_value=http_request_config,
- ),
- patch.object(
- node_factory,
- "DifyFileReferenceFactory",
- return_value=file_reference_factory,
- ),
- patch.object(
- node_factory,
- "DifyPromptMessageSerializer",
- return_value=prompt_message_serializer,
- ),
- patch.object(
- node_factory,
- "DifyRetrieverAttachmentLoader",
- return_value=retriever_attachment_loader,
- ),
- patch.object(
- node_factory,
- "build_dify_llm_file_saver",
- return_value=llm_file_saver,
- ),
- patch.object(
- node_factory,
- "DifyHumanInputNodeRuntime",
- return_value=human_input_runtime,
- ),
- patch.object(
- node_factory,
- "DifyToolNodeRuntime",
- return_value=tool_runtime,
- ),
- patch.object(
- node_factory,
- "build_dify_model_access",
- return_value=(credentials_provider, model_factory),
- ) as build_dify_model_access,
- ):
- factory = node_factory.DifyNodeFactory(
- graph_init_params=graph_init_params,
- graph_runtime_state=graph_runtime_state,
- )
-
- resolve_dify_context.assert_called_once_with(graph_init_params.run_context)
- build_dify_model_access.assert_called_once_with(dify_context)
- renderer_factory.assert_called_once_with()
- assert factory.graph_init_params is graph_init_params
- assert factory.graph_runtime_state is graph_runtime_state
- assert factory._dify_context is dify_context
- assert factory._jinja2_template_renderer is jinja2_template_renderer
- assert factory._document_extractor_unstructured_api_config is unstructured_api_config
- assert factory._http_request_config is http_request_config
- assert factory._file_reference_factory is file_reference_factory
- assert factory._prompt_message_serializer is prompt_message_serializer
- assert factory._retriever_attachment_loader is retriever_attachment_loader
- assert factory._llm_file_saver is llm_file_saver
- assert factory._human_input_runtime is human_input_runtime
- assert factory._tool_runtime is tool_runtime
- assert factory._llm_credentials_provider is credentials_provider
- assert factory._llm_model_factory is model_factory
-
-
class TestDifyNodeFactoryResolveContext:
def test_requires_reserved_context_key(self):
with pytest.raises(ValueError, match=DIFY_RUN_CONTEXT_KEY):
diff --git a/api/tests/unit_tests/services/test_app_task_service.py b/api/tests/unit_tests/services/test_app_task_service.py
index 2a72da35789..06caa8170de 100644
--- a/api/tests/unit_tests/services/test_app_task_service.py
+++ b/api/tests/unit_tests/services/test_app_task_service.py
@@ -50,37 +50,6 @@ class TestAppTaskService:
else:
mock_graph_engine_manager.assert_not_called()
- @pytest.mark.parametrize(
- "invoke_from",
- [
- InvokeFrom.WEB_APP,
- InvokeFrom.SERVICE_API,
- InvokeFrom.DEBUGGER,
- InvokeFrom.EXPLORE,
- ],
- )
- @patch("services.app_task_service.AppQueueManager")
- @patch("services.app_task_service.GraphEngineManager")
- def test_stop_task_with_different_invoke_sources(
- self, mock_graph_engine_manager, mock_app_queue_manager, invoke_from
- ):
- """Test stop_task behavior with different invoke sources.
-
- Verifies that the method works correctly regardless of the invoke source.
- """
- # Arrange
- task_id = "task-789"
- user_id = "user-999"
- app_mode = AppMode.ADVANCED_CHAT
-
- # Act
- AppTaskService.stop_task(task_id, invoke_from, user_id, app_mode)
-
- # Assert
- mock_app_queue_manager.set_stop_flag.assert_called_once_with(task_id, invoke_from, user_id)
- mock_graph_engine_manager.assert_called_once()
- mock_graph_engine_manager.return_value.send_stop_command.assert_called_once_with(task_id)
-
@patch("services.app_task_service.GraphEngineManager")
@patch("services.app_task_service.AppQueueManager")
def test_stop_task_legacy_mechanism_called_even_if_graph_engine_fails(
diff --git a/api/tests/unit_tests/services/test_workflow_run_service.py b/api/tests/unit_tests/services/test_workflow_run_service.py
index 3e7bf683101..646266f826d 100644
--- a/api/tests/unit_tests/services/test_workflow_run_service.py
+++ b/api/tests/unit_tests/services/test_workflow_run_service.py
@@ -55,17 +55,6 @@ def _workflow_run(
)
-def test_init_keeps_injected_dependencies(
- service_dependencies: tuple[MagicMock, MagicMock],
-) -> None:
- node_executions, workflow_runs = service_dependencies
-
- service = _service(service_dependencies)
-
- assert service._workflow_runs is workflow_runs
- assert service._node_executions is node_executions
-
-
class TestWorkflowRunServiceQueries:
def test_get_paginate_workflow_runs_should_forward_filters_and_parse_limit(
self,
diff --git a/api/tests/unit_tests/services/workflow/test_workflow_event_snapshot_service.py b/api/tests/unit_tests/services/workflow/test_workflow_event_snapshot_service.py
index 642389fe035..9f914556800 100644
--- a/api/tests/unit_tests/services/workflow/test_workflow_event_snapshot_service.py
+++ b/api/tests/unit_tests/services/workflow/test_workflow_event_snapshot_service.py
@@ -11,7 +11,6 @@ from typing import Any, cast, override
from unittest.mock import MagicMock
import pytest
-from sqlalchemy import event as orm_event
from sqlalchemy.orm import Session, sessionmaker
from core.app.app_config.entities import WorkflowUIBasedAppConfig
@@ -495,33 +494,17 @@ def test_get_message_context_by_app_should_scope_and_bound_compatibility_lookup(
assert result.answer == "newest answer"
-def test_get_message_context_by_conversation_should_default_created_at_to_zero_when_message_has_no_timestamp(
- sqlite_session_factory: sessionmaker[Session],
-) -> None:
- # Arrange
- _persist_message(sqlite_session_factory)
-
- def clear_created_at(message: Message, _context: Any) -> None:
- # A load hook preserves coverage for legacy rows without replacing the real ORM query.
- message.created_at = None
+def test_get_message_context_by_conversation_should_default_created_at_to_zero_when_message_has_no_timestamp() -> None:
+ session_maker = MagicMock()
+ session_maker.return_value.__enter__.return_value.scalar.return_value = Message(
+ id="msg-1", conversation_id="conv-1", answer="answer", created_at=None
+ )
- # Act
- orm_event.listen(Message, "load", clear_created_at)
- try:
- result = service_module._get_message_context_by_conversation(
- sqlite_session_factory,
- conversation_id="conv-1",
- workflow_run_id="run-1",
- )
- finally:
- orm_event.remove(Message, "load", clear_created_at)
+ result = service_module._get_message_context_by_conversation(
+ session_maker, conversation_id="conv-1", workflow_run_id="run-1"
+ )
- # Assert
- assert result is not None
- assert result.created_at == 0
- assert result.message_id == "msg-1"
- assert result.conversation_id == "conv-1"
- assert result.answer == "answer"
+ assert result == MessageContext(conversation_id="conv-1", message_id="msg-1", created_at=0, answer="answer")
def test_load_resumption_context_should_return_none_when_pause_entity_missing() -> None:
diff --git a/api/tests/unit_tests/services/workflow/test_workflow_event_snapshot_service_additional.py b/api/tests/unit_tests/services/workflow/test_workflow_event_snapshot_service_additional.py
deleted file mode 100644
index 36cdac0742e..00000000000
--- a/api/tests/unit_tests/services/workflow/test_workflow_event_snapshot_service_additional.py
+++ /dev/null
@@ -1,557 +0,0 @@
-import json
-import queue
-from collections.abc import Mapping
-from dataclasses import dataclass
-from datetime import UTC, datetime
-from itertools import cycle
-from threading import Event
-from types import SimpleNamespace
-from typing import Any, cast
-from unittest.mock import MagicMock
-
-import pytest
-from sqlalchemy import event
-from sqlalchemy.engine import Engine
-from sqlalchemy.orm import Session, sessionmaker
-
-from core.app.app_config.entities import WorkflowUIBasedAppConfig
-from core.app.entities.app_invoke_entities import AdvancedChatAppGenerateEntity, InvokeFrom, WorkflowAppGenerateEntity
-from core.app.entities.task_entities import StreamEvent
-from core.app.layers.pause_state_persist_layer import (
- WorkflowResumptionContext,
- _WorkflowGenerateEntityWrapper,
-)
-from graphon.enums import WorkflowExecutionStatus
-from graphon.runtime import GraphRuntimeState, VariablePool
-from models.base import TypeBase
-from models.enums import CreatorUserRole, MessageStatus
-from models.model import AppMode, Message
-from models.workflow import WorkflowRun
-from repositories.entities.workflow_pause import WorkflowPauseEntity
-from services import workflow_event_snapshot_service as service_module
-from services.workflow_event_snapshot_service import BufferState, MessageContext, build_workflow_event_stream
-
-
-def _build_workflow_run(status: WorkflowExecutionStatus = WorkflowExecutionStatus.RUNNING) -> WorkflowRun:
- return WorkflowRun(
- id="run-1",
- tenant_id="tenant-1",
- app_id="app-1",
- workflow_id="workflow-1",
- type="workflow",
- triggered_from="app-run",
- version="v1",
- graph=None,
- inputs=json.dumps({"query": "hello"}),
- status=status,
- outputs=json.dumps({}),
- error=None,
- elapsed_time=1.2,
- total_tokens=5,
- total_steps=2,
- created_by_role=CreatorUserRole.END_USER,
- created_by="user-1",
- created_at=datetime(2024, 1, 1, tzinfo=UTC),
- )
-
-
-def _build_resumption_context(task_id: str) -> WorkflowResumptionContext:
- app_config = WorkflowUIBasedAppConfig(
- tenant_id="tenant-1",
- app_id="app-1",
- app_mode=AppMode.WORKFLOW,
- workflow_id="workflow-1",
- )
- generate_entity = WorkflowAppGenerateEntity(
- task_id=task_id,
- app_config=app_config,
- inputs={},
- files=[],
- user_id="user-1",
- stream=True,
- invoke_from=InvokeFrom.EXPLORE,
- call_depth=0,
- workflow_execution_id="run-1",
- )
- runtime_state = GraphRuntimeState(variable_pool=VariablePool(), start_at=0.0)
- runtime_state.set_output("answer", "ok")
- wrapper = _WorkflowGenerateEntityWrapper(entity=generate_entity)
- return WorkflowResumptionContext(
- generate_entity=wrapper,
- serialized_graph_runtime_state=runtime_state.dumps(),
- )
-
-
-def message_session_maker(sqlite_engine: Engine) -> sessionmaker[Session]:
- """Create real sessions containing only workflow messages."""
- TypeBase.metadata.create_all(sqlite_engine, tables=[TypeBase.metadata.tables[Message.__tablename__]])
- return sessionmaker(bind=sqlite_engine, expire_on_commit=False)
-
-
-def _persist_message(session_maker: sessionmaker[Session]) -> Message:
- message = Message(
- app_id="app-1",
- model_provider="provider",
- model_id="model",
- override_model_configs=None,
- conversation_id="conv-1",
- inputs={},
- query="hello",
- message="",
- message_tokens=0,
- message_unit_price=0,
- message_price_unit=0,
- answer="answer",
- answer_tokens=0,
- answer_unit_price=0,
- answer_price_unit=0,
- parent_message_id=None,
- provider_response_latency=0,
- total_price=0,
- currency="USD",
- invoke_from=InvokeFrom.WEB_APP,
- from_source="api",
- from_end_user_id="user-1",
- from_account_id=None,
- app_mode=AppMode.WORKFLOW,
- status=MessageStatus.NORMAL,
- workflow_run_id="run-1",
- )
- message.id = "msg-1"
- with session_maker() as session:
- session.add(message)
- session.commit()
- return message
-
-
-class _SubscriptionContext:
- def __init__(self, subscription: Any) -> None:
- self._subscription = subscription
-
- def __enter__(self) -> Any:
- return self._subscription
-
- def __exit__(self, exc_type: Any, exc: Any, tb: Any) -> bool:
- return False
-
-
-class _Topic:
- def __init__(self, subscription: Any) -> None:
- self._subscription = subscription
-
- def subscribe(self) -> _SubscriptionContext:
- return _SubscriptionContext(self._subscription)
-
-
-class _StaticSubscription:
- def receive(self, timeout: int = 1) -> None:
- return None
-
-
-@dataclass(frozen=True)
-class _PauseEntity(WorkflowPauseEntity):
- state: bytes
-
- @property
- def id(self) -> str:
- return "pause-1"
-
- @property
- def workflow_execution_id(self) -> str:
- return "run-1"
-
- @property
- def resumed_at(self) -> datetime | None:
- return None
-
- @property
- def paused_at(self) -> datetime:
- return datetime(2024, 1, 1, tzinfo=UTC)
-
- def get_state(self) -> bytes:
- return self.state
-
- def get_pause_reasons(self) -> list[Any]:
- return []
-
-
-class TestWorkflowEventSnapshotHelpers:
- def test_get_message_context_by_conversation_should_return_none_when_no_message(
- self, message_session_maker: sessionmaker[Session]
- ) -> None:
- result = service_module._get_message_context_by_conversation(
- message_session_maker,
- conversation_id="conv-1",
- workflow_run_id="run-1",
- )
-
- assert result is None
-
- def test_get_message_context_by_conversation_should_default_created_at_to_zero_when_message_has_no_timestamp(
- self, message_session_maker: sessionmaker[Session]
- ) -> None:
- _persist_message(message_session_maker)
-
- def clear_created_at(message: Message, _context: Any) -> None:
- message.created_at = None # type: ignore[assignment]
-
- event.listen(Message, "load", clear_created_at)
- try:
- result = service_module._get_message_context_by_conversation(
- message_session_maker,
- conversation_id="conv-1",
- workflow_run_id="run-1",
- )
- finally:
- event.remove(Message, "load", clear_created_at)
-
- assert result is not None
- assert result.created_at == 0
- assert result.message_id == "msg-1"
- assert result.conversation_id == "conv-1"
- assert result.answer == "answer"
-
- def test_load_resumption_context_should_return_none_when_pause_entity_missing(self) -> None:
- assert service_module._load_resumption_context(None) is None
-
- def test_load_resumption_context_should_return_none_when_pause_entity_state_is_invalid(self) -> None:
- pause_entity = _PauseEntity(state=b"not-a-valid-state")
- assert service_module._load_resumption_context(pause_entity) is None
-
- def test_load_resumption_context_should_parse_valid_state_into_context(self) -> None:
- context = _build_resumption_context(task_id="task-ctx")
- pause_entity = _PauseEntity(state=context.dumps().encode())
-
- result = service_module._load_resumption_context(pause_entity)
-
- assert result is not None
- assert result.get_generate_entity().task_id == "task-ctx"
-
- def test_resolve_task_id_should_return_workflow_run_id_when_buffer_state_is_missing(self) -> None:
- result = service_module._resolve_task_id(
- resumption_context=None,
- buffer_state=None,
- workflow_run_id="run-1",
- )
-
- assert result == "run-1"
-
- @pytest.mark.parametrize(
- ("payload", "expected"),
- [
- (b'{"event":"node_started"}', {"event": "node_started"}),
- (b"invalid-json", None),
- (b"[]", None),
- ],
- )
- def test_parse_event_message_should_parse_only_json_object(
- self,
- payload: bytes,
- expected: dict[str, Any] | None,
- ) -> None:
- result = service_module._parse_event_message(payload)
- assert result == expected
-
- def test_is_terminal_event_should_recognize_finished_and_optional_paused_events(self) -> None:
- finished_event = {"event": StreamEvent.WORKFLOW_FINISHED}
- paused_event = {"event": StreamEvent.WORKFLOW_PAUSED}
-
- is_finished = service_module._is_terminal_event(finished_event, include_paused=False)
- paused_without_flag = service_module._is_terminal_event(paused_event, include_paused=False)
- paused_with_flag = service_module._is_terminal_event(paused_event, include_paused=True)
-
- assert is_finished is True
- assert paused_without_flag is False
- assert paused_with_flag is True
- assert service_module._is_terminal_event(StreamEvent.PING, include_paused=True) is False
-
- def test_apply_message_context_should_update_payload_when_context_exists(self) -> None:
- payload: dict[str, Any] = {"event": "workflow_started"}
- context = MessageContext(conversation_id="conv-1", message_id="msg-1", created_at=1700000000)
-
- service_module._apply_message_context(payload, context)
-
- assert payload["conversation_id"] == "conv-1"
- assert payload["message_id"] == "msg-1"
- assert payload["created_at"] == 1700000000
-
- def test_start_buffering_should_capture_task_id_and_enqueue_event(self) -> None:
- class Subscription:
- def __init__(self) -> None:
- self._calls = 0
-
- def receive(self, timeout: int = 1) -> bytes | None:
- self._calls += 1
- if self._calls == 1:
- return b'{"event":"node_started","task_id":"task-1"}'
- return None
-
- subscription = Subscription()
-
- buffer_state = service_module._start_buffering(subscription)
- ready = buffer_state.task_id_ready.wait(timeout=1)
- event = buffer_state.queue.get(timeout=1)
- buffer_state.stop_event.set()
- finished = buffer_state.done_event.wait(timeout=1)
-
- assert ready is True
- assert finished is True
- assert buffer_state.task_id_hint == "task-1"
- assert event["event"] == "node_started"
-
- def test_start_buffering_should_drop_old_event_when_queue_is_full(
- self,
- monkeypatch: pytest.MonkeyPatch,
- ) -> None:
- class QueueWithSingleFull:
- def __init__(self) -> None:
- self._first_put = True
- self.items: list[dict[str, Any]] = [{"event": "old"}]
-
- def put_nowait(self, item: dict[str, Any]) -> None:
- if self._first_put:
- self._first_put = False
- raise queue.Full
- self.items.append(item)
-
- def get_nowait(self) -> dict[str, Any]:
- if not self.items:
- raise queue.Empty
- return self.items.pop(0)
-
- def empty(self) -> bool:
- return len(self.items) == 0
-
- fake_queue = QueueWithSingleFull()
- monkeypatch.setattr(service_module.queue, "Queue", lambda maxsize=2048: fake_queue)
-
- class Subscription:
- def __init__(self) -> None:
- self._calls = 0
-
- def receive(self, timeout: int = 1) -> bytes | None:
- self._calls += 1
- if self._calls == 1:
- return b'{"event":"node_started","task_id":"task-2"}'
- return None
-
- subscription = Subscription()
-
- buffer_state = service_module._start_buffering(subscription)
- ready = buffer_state.task_id_ready.wait(timeout=1)
- buffer_state.stop_event.set()
- finished = buffer_state.done_event.wait(timeout=1)
-
- assert ready is True
- assert finished is True
- assert fake_queue.items[-1]["task_id"] == "task-2"
-
- def test_start_buffering_should_set_done_event_when_subscription_raises(self) -> None:
- class Subscription:
- def receive(self, timeout: int = 1) -> bytes | None:
- raise RuntimeError("subscription failure")
-
- subscription = Subscription()
- buffer_state = service_module._start_buffering(subscription)
-
- assert buffer_state.done_event.wait(timeout=1) is True
-
-
-class TestBuildWorkflowEventStream:
- def test_build_workflow_event_stream_should_emit_ping_and_terminal_snapshot_event(
- self,
- monkeypatch: pytest.MonkeyPatch,
- message_session_maker: sessionmaker[Session],
- ) -> None:
- workflow_run = _build_workflow_run(status=WorkflowExecutionStatus.PAUSED)
- topic = _Topic(_StaticSubscription())
- pause_entity = _PauseEntity(state=b"state")
- workflow_run_repo = SimpleNamespace(get_workflow_pause=MagicMock(return_value=pause_entity))
- node_repo = SimpleNamespace(get_execution_snapshots_by_workflow_run=MagicMock(return_value=[]))
- factory = SimpleNamespace(
- create_api_workflow_run_repository=MagicMock(return_value=workflow_run_repo),
- create_api_workflow_node_execution_repository=MagicMock(return_value=node_repo),
- )
- monkeypatch.setattr(service_module, "DifyAPIRepositoryFactory", factory)
- monkeypatch.setattr(service_module.MessageGenerator, "get_response_topic", MagicMock(return_value=topic))
- monkeypatch.setattr(
- service_module,
- "_get_message_context_by_conversation",
- MagicMock(return_value=MessageContext("conv-1", "msg-1", 1700000000)),
- )
- generate_entity = AdvancedChatAppGenerateEntity.model_construct(conversation_id="conv-1")
- resumption_context = SimpleNamespace(
- get_generate_entity=MagicMock(return_value=generate_entity),
- )
- monkeypatch.setattr(
- service_module,
- "_load_resumption_context",
- MagicMock(return_value=resumption_context),
- )
- buffer_state = BufferState(
- queue=queue.Queue(),
- stop_event=Event(),
- done_event=Event(),
- task_id_ready=Event(),
- task_id_hint="task-1",
- )
- monkeypatch.setattr(service_module, "_start_buffering", MagicMock(return_value=buffer_state))
- monkeypatch.setattr(service_module, "_resolve_task_id", MagicMock(return_value="task-1"))
- monkeypatch.setattr(
- service_module,
- "_build_snapshot_events",
- MagicMock(return_value=[{"event": StreamEvent.WORKFLOW_FINISHED, "task_id": "task-1"}]),
- )
-
- events = list(
- build_workflow_event_stream(
- app_mode=AppMode.ADVANCED_CHAT,
- workflow_run=workflow_run,
- tenant_id="tenant-1",
- app_id="app-1",
- session_maker=message_session_maker,
- )
- )
-
- assert events[0] == StreamEvent.PING
- finished_event = cast(Mapping[str, Any], events[1])
- assert finished_event["event"] == StreamEvent.WORKFLOW_FINISHED
- assert buffer_state.stop_event.is_set() is True
- node_repo.get_execution_snapshots_by_workflow_run.assert_called_once()
- called_kwargs = node_repo.get_execution_snapshots_by_workflow_run.call_args.kwargs
- assert called_kwargs["workflow_run_id"] == "run-1"
-
- def test_build_workflow_event_stream_should_emit_periodic_ping_and_stop_after_idle_timeout(
- self,
- monkeypatch: pytest.MonkeyPatch,
- message_session_maker: sessionmaker[Session],
- ) -> None:
- workflow_run = _build_workflow_run(status=WorkflowExecutionStatus.RUNNING)
- topic = _Topic(_StaticSubscription())
- workflow_run_repo = SimpleNamespace(get_workflow_pause=MagicMock())
- node_repo = SimpleNamespace(get_execution_snapshots_by_workflow_run=MagicMock(return_value=[]))
- factory = SimpleNamespace(
- create_api_workflow_run_repository=MagicMock(return_value=workflow_run_repo),
- create_api_workflow_node_execution_repository=MagicMock(return_value=node_repo),
- )
- monkeypatch.setattr(service_module, "DifyAPIRepositoryFactory", factory)
- monkeypatch.setattr(service_module.MessageGenerator, "get_response_topic", MagicMock(return_value=topic))
- monkeypatch.setattr(service_module, "_load_resumption_context", MagicMock(return_value=None))
- monkeypatch.setattr(service_module, "_build_snapshot_events", MagicMock(return_value=[]))
- monkeypatch.setattr(service_module, "_resolve_task_id", MagicMock(return_value="task-1"))
-
- class AlwaysEmptyQueue:
- def empty(self) -> bool:
- return False
-
- def get(self, timeout: int = 1) -> None:
- raise queue.Empty
-
- buffer_state = BufferState(
- queue=AlwaysEmptyQueue(), # type: ignore[arg-type]
- stop_event=Event(),
- done_event=Event(),
- task_id_ready=Event(),
- task_id_hint="task-1",
- )
- monkeypatch.setattr(service_module, "_start_buffering", MagicMock(return_value=buffer_state))
- time_values = cycle([0.0, 6.0, 21.0, 26.0])
- monkeypatch.setattr(service_module.time, "time", lambda: next(time_values))
-
- events = list(
- build_workflow_event_stream(
- app_mode=AppMode.WORKFLOW,
- workflow_run=workflow_run,
- tenant_id="tenant-1",
- app_id="app-1",
- session_maker=message_session_maker,
- idle_timeout=20.0,
- ping_interval=5.0,
- )
- )
-
- assert events == [StreamEvent.PING, StreamEvent.PING]
- assert buffer_state.stop_event.is_set() is True
-
- def test_build_workflow_event_stream_should_exit_when_buffer_done_and_empty(
- self,
- monkeypatch: pytest.MonkeyPatch,
- message_session_maker: sessionmaker[Session],
- ) -> None:
- workflow_run = _build_workflow_run(status=WorkflowExecutionStatus.RUNNING)
- topic = _Topic(_StaticSubscription())
- workflow_run_repo = SimpleNamespace(get_workflow_pause=MagicMock())
- node_repo = SimpleNamespace(get_execution_snapshots_by_workflow_run=MagicMock(return_value=[]))
- factory = SimpleNamespace(
- create_api_workflow_run_repository=MagicMock(return_value=workflow_run_repo),
- create_api_workflow_node_execution_repository=MagicMock(return_value=node_repo),
- )
- monkeypatch.setattr(service_module, "DifyAPIRepositoryFactory", factory)
- monkeypatch.setattr(service_module.MessageGenerator, "get_response_topic", MagicMock(return_value=topic))
- monkeypatch.setattr(service_module, "_load_resumption_context", MagicMock(return_value=None))
- monkeypatch.setattr(service_module, "_build_snapshot_events", MagicMock(return_value=[]))
- monkeypatch.setattr(service_module, "_resolve_task_id", MagicMock(return_value="task-1"))
- buffer_state = BufferState(
- queue=queue.Queue(),
- stop_event=Event(),
- done_event=Event(),
- task_id_ready=Event(),
- task_id_hint="task-1",
- )
- buffer_state.done_event.set()
- monkeypatch.setattr(service_module, "_start_buffering", MagicMock(return_value=buffer_state))
-
- events = list(
- build_workflow_event_stream(
- app_mode=AppMode.WORKFLOW,
- workflow_run=workflow_run,
- tenant_id="tenant-1",
- app_id="app-1",
- session_maker=message_session_maker,
- )
- )
-
- assert events == [StreamEvent.PING]
- assert buffer_state.stop_event.is_set() is True
-
- def test_build_workflow_event_stream_should_continue_when_pause_loading_fails(
- self,
- monkeypatch: pytest.MonkeyPatch,
- message_session_maker: sessionmaker[Session],
- ) -> None:
- workflow_run = _build_workflow_run(status=WorkflowExecutionStatus.PAUSED)
- topic = _Topic(_StaticSubscription())
- workflow_run_repo = SimpleNamespace(get_workflow_pause=MagicMock(side_effect=RuntimeError("boom")))
- node_repo = SimpleNamespace(get_execution_snapshots_by_workflow_run=MagicMock(return_value=[]))
- factory = SimpleNamespace(
- create_api_workflow_run_repository=MagicMock(return_value=workflow_run_repo),
- create_api_workflow_node_execution_repository=MagicMock(return_value=node_repo),
- )
- monkeypatch.setattr(service_module, "DifyAPIRepositoryFactory", factory)
- monkeypatch.setattr(service_module.MessageGenerator, "get_response_topic", MagicMock(return_value=topic))
- monkeypatch.setattr(service_module, "_load_resumption_context", MagicMock(return_value=None))
- monkeypatch.setattr(service_module, "_resolve_task_id", MagicMock(return_value="task-1"))
- snapshot_builder = MagicMock(return_value=[{"event": StreamEvent.WORKFLOW_FINISHED}])
- monkeypatch.setattr(service_module, "_build_snapshot_events", snapshot_builder)
- buffer_state = BufferState(
- queue=queue.Queue(),
- stop_event=Event(),
- done_event=Event(),
- task_id_ready=Event(),
- task_id_hint="task-1",
- )
- monkeypatch.setattr(service_module, "_start_buffering", MagicMock(return_value=buffer_state))
-
- events = list(
- build_workflow_event_stream(
- app_mode=AppMode.WORKFLOW,
- workflow_run=workflow_run,
- tenant_id="tenant-1",
- app_id="app-1",
- session_maker=message_session_maker,
- )
- )
-
- assert events[0] == StreamEvent.PING
- assert snapshot_builder.call_args.kwargs["pause_entity"] is None