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: replace 50 workflow, catalogue and token lock doubles (#43575)

Asuka Minato2a598012d199
diff --git a/api/tests/unit_tests/core/app/apps/completion/test_app_runner.py b/api/tests/unit_tests/core/app/apps/completion/test_app_runner.py
index c0f25df1dee..1203f2c69d2 100644
--- a/api/tests/unit_tests/core/app/apps/completion/test_app_runner.py
+++ b/api/tests/unit_tests/core/app/apps/completion/test_app_runner.py
@@ -1,13 +1,14 @@
-from collections.abc import Callable, Iterator
+from collections.abc import Callable, Generator, Iterator
from dataclasses import dataclass, field
from decimal import Decimal
import pytest
+from flask import Flask
from redis import Redis
from sqlalchemy import event
+from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session
-import core.app.apps.completion.app_runner as module
from core.app.app_config.entities import (
AppAdditionalFeatures,
DatasetEntity,
@@ -22,20 +23,34 @@ from core.app.apps.completion.app_runner import CompletionAppRunner
from core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueManager
from core.app.entities.app_invoke_entities import CompletionAppGenerateEntity, InvokeFrom
from core.credit_usage import CreditUsageAppType, CreditUsageCreatedBy
-from core.model_manager import ModelInstance, ModelManager
+from core.entities.provider_configuration import ProviderModelBundle
+from core.entities.provider_entities import CustomProviderConfiguration
from core.moderation.base import ModerationError
-from core.rag.retrieval.dataset_retrieval import DatasetRetrieval
+from core.plugin.impl.model import PluginModelClient
+from core.plugin.impl.model_runtime import PluginModelRuntime
+from core.plugin.impl.model_runtime_factory import create_plugin_model_runtime
+from core.provider_manager import ProviderManager
+from extensions.ext_database import db
from extensions.ext_redis import RedisClientWrapper
from graphon.file import FileUploadConfig
from graphon.file.models import ImageConfig
-from graphon.model_runtime.entities.message_entities import ImagePromptMessageContent
+from graphon.model_runtime.entities.llm_entities import LLMResult, LLMResultChunk, LLMResultChunkDelta
+from graphon.model_runtime.entities.message_entities import (
+ AssistantPromptMessage,
+ ImagePromptMessageContent,
+ UserPromptMessage,
+)
from graphon.model_runtime.entities.model_entities import ModelType
+from graphon.model_runtime.model_providers.base.large_language_model import LargeLanguageModel
+from models.dataset import Dataset
from models.enums import ConversationFromSource
from models.model import App, AppMode, Conversation, IconType, Message
+from services.knowledge.external.service import ExternalDatasetService
from tests.unit_tests.core.model_fixtures import make_model_config
APP_ID = "00000000-0000-0000-0000-000000000001"
TENANT_ID = "00000000-0000-0000-0000-000000000002"
+PROVIDER = "langgenius/openai/openai"
@dataclass(frozen=True)
@@ -44,6 +59,16 @@ class RecordedCall:
kwargs: dict[str, object]
+def record_delegated_calls[**P, R](function: Callable[P, R], calls: list[RecordedCall]) -> Callable[P, R]:
+ """Record arguments without replacing the production method's behavior."""
+
+ def recorded(*args: P.args, **kwargs: P.kwargs) -> R:
+ calls.append(RecordedCall(args=args, kwargs=kwargs))
+ return function(*args, **kwargs)
+
+ return recorded
+
+
@dataclass
class CallRecorder:
result: object = None
@@ -70,6 +95,7 @@ def queue_manager(monkeypatch: pytest.MonkeyPatch) -> Iterator[MessageBasedAppQu
redis = RedisClientWrapper()
redis.initialize(client)
monkeypatch.setattr("core.app.apps.base_app_queue_manager.redis_client", redis)
+ monkeypatch.setattr("core.plugin.impl.model_runtime.redis_client", redis)
yield MessageBasedAppQueueManager(
task_id="task",
user_id="user",
@@ -80,52 +106,73 @@ def queue_manager(monkeypatch: pytest.MonkeyPatch) -> Iterator[MessageBasedAppQu
)
-class RecordingDatasetRetrieval(DatasetRetrieval):
- def __init__(self, result: tuple[object, list[object]]) -> None:
- self.result = result
- self.calls: list[RecordedCall] = []
-
- def retrieve(self, *args: object, **kwargs: object) -> tuple[object, list[object]]:
- self.calls.append(RecordedCall(args=args, kwargs=kwargs))
- return self.result
-
-
-class RecordingModelInstance(ModelInstance):
- def __init__(self, result: object = "invoke_result", implementation: Callable[..., object] | None = None) -> None:
- self.result = result
- self.implementation = implementation
- self.calls: list[RecordedCall] = []
-
- def invoke_llm(self, *args: object, **kwargs: object) -> object:
- self.calls.append(RecordedCall(args=args, kwargs=kwargs))
- if self.implementation is not None:
- return self.implementation(*args, **kwargs)
- return self.result
+def model_runtime(monkeypatch: pytest.MonkeyPatch) -> tuple[ProviderModelBundle, list[RecordedCall], list[str]]:
+ """Run the real manager, model, runtime and client; isolate configuration lookup and daemon I/O."""
+ config = make_model_config(provider=PROVIDER, model="model", mode="completion")
+ bundle = config.provider_model_bundle
+ bundle.configuration.tenant_id = TENANT_ID
+ bundle.configuration.custom_configuration.provider = CustomProviderConfiguration(credentials={"api_key": "token"})
+ bundle.model_type_instance = LargeLanguageModel(
+ provider_schema=bundle.configuration.provider,
+ model_runtime=create_plugin_model_runtime(tenant_id=TENANT_ID),
+ )
+ calls: list[RecordedCall] = []
+ events: list[str] = []
+
+ def provider_bundle(
+ _manager: ProviderManager, *, tenant_id: str, provider: str, model_type: ModelType
+ ) -> ProviderModelBundle:
+ assert (tenant_id, provider, model_type) == (TENANT_ID, PROVIDER, ModelType.LLM)
+ return bundle
+
+ def dispatch(_client: PluginModelClient, **kwargs: object) -> Generator[LLMResultChunk]:
+ calls.append(RecordedCall(args=(), kwargs=kwargs))
+ events.append("invoke")
+ events.append("first-chunk")
+ yield LLMResultChunk(
+ model="model",
+ delta=LLMResultChunkDelta(index=0, message=AssistantPromptMessage(content="answer")),
+ )
+ monkeypatch.setattr(ProviderManager, "get_provider_model_bundle", provider_bundle)
+ monkeypatch.setattr(PluginModelRuntime, "invoke_llm", record_delegated_calls(PluginModelRuntime.invoke_llm, calls))
+ monkeypatch.setattr(PluginModelClient, "_request_with_plugin_daemon_response_stream", dispatch)
+ monkeypatch.setattr(PluginModelClient, "get_model_schema", lambda *_args, **_kwargs: config.model_schema)
+ return bundle, calls, events
-class RecordingModelManager(ModelManager):
- def __init__(self, model_instance: RecordingModelInstance) -> None:
- self.model_instance = model_instance
- self.calls: list[RecordedCall] = []
- def get_model_instance(self, *args: object, **kwargs: object) -> RecordingModelInstance:
- self.calls.append(RecordedCall(args=args, kwargs=kwargs))
- return self.model_instance
+def retrieval_app(sqlite_engine: Engine) -> Iterator[Flask]:
+ """Bind the real Flask database extension for independent retrieval audit writes."""
+ app = Flask(__name__)
+ app.config["SQLALCHEMY_DATABASE_URI"] = sqlite_engine.url
+ db.init_app(app)
+ with app.app_context():
+ try:
+ yield app
+ finally:
+ db.engine.dispose()
@pytest.fixture
-def runner():
+def runner() -> CompletionAppRunner:
return CompletionAppRunner()
-def _build_app_config(dataset=None, external_tools=None, additional_features=None):
+def _build_app_config(
+ dataset: DatasetEntity | None = None,
+ external_tools: list[ExternalDataVariableEntity] | None = None,
+ additional_features: AppAdditionalFeatures | None = None,
+) -> CompletionAppConfig:
+ """None disables the corresponding optional retrieval, external-tool or feature configuration."""
return CompletionAppConfig(
app_id=APP_ID,
tenant_id=TENANT_ID,
app_mode=AppMode.COMPLETION,
app_model_config_from=EasyUIBasedAppModelConfigFrom.APP_LATEST_CONFIG,
app_model_config_id="model-config",
- model=ModelConfigEntity(provider="provider", model="model", mode="completion"),
+ model=ModelConfigEntity(provider=PROVIDER, model="model", mode="completion"),
prompt_template=PromptTemplateEntity(
prompt_type=PromptTemplateEntity.PromptType.SIMPLE,
simple_prompt_template="Answer the query.",
@@ -137,8 +184,11 @@ def _build_app_config(dataset=None, external_tools=None, additional_features=Non
)
-def _build_generate_entity(app_config, file_upload_config=None):
- model_conf = make_model_config(provider="provider", model="model", mode="completion")
+def _build_generate_entity(
+ app_config: CompletionAppConfig, file_upload_config: FileUploadConfig | None = None
+) -> CompletionAppGenerateEntity:
+ """None leaves uploads unconfigured so the runner uses its default image detail."""
+ model_conf = make_model_config(provider=PROVIDER, model="model", mode="completion")
model_conf.parameters = {"max_tokens": 10}
model_conf.stop = ["stop"]
return CompletionAppGenerateEntity(
@@ -204,7 +254,9 @@ def _persist_records(session: Session) -> tuple[App, Message]:
class TestCompletionAppRunner:
- def test_run_app_not_found(self, runner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager):
+ def test_run_app_not_found(
+ self, runner: CompletionAppRunner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager
+ ) -> None:
app_config = _build_app_config()
app_generate_entity = _build_generate_entity(app_config)
@@ -212,8 +264,8 @@ class TestCompletionAppRunner:
runner.run(app_generate_entity, queue_manager, _message(), sqlite_session)
def test_run_moderation_error_outputs_direct(
- self, runner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager
- ):
+ self, runner: CompletionAppRunner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager
+ ) -> None:
_, message = _persist_records(sqlite_session)
app_config = _build_app_config()
@@ -232,8 +284,8 @@ class TestCompletionAppRunner:
assert handle_invoke_result.calls == []
def test_run_hosting_moderation_stops(
- self, runner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager
- ):
+ self, runner: CompletionAppRunner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager
+ ) -> None:
_, message = _persist_records(sqlite_session)
app_config = _build_app_config()
@@ -253,12 +305,19 @@ class TestCompletionAppRunner:
def test_run_dataset_and_external_tools_flow(
self,
- runner,
+ runner: CompletionAppRunner,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
queue_manager: MessageBasedAppQueueManager,
- ):
+ model_runtime: tuple[ProviderModelBundle, list[RecordedCall], list[str]],
+ retrieval_app: Flask,
+ ) -> None:
_, message = _persist_records(sqlite_session)
+ dataset = Dataset(
+ id="ds", tenant_id=TENANT_ID, name="External knowledge", provider="external", created_by="user"
+ )
+ sqlite_session.add(dataset)
+ sqlite_session.commit()
retrieve_config = DatasetRetrieveConfigEntity(
query_variable="qvar",
@@ -276,9 +335,10 @@ class TestCompletionAppRunner:
app_generate_entity = _build_generate_entity(app_config, file_upload_config=file_upload_config)
- runner.organize_prompt_messages = CallRecorder( # type: ignore[method-assign]
- results=[(["pm1"], ["stop"]), (["pm2"], ["stop"])]
+ organize_prompt_messages = CallRecorder(
+ results=[([UserPromptMessage(content="pm1")], ["stop"]), ([UserPromptMessage(content="pm2")], ["stop"])]
)
+ runner.organize_prompt_messages = organize_prompt_messages # type: ignore[method-assign]
runner.moderation_for_inputs = CallRecorder( # type: ignore[method-assign]
result=(None, app_generate_entity.inputs, "query")
)
@@ -290,31 +350,37 @@ class TestCompletionAppRunner:
handle_invoke_result = CallRecorder()
runner._handle_invoke_result = handle_invoke_result # type: ignore[method-assign]
- dataset_retrieval = RecordingDatasetRetrieval(("ctx", ["file1"]))
- monkeypatch.setattr(module, "DatasetRetrieval", lambda _: dataset_retrieval)
+ retrieval_calls: list[dict[str, object]] = []
- model_instance = RecordingModelInstance()
- model_manager = RecordingModelManager(model_instance)
- monkeypatch.setattr(module.ModelManager, "for_tenant", staticmethod(lambda tenant_id: model_manager))
+ def retrieve_external(**kwargs: object) -> list[dict[str, object]]:
+ retrieval_calls.append(kwargs)
+ return [{"content": "ctx", "metadata": {}, "score": 1.0, "title": "Document"}]
+
+ monkeypatch.setattr(ExternalDatasetService, "fetch_external_knowledge_retrieval", retrieve_external)
runner.run(app_generate_entity, queue_manager, message, sqlite_session)
- assert len(dataset_retrieval.calls) == 1
- assert dataset_retrieval.calls[0].kwargs["query"] == "query_from_input"
+ assert len(retrieval_calls) == 1
+ assert retrieval_calls[0]["query"] == "query_from_input"
+ assert retrieval_calls[0]["tenant_id"] == TENANT_ID
+ assert retrieval_calls[0]["dataset_id"] == dataset.id
+ assert organize_prompt_messages.calls[-1].kwargs["context"] == "ctx"
+ assert organize_prompt_messages.calls[-1].kwargs["context_files"] == []
assert len(handle_invoke_result.calls) == 1
def test_run_closes_explicit_session_before_stream_consumption(
self,
- runner,
+ runner: CompletionAppRunner,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
queue_manager: MessageBasedAppQueueManager,
- ):
+ model_runtime: tuple[ProviderModelBundle, list[RecordedCall], list[str]],
+ ) -> None:
_, message = _persist_records(sqlite_session)
app_config = _build_app_config()
app_generate_entity = _build_generate_entity(app_config)
- events = []
+ _, _, events = model_runtime
session = sqlite_session
original_close = session.close
@@ -334,17 +400,6 @@ class TestCompletionAppRunner:
handle_invoke_result = CallRecorder(implementation=lambda invoke_result, **kwargs: list(invoke_result))
runner._handle_invoke_result = handle_invoke_result # type: ignore[method-assign]
- def invoke_stream():
- events.append("first-chunk")
- yield "chunk"
-
- def invoke_llm(**kwargs):
- events.append("invoke")
- return invoke_stream()
-
- model_instance = RecordingModelInstance(implementation=invoke_llm)
- model_manager = RecordingModelManager(model_instance)
- monkeypatch.setattr(module.ModelManager, "for_tenant", staticmethod(lambda tenant_id: model_manager))
monkeypatch.setattr(session, "close", record_close)
event.listen(session, "after_commit", record_commit)
@@ -370,64 +425,80 @@ class TestCompletionAppRunner:
@pytest.mark.parametrize("stream", [False, True])
def test_run_invokes_model_resolved_by_model_manager(
self,
- runner,
- monkeypatch: pytest.MonkeyPatch,
+ runner: CompletionAppRunner,
sqlite_session: Session,
stream: bool,
queue_manager: MessageBasedAppQueueManager,
- ):
+ model_runtime: tuple[ProviderModelBundle, list[RecordedCall], list[str]],
+ ) -> None:
_, message = _persist_records(sqlite_session)
app_config = _build_app_config()
app_generate_entity = _build_generate_entity(app_config)
app_generate_entity.stream = stream
- runner.organize_prompt_messages = CallRecorder(result=(["prompt"], ["stop"])) # type: ignore[method-assign]
+ runner.organize_prompt_messages = CallRecorder( # type: ignore[method-assign]
+ result=([UserPromptMessage(content="prompt")], ["stop"])
+ )
runner.moderation_for_inputs = CallRecorder( # type: ignore[method-assign]
result=(None, app_generate_entity.inputs, "query")
)
runner.check_hosting_moderation = CallRecorder(result=False) # type: ignore[method-assign]
runner.recalc_llm_max_tokens = CallRecorder() # type: ignore[method-assign]
- runner._handle_invoke_result = CallRecorder() # type: ignore[method-assign]
+ results: list[LLMResult | list[LLMResultChunk]] = []
+
+ def handle_result(invoke_result: LLMResult | Generator[LLMResultChunk], **_kwargs: object) -> None:
+ results.append(invoke_result if isinstance(invoke_result, LLMResult) else list(invoke_result))
- model_instance = RecordingModelInstance()
- model_manager = RecordingModelManager(model_instance)
- model_manager_factory = CallRecorder(result=model_manager)
- monkeypatch.setattr(module.ModelManager, "for_tenant", staticmethod(model_manager_factory))
+ runner._handle_invoke_result = handle_result # type: ignore[method-assign]
runner.run(app_generate_entity, queue_manager, message, sqlite_session)
- assert model_manager_factory.calls == [RecordedCall(args=(), kwargs={"tenant_id": TENANT_ID})]
- assert model_manager.calls == [
- RecordedCall(
- args=(),
- kwargs={
- "tenant_id": TENANT_ID,
- "provider": "provider",
- "model_type": ModelType.LLM,
- "model": "model",
- },
- )
- ]
- assert model_instance.calls == [
+ bundle, calls, _ = model_runtime
+ assert bundle.configuration.tenant_id == TENANT_ID
+ assert len(calls) == 2
+ assert isinstance(calls[0].args[0], PluginModelRuntime)
+ assert calls[0].kwargs["request_metadata"] == {
+ "app_id": APP_ID,
+ "app_type": CreditUsageAppType.COMPLETION,
+ "created_by": CreditUsageCreatedBy.APP,
+ }
+ assert calls[1:] == [
RecordedCall(
args=(),
kwargs={
- "prompt_messages": ["prompt"],
- "model_parameters": {"max_tokens": 10},
- "stop": ["stop"],
- "stream": stream,
- "request_metadata": {
+ "method": "POST",
+ "path": f"plugin/{TENANT_ID}/dispatch/llm/invoke",
+ "type_": LLMResultChunk,
+ "headers": {"X-Plugin-ID": "langgenius/openai", "Content-Type": "application/json"},
+ "data": {
"app_id": APP_ID,
- "app_type": CreditUsageAppType.COMPLETION,
- "created_by": CreditUsageCreatedBy.APP,
+ "data": {
+ "provider": "openai",
+ "model_type": "llm",
+ "model": "model",
+ "credentials": {"api_key": "token"},
+ "prompt_messages": [{"role": "user", "content": "prompt", "name": None}],
+ "model_parameters": {"max_tokens": 10},
+ "tools": None,
+ "stop": ["stop"],
+ "stream": stream,
+ },
},
},
)
]
+ assert len(results) == 1
+ result = results[0]
+ if stream:
+ assert isinstance(result, list)
+ assert result[0].delta.message.content == "answer"
+ else:
+ assert isinstance(result, LLMResult)
+ assert result.message.content == "answer"
def test_run_uses_low_image_detail_default(
- self, runner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager
- ):
+ self, runner: CompletionAppRunner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager
+ ) -> None:
_, message = _persist_records(sqlite_session)
app_config = _build_app_config()
diff --git a/api/tests/unit_tests/core/workflow/generator/test_tool_catalogue.py b/api/tests/unit_tests/core/workflow/generator/test_tool_catalogue.py
index 74043747f5c..bc0a02aa596 100644
--- a/api/tests/unit_tests/core/workflow/generator/test_tool_catalogue.py
+++ b/api/tests/unit_tests/core/workflow/generator/test_tool_catalogue.py
@@ -1,10 +1,24 @@
"""Unit tests for the tool catalogue helpers."""
-from types import SimpleNamespace
-from unittest.mock import patch
-
+import pytest
+
+from core.tools.__base.tool_runtime import ToolRuntime
+from core.tools.builtin_tool.provider import BuiltinToolProviderController
+from core.tools.builtin_tool.providers.time.time import WikiPediaProvider
+from core.tools.builtin_tool.providers.time.tools.current_time import CurrentTimeTool
+from core.tools.builtin_tool.tool import BuiltinTool
+from core.tools.custom_tool.provider import ApiToolProviderController
from core.tools.entities.common_entities import I18nObject
-from core.tools.entities.tool_entities import ToolDescription
+from core.tools.entities.tool_entities import (
+ ToolDescription,
+ ToolEntity,
+ ToolIdentity,
+ ToolProviderEntity,
+ ToolProviderEntityWithPlugin,
+ ToolProviderIdentity,
+)
+from core.tools.plugin_tool.provider import PluginToolProviderController
+from core.tools.tool_manager import ToolManager
from core.workflow.generator.tool_catalogue import (
MAX_ROUTED_TOOL_CANDIDATES,
MAX_ROUTED_TOOLS_PER_PROVIDER,
@@ -44,10 +58,10 @@ class TestInstalledToolKeys:
``plugin_id`` or any other identifier.
"""
- def test_empty_input_returns_empty_set(self):
+ def test_empty_input_returns_empty_set(self) -> None:
assert installed_tool_keys([]) == set()
- def test_returns_provider_tool_tuples(self):
+ def test_returns_provider_tool_tuples(self) -> None:
keys = installed_tool_keys(
[
_entry("google", "search"),
@@ -56,7 +70,7 @@ class TestInstalledToolKeys:
)
assert keys == {("google", "search"), ("github", "list_issues")}
- def test_dedupes_duplicate_entries(self):
+ def test_dedupes_duplicate_entries(self) -> None:
# Defensive — the catalogue builder dedupes on read, but a duplicate
# entry slipping through should collapse rather than break the set
# type contract.
@@ -65,10 +79,10 @@ class TestInstalledToolKeys:
class TestFormatToolCatalogue:
- def test_empty_input_returns_empty_string(self):
+ def test_empty_input_returns_empty_string(self) -> None:
assert format_tool_catalogue([]) == ""
- def test_renders_provider_slash_tool_per_line(self):
+ def test_renders_provider_slash_tool_per_line(self) -> None:
out = format_tool_catalogue(
[
_entry("google", "search", description="Search the web with Google."),
@@ -81,7 +95,7 @@ class TestFormatToolCatalogue:
'- time/current_time [provider_id="time"; tool_name="current_time"] — Return the current time.',
]
- def test_includes_label_when_different_from_tool_name(self):
+ def test_includes_label_when_different_from_tool_name(self) -> None:
out = format_tool_catalogue(
[
_entry("google", "search", label="Google Search", description="Search."),
@@ -89,7 +103,7 @@ class TestFormatToolCatalogue:
)
assert out == '- google/search (Google Search) [provider_id="google"; tool_name="search"] — Search.'
- def test_omits_label_when_identical_to_tool_name(self):
+ def test_omits_label_when_identical_to_tool_name(self) -> None:
out = format_tool_catalogue(
[
_entry("time", "current_time", label="current_time", description="Now."),
@@ -97,7 +111,7 @@ class TestFormatToolCatalogue:
)
assert out == '- time/current_time [provider_id="time"; tool_name="current_time"] — Now.'
- def test_caps_only_prompt_text_while_full_inventory_remains_available(self):
+ def test_caps_only_prompt_text_while_full_inventory_remains_available(self) -> None:
entries = [_entry("provider", f"tool_{index:03d}") for index in range(100)]
out = format_tool_catalogue(entries)
@@ -107,7 +121,7 @@ class TestFormatToolCatalogue:
assert "tool_080" not in out
assert ("provider", "tool_099") in installed_tool_keys(entries)
- def test_can_disable_prompt_cap_for_an_already_selected_catalogue(self):
+ def test_can_disable_prompt_cap_for_an_already_selected_catalogue(self) -> None:
entries = [_entry("provider", f"tool_{index:03d}") for index in range(100)]
out = format_tool_catalogue(entries, max_tools=None)
@@ -115,21 +129,21 @@ class TestFormatToolCatalogue:
assert len(out.splitlines()) == 100
assert "tool_099" in out
- def test_truncates_long_descriptions(self):
+ def test_truncates_long_descriptions(self) -> None:
long_desc = "x" * 200
out = format_tool_catalogue([_entry("p", "t", description=long_desc)])
# Truncated to 117 chars + "..."
assert out.endswith("...")
assert len(out.split(" — ", 1)[1]) == 120
- def test_strips_newlines_from_descriptions(self):
+ def test_strips_newlines_from_descriptions(self) -> None:
out = format_tool_catalogue([_entry("p", "t", description="line1\nline2\nline3")])
assert "\n" not in out.split(" — ", 1)[1]
assert "line1 line2 line3" in out
class TestSelectToolCandidates:
- def test_routes_english_capability_query_to_relevant_tool_description(self):
+ def test_routes_english_capability_query_to_relevant_tool_description(self) -> None:
entries = [
*[_entry(f"provider_{index}", "generic", description="Manage generic records.") for index in range(30)],
_entry(
@@ -150,7 +164,7 @@ class TestSelectToolCandidates:
]
assert selection.unmatched_queries == []
- def test_pins_explicit_identifier_and_existing_refine_tool_without_queries(self):
+ def test_pins_explicit_identifier_and_existing_refine_tool_without_queries(self) -> None:
entries = [
_entry("langgenius/google/google", "search"),
_entry("langgenius/time/time", "current_time"),
@@ -182,7 +196,7 @@ class TestSelectToolCandidates:
]
assert selection.pinned_count == 2
- def test_explicit_identifier_does_not_also_pin_a_hyphenated_prefix(self):
+ def test_explicit_identifier_does_not_also_pin_a_hyphenated_prefix(self) -> None:
entries = [
_entry("provider", "search"),
_entry("provider", "search-web"),
@@ -197,7 +211,7 @@ class TestSelectToolCandidates:
assert selection.entries == [entries[1]]
assert selection.pinned_count == 1
- def test_reports_unmatched_capability_for_legacy_fallback(self):
+ def test_reports_unmatched_capability_for_legacy_fallback(self) -> None:
selection = select_tool_candidates(
[_entry("records", "list", description="List stored database records.")],
[ToolCapabilityQuery(capability="synthesize quantum music", keywords=["qubits", "melody"])],
@@ -206,7 +220,7 @@ class TestSelectToolCandidates:
assert selection.entries == []
assert selection.unmatched_queries == ["synthesize quantum music"]
- def test_deduplicates_one_tool_selected_by_multiple_queries(self):
+ def test_deduplicates_one_tool_selected_by_multiple_queries(self) -> None:
entries = [
_entry(
"langgenius/google/google",
@@ -224,7 +238,7 @@ class TestSelectToolCandidates:
assert selection.entries == entries
- def test_enforces_provider_diversity(self):
+ def test_enforces_provider_diversity(self) -> None:
words = ["alpha", "bravo", "charlie", "delta", "echo"]
entries = [
_entry("large_provider", f"{word}_action", description=f"Perform the {word} capability.") for word in words
@@ -238,7 +252,7 @@ class TestSelectToolCandidates:
)
assert selection.entries == select_tool_candidates(entries, queries).entries
- def test_500_tool_catalogue_never_exceeds_global_candidate_limit(self):
+ def test_500_tool_catalogue_never_exceeds_global_candidate_limit(self) -> None:
words = ["alpha", "bravo", "charlie", "delta", "echo"]
entries = [
_entry(
@@ -255,7 +269,7 @@ class TestSelectToolCandidates:
assert len(selection.entries) == 15
assert len(selection.entries) <= MAX_ROUTED_TOOL_CANDIDATES
- def test_legacy_fallback_keeps_explicit_tool_beyond_first_80(self):
+ def test_legacy_fallback_keeps_explicit_tool_beyond_first_80(self) -> None:
entries = [_entry("provider", f"tool_{index:03d}") for index in range(100)]
selected = select_legacy_fallback_tools(
@@ -270,7 +284,7 @@ class TestSelectToolCandidates:
class TestLegacyFallbackSelection:
- def test_returns_selected_and_omitted_tools(self):
+ def test_returns_selected_and_omitted_tools(self) -> None:
entries = [_entry("provider", f"tool_{index:03d}") for index in range(100)]
selection = select_legacy_fallback_selection(entries)
@@ -281,12 +295,12 @@ class TestLegacyFallbackSelection:
assert selection.limit == 80
assert selection.overflow_count == 0
- def test_keeps_legacy_fallback_tools_compatible(self):
+ def test_keeps_legacy_fallback_tools_compatible(self) -> None:
entries = [_entry("provider", f"tool_{index:03d}") for index in range(100)]
assert select_legacy_fallback_tools(entries) == select_legacy_fallback_selection(entries).entries
- def test_reports_pinned_overflow_without_fabricated_omissions(self):
+ def test_reports_pinned_overflow_without_fabricated_omissions(self) -> None:
entries = [_entry("provider", f"tool_{index:03d}") for index in range(85)]
explicit_text = "Use " + ", ".join(f"provider/{entry['tool_name']}" for entry in entries) + " exactly."
@@ -298,7 +312,7 @@ class TestLegacyFallbackSelection:
assert selection.limit == 80
assert selection.overflow_count == 5
- def test_empty_catalogue_has_no_omissions_or_overflow(self):
+ def test_empty_catalogue_has_no_omissions_or_overflow(self) -> None:
selection = select_legacy_fallback_selection([])
assert selection.entries == []
@@ -309,13 +323,13 @@ class TestLegacyFallbackSelection:
class TestToolBuilderContext:
- def test_finds_exact_provider_and_tool_pair(self):
+ def test_finds_exact_provider_and_tool_pair(self) -> None:
entries = [_entry("google", "search"), _entry("google", "maps")]
assert find_tool_entry(entries, "google", "search") == entries[0]
assert find_tool_entry(entries, "google", "missing") is None
- def test_renders_trusted_identity_and_parameter_contract(self):
+ def test_renders_trusted_identity_and_parameter_contract(self) -> None:
entry = _entry("langgenius/google/google", "search", label="Google Search", description="Search the web.")
entry["plugin_id"] = "langgenius/google"
entry["plugin_unique_identifier"] = "langgenius/google:1.0@checksum"
@@ -358,130 +372,71 @@ class TestToolBuilderContext:
# ── Helpers ──────────────────────────────────────────────────────────────────
-class _FakeToolEntity(SimpleNamespace):
- """Tool entity exposing ``identity`` + ``description`` like the real thing."""
-
-
-class _FakeToolIdentity(SimpleNamespace):
- """Identity holding ``name`` + ``label`` like ``ToolIdentity``."""
-
-
-class _FakeTool:
- """Tool stand-in: ``.entity`` is the only attribute the catalogue reads."""
-
- def __init__(self, entity):
- self.entity = entity
-
-
-def _make_tool(name: str, label_en: str = "", description_llm: str = "") -> _FakeTool:
- return _FakeTool(
- entity=_FakeToolEntity(
- identity=_FakeToolIdentity(
- name=name,
- label=I18nObject(en_US=label_en),
- ),
+def _make_tool(name: str, label_en: str = "", description_llm: str = "") -> BuiltinTool:
+ """Use a real builtin tool with optional empty display metadata."""
+ return CurrentTimeTool(
+ provider="time",
+ runtime=ToolRuntime(tenant_id="tenant-1"),
+ entity=ToolEntity(
+ identity=ToolIdentity(author="test", provider="time", name=name, label=I18nObject(en_US=label_en)),
description=ToolDescription(human=I18nObject(en_US=""), llm=description_llm),
- parameters=[],
- output_schema={},
- )
+ ),
)
-class _FakeProviderType(SimpleNamespace):
- """Stand-in for ``ToolProviderType`` — only ``.value`` is read."""
+def _make_builtin_provider(name: str, tools: list[BuiltinTool]) -> BuiltinToolProviderController:
+ """Load the shipped time provider, then configure its real tool inventory."""
+ provider = WikiPediaProvider()
+ provider.entity.identity.name = name
+ provider.tools = tools
+ return provider
-def _make_builtin_provider(name: str, tools: list, raises_on_get_tools: bool = False):
- """
- Build something ``isinstance(..., BuiltinToolProviderController)`` will
- answer True to without actually constructing one (those require real
- on-disk plugin metadata). We patch the isinstance call sites instead.
- """
- provider = SimpleNamespace(
- entity=SimpleNamespace(identity=SimpleNamespace(name=name)),
- provider_type=_FakeProviderType(value="builtin"),
- get_tools=((lambda: (_ for _ in ()).throw(RuntimeError("boom"))) if raises_on_get_tools else (lambda: tools)),
+def _provider_identity(name: str) -> ToolProviderIdentity:
+ return ToolProviderIdentity(
+ author="test", name=name, description=I18nObject(en_US=name), icon="", label=I18nObject(en_US=name)
)
- provider._is_builtin = True
- return provider
-def _make_plugin_provider(name: str, plugin_id: str | None, tools: list):
- provider = SimpleNamespace(
- entity=SimpleNamespace(identity=SimpleNamespace(name=name)),
- provider_type=_FakeProviderType(value="plugin"),
+def _make_plugin_provider(name: str, plugin_id: str, tools: list[BuiltinTool]) -> PluginToolProviderController:
+ return PluginToolProviderController(
+ entity=ToolProviderEntityWithPlugin(identity=_provider_identity(name), tools=[tool.entity for tool in tools]),
plugin_id=plugin_id,
plugin_unique_identifier=f"{plugin_id}:1.0@checksum" if plugin_id else "",
- get_tools=lambda: tools,
+ tenant_id="tenant-1",
)
- provider._is_plugin = True
- return provider
-
-
-def _make_unknown_provider(name: str):
- """A provider matching neither class — must be skipped."""
- return SimpleNamespace(
- entity=SimpleNamespace(identity=SimpleNamespace(name=name)),
- provider_type=_FakeProviderType(value="weird"),
- get_tools=lambda: [_make_tool("ghost")],
- )
-
-
-def _patched_isinstance(obj, cls):
- """
- Reroute the isinstance checks ``build_tool_catalogue`` makes onto the fake
- providers built above.
-
- Match the provider classes by ``__name__`` rather than by identity (``is``).
- In the full test suite a sibling test that reloads or stubs
- ``core.tools.*.provider`` (e.g. via ``sys.modules``) gives the catalogue a
- DIFFERENT class object than a fresh ``import`` here would; an ``is`` check
- would then miss, every fake provider would fall through to the real
- ``isinstance`` and fail it, and the catalogue would come back empty — which
- is exactly how this test flaked in CI under parallel execution. A name match
- is immune to those reloads. Anything we don't recognise (including tuple
- ``cls`` args) defers to the real ``isinstance``.
- """
- cls_name = getattr(cls, "__name__", "")
- if cls_name == "BuiltinToolProviderController":
- return bool(getattr(obj, "_is_builtin", False))
- if cls_name == "PluginToolProviderController":
- return bool(getattr(obj, "_is_plugin", False))
- import builtins as _b
-
- return _b.isinstance(obj, cls)
# ── _i18n_text / _tool_description ───────────────────────────────────────────
class TestI18nText:
- def test_returns_empty_string_when_label_is_none(self):
+ def test_returns_empty_string_when_label_is_none(self) -> None:
assert _i18n_text(None) == ""
- def test_returns_en_us_when_present(self):
+ def test_returns_en_us_when_present(self) -> None:
assert _i18n_text(I18nObject(en_US="Search", zh_Hans="搜索")) == "Search"
- def test_falls_back_to_zh_hans_when_en_us_blank(self):
+ def test_falls_back_to_zh_hans_when_en_us_blank(self) -> None:
# Some plugins ship only Chinese metadata; falling back keeps the
# planner aware of those tools instead of dropping them silently.
assert _i18n_text(I18nObject(en_US="", zh_Hans="搜索")) == "搜索"
- def test_returns_empty_when_both_locales_are_blank(self):
+ def test_returns_empty_when_both_locales_are_blank(self) -> None:
assert _i18n_text(I18nObject(en_US="", zh_Hans="")) == ""
class TestToolDescription:
- def test_returns_empty_string_for_none_description(self):
+ def test_returns_empty_string_for_none_description(self) -> None:
# ToolEntity.description is Optional — must not raise on absent.
assert _tool_description(None) == ""
- def test_returns_llm_attribute(self):
+ def test_returns_llm_attribute(self) -> None:
description = ToolDescription(human=I18nObject(en_US=""), llm="Web search")
assert _tool_description(description) == "Web search"
- def test_returns_empty_when_llm_is_blank(self):
+ def test_returns_empty_when_llm_is_blank(self) -> None:
description = ToolDescription(human=I18nObject(en_US=""), llm="")
assert _tool_description(description) == ""
@@ -494,20 +449,16 @@ class TestBuildToolCatalogue:
"""
The builder iterates the ``ToolManager.list_builtin_providers`` generator
(which already covers both hardcoded and plugin providers in production).
- We patch the generator + isinstance so the tests can exercise every branch
- without standing up real plugin daemon state.
+ Real builtin and plugin controllers retain their constructors and type checks.
+ Only provider discovery and intentional failure injection are isolated.
"""
- @patch("core.workflow.generator.tool_catalogue.isinstance", side_effect=_patched_isinstance)
- @patch("core.workflow.generator.tool_catalogue.ToolManager.list_builtin_providers")
- def test_returns_empty_list_for_tenant_with_no_tools(self, mock_list, mock_isinstance):
- mock_list.return_value = iter([])
+ def test_returns_empty_list_for_tenant_with_no_tools(self, monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setattr(ToolManager, "list_builtin_providers", lambda _tenant: iter([]))
assert build_tool_catalogue("tenant-1") == []
- @patch("core.workflow.generator.tool_catalogue.isinstance", side_effect=_patched_isinstance)
- @patch("core.workflow.generator.tool_catalogue.ToolManager.list_builtin_providers")
- def test_collects_hardcoded_and_plugin_tools(self, mock_list, mock_isinstance):
+ def test_collects_hardcoded_and_plugin_tools(self, monkeypatch: pytest.MonkeyPatch) -> None:
# Mixed-tenant scenario: hardcoded provider plus a plugin provider,
# each carrying one tool. The catalogue must include all four fields
# the workflow tool node will need (provider_name / provider_type /
@@ -521,7 +472,7 @@ class TestBuildToolCatalogue:
plugin_id="langgenius/google",
tools=[_make_tool("search", label_en="Google Search", description_llm="Search the web.")],
)
- mock_list.return_value = iter([hardcoded, plugin])
+ monkeypatch.setattr(ToolManager, "list_builtin_providers", lambda _tenant: iter([hardcoded, plugin]))
entries = build_tool_catalogue("tenant-1")
@@ -542,52 +493,54 @@ class TestBuildToolCatalogue:
assert time_entry["provider_type"] == "builtin"
assert time_entry["plugin_id"] == ""
- @patch("core.workflow.generator.tool_catalogue.isinstance", side_effect=_patched_isinstance)
- @patch("core.workflow.generator.tool_catalogue.ToolManager.list_builtin_providers")
- def test_skips_unknown_provider_classes(self, mock_list, mock_isinstance):
+ def test_skips_unknown_provider_classes(self, monkeypatch: pytest.MonkeyPatch) -> None:
# If ToolManager ever yields a provider the catalogue doesn't know how
# to label, we must continue (not raise) and leave it out of the
# output rather than guessing at provider_type.
- unknown = _make_unknown_provider("mystery")
+ unknown = ApiToolProviderController(
+ entity=ToolProviderEntity(identity=_provider_identity("mystery")),
+ provider_id="provider-id",
+ tenant_id="tenant-1",
+ )
hardcoded = _make_builtin_provider("time", [_make_tool("now")])
- mock_list.return_value = iter([unknown, hardcoded])
+ monkeypatch.setattr(ToolManager, "list_builtin_providers", lambda _tenant: iter([unknown, hardcoded]))
entries = build_tool_catalogue("tenant-1")
assert [e["provider_name"] for e in entries] == ["time"]
- @patch("core.workflow.generator.tool_catalogue.isinstance", side_effect=_patched_isinstance)
- @patch("core.workflow.generator.tool_catalogue.ToolManager.list_builtin_providers")
- def test_continues_when_a_provider_get_tools_raises(self, mock_list, mock_isinstance):
+ def test_continues_when_a_provider_get_tools_raises(self, monkeypatch: pytest.MonkeyPatch) -> None:
# A buggy plugin must not break the whole catalogue. Resilient
# per-provider try/except is what keeps generation usable in tenants
# with broken installs.
- bad = _make_builtin_provider("broken", [], raises_on_get_tools=True)
+ bad = _make_builtin_provider("broken", [])
+
+ def unavailable() -> list[BuiltinTool]:
+ raise RuntimeError("boom")
+
+ monkeypatch.setattr(bad, "get_tools", unavailable)
good = _make_builtin_provider("time", [_make_tool("now")])
- mock_list.return_value = iter([bad, good])
+ monkeypatch.setattr(ToolManager, "list_builtin_providers", lambda _tenant: iter([bad, good]))
entries = build_tool_catalogue("tenant-1")
assert [e["provider_name"] for e in entries] == ["time"]
- @patch("core.workflow.generator.tool_catalogue.isinstance", side_effect=_patched_isinstance)
- @patch("core.workflow.generator.tool_catalogue.ToolManager.list_builtin_providers")
- def test_skips_individual_tools_when_their_metadata_is_broken(self, mock_list, mock_isinstance):
+ def test_skips_individual_tools_when_their_metadata_is_broken(self, monkeypatch: pytest.MonkeyPatch) -> None:
# Per-tool try/except — a single mis-declared tool inside an otherwise
# healthy provider gets dropped, the rest still surface.
good_tool = _make_tool("ok", label_en="Ok", description_llm="Healthy tool.")
- # Bad tool: accessing .entity.identity raises because entity is None.
- bad_tool = SimpleNamespace(entity=None)
+ # Inject corrupt metadata after normal construction to exercise defensive handling.
+ bad_tool = _make_tool("bad")
+ monkeypatch.setattr(bad_tool, "entity", None)
hardcoded = _make_builtin_provider("p", [bad_tool, good_tool])
- mock_list.return_value = iter([hardcoded])
+ monkeypatch.setattr(ToolManager, "list_builtin_providers", lambda _tenant: iter([hardcoded]))
entries = build_tool_catalogue("tenant-1")
assert [e["tool_name"] for e in entries] == ["ok"]
- @patch("core.workflow.generator.tool_catalogue.isinstance", side_effect=_patched_isinstance)
- @patch("core.workflow.generator.tool_catalogue.ToolManager.list_builtin_providers")
- def test_keeps_complete_inventory_for_validation_beyond_prompt_cap(self, mock_list, mock_isinstance):
+ def test_keeps_complete_inventory_for_validation_beyond_prompt_cap(self, monkeypatch: pytest.MonkeyPatch) -> None:
# Prompt formatting is capped separately. Dropping entries here would
# make the validator falsely report installed tools after the cap as
# missing from the workspace.
@@ -595,21 +548,20 @@ class TestBuildToolCatalogue:
"p",
[_make_tool(f"t{i:03d}") for i in range(200)],
)
- mock_list.return_value = iter([big_provider])
+ monkeypatch.setattr(ToolManager, "list_builtin_providers", lambda _tenant: iter([big_provider]))
entries = build_tool_catalogue("tenant-1")
assert len(entries) == 200
assert ("p", "t199") in installed_tool_keys(entries)
- @patch("core.workflow.generator.tool_catalogue.isinstance", side_effect=_patched_isinstance)
- @patch("core.workflow.generator.tool_catalogue.ToolManager.list_builtin_providers")
- def test_defaults_plugin_id_to_empty_string_when_missing(self, mock_list, mock_isinstance):
+ def test_defaults_plugin_id_to_empty_string_when_missing(self, monkeypatch: pytest.MonkeyPatch) -> None:
# Plugin provider whose plugin_id is None should serialise to "" so
# the consumer can safely index ``e["plugin_id"]`` without a None
# check at every callsite.
- plugin = _make_plugin_provider("p", plugin_id=None, tools=[_make_tool("t")])
- mock_list.return_value = iter([plugin])
+ plugin = _make_plugin_provider("p", plugin_id="", tools=[_make_tool("t")])
+ monkeypatch.setattr(plugin, "plugin_id", None)
+ monkeypatch.setattr(ToolManager, "list_builtin_providers", lambda _tenant: iter([plugin]))
entries = build_tool_catalogue("tenant-1")
diff --git a/api/tests/unit_tests/pyrefly.toml b/api/tests/unit_tests/pyrefly.toml
index dc569b5be7f..328f893c1ac 100644
--- a/api/tests/unit_tests/pyrefly.toml
+++ b/api/tests/unit_tests/pyrefly.toml
@@ -197,7 +197,6 @@ project-excludes = [
"core/app/apps/common/test_workflow_response_converter_human_input.py",
"core/app/apps/common/test_workflow_response_converter_resumption.py",
"core/app/apps/common/test_workflow_response_converter_truncation.py",
- "core/app/apps/completion/test_app_runner.py",
"core/app/apps/completion/test_completion_app_config_manager.py",
"core/app/apps/completion/test_completion_completion_app_generator.py",
"core/app/apps/completion/test_completion_generate_response_converter.py",
@@ -412,7 +411,6 @@ project-excludes = [
"core/workflow/generator/test_prompts.py",
"core/workflow/generator/test_runner.py",
"core/workflow/generator/test_runner_missing.py",
- "core/workflow/generator/test_tool_catalogue.py",
"core/workflow/graph_engine/layers/conftest.py",
"core/workflow/graph_engine/layers/test_observability.py",
"core/workflow/graph_engine/test_mock_config.py",
@@ -634,7 +632,6 @@ project-excludes = [
"services/test_webhook_service_additional.py",
"services/test_website_service.py",
"services/test_workflow_collaboration_service.py",
- "services/test_workflow_generator_service.py",
"services/test_workflow_node_execution_trace_service.py",
"services/test_workflow_run_service.py",
"services/test_workflow_run_service_pause.py",
diff --git a/api/tests/unit_tests/services/test_api_token_service.py b/api/tests/unit_tests/services/test_api_token_service.py
index fd07797c0e0..5670552deb9 100644
--- a/api/tests/unit_tests/services/test_api_token_service.py
+++ b/api/tests/unit_tests/services/test_api_token_service.py
@@ -4,15 +4,17 @@ from __future__ import annotations
from collections.abc import Iterator
from datetime import datetime
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
from uuid import uuid4
import pytest
from flask import Flask
+from redis import Redis
from sqlalchemy.orm import Session
from werkzeug.exceptions import Unauthorized
import services.api_token_service as api_token_service_module
+from extensions.ext_redis import RedisClientWrapper
from models.engine import db
from models.enums import ApiTokenType
from models.model import ApiToken
@@ -111,8 +113,37 @@ class TestRecordTokenUsage:
api_token_service_module.record_token_usage("token-123", "app")
+def single_flight_redis(monkeypatch: pytest.MonkeyPatch) -> Iterator[tuple[Redis, list[tuple[object, ...]]]]:
+ """Use the real Redis client, wrapper and lock; isolate only wire commands."""
+ commands: list[tuple[object, ...]] = []
+
+ def execute(*args: object, **_kwargs: object) -> object:
+ commands.append(args)
+ assert args[0] in {"SET", "EVALSHA"}
+ return True
+
+ with Redis() as client:
+ monkeypatch.setattr(client, "execute_command", execute)
+ wrapper = RedisClientWrapper()
+ wrapper.initialize(client)
+ monkeypatch.setattr(api_token_service_module, "redis_client", wrapper)
+ yield client, commands
+
+
+def _assert_lock_released(commands: list[tuple[object, ...]]) -> None:
+ assert len(commands) == 2
+ acquire, release = commands
+ assert acquire[:2] == ("SET", "api_token_query_lock:app:token-123")
+ assert acquire[3:] == ("NX", "PX", 10000)
+ assert release[0] == "EVALSHA"
+ assert release[2:] == (1, acquire[1], acquire[2]) # Release uses the acquired ownership token.
+
+
class TestFetchTokenWithSingleFlight:
- def test_should_return_cached_token_when_lock_acquired_and_cache_filled(self):
+ def test_should_return_cached_token_when_lock_acquired_and_cache_filled(
+ self, single_flight_redis: tuple[Redis, list[tuple[object, ...]]]
+ ) -> None:
auth_token = "token-123"
scope = "app"
cached_token = CachedApiToken(
@@ -124,69 +155,71 @@ class TestFetchTokenWithSingleFlight:
last_used_at=None,
created_at=None,
)
- lock = MagicMock()
- lock.acquire.return_value = True
+ _client, commands = single_flight_redis
with (
- patch.object(api_token_service_module, "redis_client") as mock_redis,
patch.object(api_token_service_module.ApiTokenCache, "get", return_value=cached_token),
patch.object(api_token_service_module, "query_token_from_db") as mock_query_db,
):
- mock_redis.lock.return_value = lock
result = api_token_service_module.fetch_token_with_single_flight(auth_token, scope)
assert result == cached_token
- lock.acquire.assert_called_once_with(blocking=True)
- lock.release.assert_called_once()
+ _assert_lock_released(commands)
mock_query_db.assert_not_called()
- def test_should_query_db_when_lock_acquired_and_cache_missed(self):
+ def test_should_query_db_when_lock_acquired_and_cache_missed(
+ self, single_flight_redis: tuple[Redis, list[tuple[object, ...]]]
+ ) -> None:
auth_token = "token-123"
scope = "app"
db_token = _api_token()
- lock = MagicMock()
- lock.acquire.return_value = True
+ _client, commands = single_flight_redis
with (
- patch.object(api_token_service_module, "redis_client") as mock_redis,
patch.object(api_token_service_module.ApiTokenCache, "get", return_value=None),
patch.object(api_token_service_module, "query_token_from_db", return_value=db_token) as mock_query_db,
):
- mock_redis.lock.return_value = lock
result = api_token_service_module.fetch_token_with_single_flight(auth_token, scope)
assert result == db_token
mock_query_db.assert_called_once_with(auth_token, scope)
- lock.release.assert_called_once()
+ _assert_lock_released(commands)
- def test_should_query_db_directly_when_lock_not_acquired(self):
+ def test_should_query_db_directly_when_lock_not_acquired(
+ self, single_flight_redis: tuple[Redis, list[tuple[object, ...]]], monkeypatch: pytest.MonkeyPatch
+ ) -> None:
auth_token = "token-123"
scope = "app"
db_token = _api_token()
- lock = MagicMock()
- lock.acquire.return_value = False
+ client, commands = single_flight_redis
+
+ def contended(*args: object, **_kwargs: object) -> bool:
+ commands.append(args)
+ assert args[0] == "SET"
+ return False
+
+ monkeypatch.setattr(client, "execute_command", contended)
with (
- patch.object(api_token_service_module, "redis_client") as mock_redis,
patch.object(api_token_service_module.ApiTokenCache, "get") as mock_cache_get,
patch.object(api_token_service_module, "query_token_from_db", return_value=db_token) as mock_query_db,
):
- mock_redis.lock.return_value = lock
result = api_token_service_module.fetch_token_with_single_flight(auth_token, scope)
assert result == db_token
mock_cache_get.assert_not_called()
mock_query_db.assert_called_once_with(auth_token, scope)
- lock.release.assert_not_called()
+ assert commands
+ assert all(command[0] == "SET" for command in commands)
- def test_should_reraise_unauthorized_from_db_query(self):
+ def test_should_reraise_unauthorized_from_db_query(
+ self, single_flight_redis: tuple[Redis, list[tuple[object, ...]]]
+ ) -> None:
auth_token = "token-123"
scope = "app"
- lock = MagicMock()
- lock.acquire.return_value = True
+ _client, commands = single_flight_redis
with (
- patch.object(api_token_service_module, "redis_client") as mock_redis,
patch.object(api_token_service_module.ApiTokenCache, "get", return_value=None),
patch.object(
api_token_service_module,
@@ -194,28 +227,34 @@ class TestFetchTokenWithSingleFlight:
side_effect=Unauthorized("Access token is invalid"),
),
):
- mock_redis.lock.return_value = lock
with pytest.raises(Unauthorized, match="Access token is invalid"):
api_token_service_module.fetch_token_with_single_flight(auth_token, scope)
- lock.release.assert_called_once()
+ _assert_lock_released(commands)
- def test_should_fallback_to_db_query_when_lock_raises_exception(self):
+ def test_should_fallback_to_db_query_when_lock_raises_exception(
+ self, single_flight_redis: tuple[Redis, list[tuple[object, ...]]], monkeypatch: pytest.MonkeyPatch
+ ) -> None:
auth_token = "token-123"
scope = "app"
db_token = _api_token()
- lock = MagicMock()
- lock.acquire.side_effect = RuntimeError("redis lock error")
+ client, commands = single_flight_redis
+
+ def unavailable(*args: object, **_kwargs: object) -> bool:
+ commands.append(args)
+ raise RuntimeError("redis lock error")
+
+ monkeypatch.setattr(client, "execute_command", unavailable)
with (
- patch.object(api_token_service_module, "redis_client") as mock_redis,
patch.object(api_token_service_module, "query_token_from_db", return_value=db_token) as mock_query_db,
):
- mock_redis.lock.return_value = lock
result = api_token_service_module.fetch_token_with_single_flight(auth_token, scope)
assert result == db_token
mock_query_db.assert_called_once_with(auth_token, scope)
+ assert len(commands) == 1
+ assert commands[0][:2] == ("SET", "api_token_query_lock:app:token-123")
class TestApiTokenCacheTenantBranches:
diff --git a/api/tests/unit_tests/services/test_workflow_generator_service.py b/api/tests/unit_tests/services/test_workflow_generator_service.py
index 86f4010bfa2..b0dc2620e7e 100644
--- a/api/tests/unit_tests/services/test_workflow_generator_service.py
+++ b/api/tests/unit_tests/services/test_workflow_generator_service.py
@@ -1,297 +1,307 @@
-"""
-Unit tests for ``WorkflowGeneratorService``.
+"""Exercise service wiring through the real model, tool catalogue and graph generator.
-The service is a thin facade — its job is (1) hand the tenant model_config to
-``ModelManager`` to get a model_instance, (2) build the tool catalogue, and
-(3) delegate to ``WorkflowGenerator``. We mock both dependencies so the tests
-stay fast and focus on the wiring itself.
+Only provider discovery, schema lookup, Redis commands and plugin-daemon I/O are
+isolated. Delegating spies preserve the production generator and runtime behavior.
"""
-from unittest.mock import MagicMock, patch
+import json
+from collections.abc import Callable, Generator, Iterator
+from dataclasses import dataclass, field
+
+import pytest
+from redis import Redis
from core.app.app_config.entities import ModelConfig
from core.credit_usage import CreditUsageAppType, CreditUsageCreatedBy
-from graphon.model_runtime.entities.llm_entities import LLMMode
+from core.entities.provider_configuration import ProviderModelBundle
+from core.entities.provider_entities import CustomProviderConfiguration
+from core.model_manager import ModelInstance
+from core.plugin.impl.model import PluginModelClient
+from core.plugin.impl.model_runtime import PluginModelRuntime
+from core.plugin.impl.model_runtime_factory import create_plugin_model_runtime
+from core.provider_manager import ProviderManager
+from core.tools.entities.common_entities import I18nObject
+from core.tools.entities.tool_entities import (
+ ToolDescription,
+ ToolEntity,
+ ToolIdentity,
+ ToolProviderEntityWithPlugin,
+ ToolProviderIdentity,
+)
+from core.tools.plugin_tool.provider import PluginToolProviderController
+from core.tools.tool_manager import ToolManager
+from core.workflow.generator import WorkflowGenerator
+from extensions.ext_redis import RedisClientWrapper
+from graphon.model_runtime.entities.llm_entities import LLMMode, LLMResultChunk, LLMResultChunkDelta
+from graphon.model_runtime.entities.message_entities import AssistantPromptMessage
+from graphon.model_runtime.entities.model_entities import ModelType
+from graphon.model_runtime.model_providers.base.large_language_model import LargeLanguageModel
from services.workflow_generator_service import WorkflowGeneratorService
+from tests.unit_tests.core.model_fixtures import make_model_config
+
+TENANT_ID = "t-1"
+PROVIDER = "langgenius/openai/openai"
def _model_config() -> ModelConfig:
- return ModelConfig(
- provider="openai",
- name="gpt-4o",
- mode=LLMMode.CHAT,
- completion_params={"temperature": 0.4},
- )
+ return ModelConfig(provider=PROVIDER, name="gpt-4o", mode=LLMMode.CHAT, completion_params={"temperature": 0.4})
-class TestWorkflowGeneratorService:
- @patch("services.workflow_generator_service.WorkflowGenerator")
- @patch("services.workflow_generator_service.ModelManager")
- @patch("services.workflow_generator_service.build_tool_catalogue")
- def test_forwards_model_instance_and_complete_catalogue_to_generator(
- self,
- mock_build_catalogue: MagicMock,
- mock_model_manager: MagicMock,
- mock_workflow_generator: MagicMock,
- ):
- """Happy path: the runner receives the complete catalogue for dynamic routing."""
- # Arrange
- instance = MagicMock(name="model_instance")
- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = instance
- mock_build_catalogue.return_value = [
- {
- "provider_name": "google",
- "provider_type": "builtin",
- "plugin_id": "",
- "tool_name": "search",
- "tool_label": "Search",
- "description": "Search.",
- }
- ]
- mock_workflow_generator.generate_workflow_graph.return_value = {
- "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
- "message": "ok",
- "error": "",
- }
+def _record[**P, R](function: Callable[P, R], calls: list[dict[str, object]]) -> Callable[P, R]:
+ """Observe keyword arguments and execute the original method unchanged."""
- # Act
- result = WorkflowGeneratorService.generate_workflow_graph(
- tenant_id="t-1",
- mode="workflow",
- instruction="Summarize a URL",
- model_config=_model_config(),
- ideal_output="A 3-sentence summary",
- )
+ def delegated(*args: P.args, **kwargs: P.kwargs) -> R:
+ calls.append(dict(kwargs))
+ return function(*args, **kwargs)
- # Assert
- mock_model_manager.for_tenant.assert_called_once_with(
- tenant_id="t-1",
- request_metadata={
- "app_type": CreditUsageAppType.WORKFLOW,
- "created_by": CreditUsageCreatedBy.WORKFLOW_GENERATION,
- },
- )
- mock_workflow_generator.generate_workflow_graph.assert_called_once()
- call_kwargs = mock_workflow_generator.generate_workflow_graph.call_args.kwargs
- assert call_kwargs["model_instance"] is instance
- assert call_kwargs["provider"] == "openai"
- assert call_kwargs["model_name"] == "gpt-4o"
- assert call_kwargs["mode"] == "workflow"
- assert call_kwargs["instruction"] == "Summarize a URL"
- assert call_kwargs["ideal_output"] == "A 3-sentence summary"
- assert call_kwargs["tool_catalogue_text"] == ""
- assert call_kwargs["tool_catalogue_entries"] == mock_build_catalogue.return_value
- assert call_kwargs["model_parameters"] == {"temperature": 0.4}
- assert result["error"] == ""
-
- @patch("services.workflow_generator_service.WorkflowGenerator")
- @patch("services.workflow_generator_service.ModelManager")
- @patch("services.workflow_generator_service.build_tool_catalogue")
- def test_catalogue_build_failure_falls_back_to_empty_text(
- self,
- mock_build_catalogue,
- mock_model_manager,
- mock_workflow_generator,
- ):
- """
- A plugin-daemon outage must not block generation — the catalogue helper
- is wrapped in try/except so a failure downgrades to an empty catalogue.
- """
- # Arrange
- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = MagicMock()
- mock_build_catalogue.side_effect = RuntimeError("plugin daemon unreachable")
- mock_workflow_generator.generate_workflow_graph.return_value = {
- "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
- "message": "",
- "error": "",
- }
+ return delegated
- # Act
- WorkflowGeneratorService.generate_workflow_graph(
- tenant_id="t-1",
- mode="workflow",
- instruction="Summarize a URL",
- model_config=_model_config(),
- )
- # Assert: generation still ran, catalogue text was empty.
- call_kwargs = mock_workflow_generator.generate_workflow_graph.call_args.kwargs
- assert call_kwargs["tool_catalogue_text"] == ""
-
- @patch("services.workflow_generator_service.WorkflowGenerator")
- @patch("services.workflow_generator_service.ModelManager")
- @patch("services.workflow_generator_service.build_tool_catalogue")
- def test_defaults_ideal_output_to_empty_string(
- self,
- mock_build_catalogue: MagicMock,
- mock_model_manager: MagicMock,
- mock_workflow_generator: MagicMock,
- ):
- """Callers can omit ideal_output; the runner should still receive ""."""
- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = MagicMock()
- mock_build_catalogue.return_value = []
- mock_workflow_generator.generate_workflow_graph.return_value = {
- "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
- "message": "",
- "error": "",
- }
+@dataclass
+class GenerationObservations:
+ """Fixture data and captured calls, not a substitute for a production dependency."""
- WorkflowGeneratorService.generate_workflow_graph(
- tenant_id="t-1",
- mode="advanced-chat",
- instruction="A chat bot",
- model_config=_model_config(),
- )
+ bundle: ProviderModelBundle
+ providers: list[PluginToolProviderController] = field(default_factory=list)
+ generator_calls: list[dict[str, object]] = field(default_factory=list)
+ runtime_calls: list[dict[str, object]] = field(default_factory=list)
+ daemon_calls: list[dict[str, object]] = field(default_factory=list)
+ resolutions: list[tuple[str, str, ModelType]] = field(default_factory=list)
- call_kwargs = mock_workflow_generator.generate_workflow_graph.call_args.kwargs
- assert call_kwargs["ideal_output"] == ""
- assert call_kwargs["mode"] == "advanced-chat"
-
- @patch("services.workflow_generator_service.WorkflowGenerator")
- @patch("services.workflow_generator_service.ModelManager")
- @patch("services.workflow_generator_service.build_tool_catalogue")
- def test_forwards_current_graph_for_refine(
- self,
- mock_build_catalogue: MagicMock,
- mock_model_manager: MagicMock,
- mock_workflow_generator: MagicMock,
- ):
- """The cmd+k `/refine` path passes the existing draft graph through to the runner."""
- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = MagicMock()
- mock_build_catalogue.return_value = []
- mock_workflow_generator.generate_workflow_graph.return_value = {
- "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
- "message": "",
- "error": "",
- }
- current_graph = {"nodes": [{"id": "node1"}], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}}
-
- WorkflowGeneratorService.generate_workflow_graph(
- tenant_id="t-1",
- mode="workflow",
- instruction="Add a translation step",
- model_config=_model_config(),
- current_graph=current_graph,
+
+def generation(monkeypatch: pytest.MonkeyPatch) -> Iterator[GenerationObservations]:
+ config = make_model_config(provider=PROVIDER, model="gpt-4o", mode="chat")
+ bundle = config.provider_model_bundle
+ bundle.configuration.tenant_id = TENANT_ID
+ bundle.configuration.custom_configuration.provider = CustomProviderConfiguration(credentials={"api_key": "token"})
+ bundle.model_type_instance = LargeLanguageModel(
+ provider_schema=bundle.configuration.provider,
+ model_runtime=create_plugin_model_runtime(tenant_id=TENANT_ID),
+ )
+ observed = GenerationObservations(bundle=bundle)
+
+ def provider_bundle(
+ _manager: ProviderManager, *, tenant_id: str, provider: str, model_type: ModelType
+ ) -> ProviderModelBundle:
+ observed.resolutions.append((tenant_id, provider, model_type))
+ return bundle
+
+ def providers(tenant_id: str) -> list[PluginToolProviderController]:
+ assert tenant_id == TENANT_ID
+ return observed.providers
+
+ def dispatch(_client: PluginModelClient, **kwargs: object) -> Generator[LLMResultChunk]:
+ observed.daemon_calls.append(kwargs)
+ data = kwargs["data"]
+ assert isinstance(data, dict)
+ messages = data["data"]["prompt_messages"]
+ system_prompt = messages[0]["content"]
+ user_prompt = messages[-1]["content"]
+ if "workflow planner" in system_prompt.lower():
+ terminal = "answer" if "# Mode\n\nadvanced-chat" in user_prompt else "end"
+ response: dict[str, object] = {
+ "title": "Generated graph",
+ "description": "ok",
+ "nodes": [
+ {"id": "start", "node_type": "start", "label": "Start", "purpose": "Input"},
+ {"id": "finish", "node_type": terminal, "label": "Finish", "purpose": "Output"},
+ ],
+ "edges": [{"source": "start", "target": "finish"}],
+ }
+ else:
+ response = {"config": {"variables": [], "outputs": [], "answer": "Done"}}
+ yield LLMResultChunk(
+ model="gpt-4o",
+ delta=LLMResultChunkDelta(index=0, message=AssistantPromptMessage(content=json.dumps(response))),
)
- call_kwargs = mock_workflow_generator.generate_workflow_graph.call_args.kwargs
- assert call_kwargs["current_graph"] is current_graph
-
- @patch("services.workflow_generator_service.WorkflowGenerator")
- @patch("services.workflow_generator_service.ModelManager")
- @patch("services.workflow_generator_service.build_tool_catalogue")
- def test_defaults_current_graph_to_none_for_create(
- self,
- mock_build_catalogue: MagicMock,
- mock_model_manager: MagicMock,
- mock_workflow_generator: MagicMock,
- ):
- """Omitting current_graph (the `/create` path) forwards None to the runner."""
- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = MagicMock()
- mock_build_catalogue.return_value = []
- mock_workflow_generator.generate_workflow_graph.return_value = {
- "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
- "message": "",
- "error": "",
+ monkeypatch.setattr(ProviderManager, "get_provider_model_bundle", provider_bundle)
+ monkeypatch.setattr(ToolManager, "list_builtin_providers", providers)
+ monkeypatch.setattr(PluginModelClient, "get_model_schema", lambda *_args, **_kwargs: config.model_schema)
+ monkeypatch.setattr(PluginModelClient, "_request_with_plugin_daemon_response_stream", dispatch)
+ monkeypatch.setattr(
+ PluginModelRuntime, "invoke_llm", _record(PluginModelRuntime.invoke_llm, observed.runtime_calls)
+ )
+ monkeypatch.setattr(
+ WorkflowGenerator,
+ "_iter_generation_events",
+ _record(WorkflowGenerator._iter_generation_events, observed.generator_calls),
+ )
+ with Redis() as client:
+ monkeypatch.setattr(client, "execute_command", lambda *_args, **_kwargs: None)
+ redis = RedisClientWrapper()
+ redis.initialize(client)
+ monkeypatch.setattr("core.plugin.impl.model_runtime.redis_client", redis)
+ yield observed
+
+
+def _planner_prompt(generation: GenerationObservations) -> str:
+ data = generation.daemon_calls[0]["data"]
+ assert isinstance(data, dict)
+ return data["data"]["prompt_messages"][-1]["content"]
+
+
+def _assert_model_resolution(generation: GenerationObservations, app_type: CreditUsageAppType) -> None:
+ assert generation.resolutions == [(TENANT_ID, PROVIDER, ModelType.LLM)]
+ assert len(generation.generator_calls) == 1
+ call = generation.generator_calls[0]
+ instance = call["model_instance"]
+ assert type(instance) is ModelInstance
+ assert instance.provider_model_bundle is generation.bundle
+ assert instance.credentials == {"api_key": "token"}
+ assert call["provider"] == PROVIDER
+ assert call["model_name"] == "gpt-4o"
+ assert call["model_mode"] == "chat"
+ assert call["model_parameters"] == {"temperature": 0.4}
+ assert len(generation.runtime_calls) == len(generation.daemon_calls) == 3
+ for runtime_call in generation.runtime_calls:
+ assert runtime_call["request_metadata"] == {
+ "app_type": app_type,
+ "created_by": CreditUsageCreatedBy.WORKFLOW_GENERATION,
}
- WorkflowGeneratorService.generate_workflow_graph(
- tenant_id="t-1",
- mode="workflow",
- instruction="Summarize a URL",
- model_config=_model_config(),
+
+def test_forwards_model_instance_and_complete_catalogue_to_generator(generation: GenerationObservations) -> None:
+ label = I18nObject(en_US="Search")
+ generation.providers.append(
+ PluginToolProviderController(
+ entity=ToolProviderEntityWithPlugin(
+ identity=ToolProviderIdentity(author="test", name="google", description=label, icon="", label=label),
+ tools=[
+ ToolEntity(
+ identity=ToolIdentity(author="test", name="search", label=label, provider="google"),
+ description=ToolDescription(human=label, llm="Search."),
+ )
+ ],
+ ),
+ plugin_id="langgenius/google",
+ plugin_unique_identifier="langgenius/google:1.0.0",
+ tenant_id=TENANT_ID,
)
+ )
+ result = WorkflowGeneratorService.generate_workflow_graph(
+ tenant_id=TENANT_ID,
+ mode="workflow",
+ instruction="Summarize a URL",
+ model_config=_model_config(),
+ ideal_output="A 3-sentence summary",
+ )
- call_kwargs = mock_workflow_generator.generate_workflow_graph.call_args.kwargs
- assert call_kwargs["current_graph"] is None
-
- @patch("services.workflow_generator_service.WorkflowGenerator")
- @patch("services.workflow_generator_service.ModelManager")
- @patch("services.workflow_generator_service.build_tool_catalogue")
- def test_auto_mode_forwards_sentinel_to_runner(
- self,
- mock_build_catalogue: MagicMock,
- mock_model_manager: MagicMock,
- mock_workflow_generator: MagicMock,
- ):
- """``mode="auto"`` passes straight through — the planner resolves it, no extra LLM call."""
- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = MagicMock()
- mock_build_catalogue.return_value = []
- mock_workflow_generator.generate_workflow_graph.return_value = {
- "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
- "message": "",
- "error": "",
+ _assert_model_resolution(generation, CreditUsageAppType.WORKFLOW)
+ call = generation.generator_calls[0]
+ assert call["instruction"] == "Summarize a URL"
+ assert call["ideal_output"] == "A 3-sentence summary"
+ assert call["tool_catalogue_text"] == ""
+ assert call["installed_tools"] == {("google", "search")}
+ assert call["tool_catalogue_entries"] == [
+ {
+ "provider_name": "google",
+ "provider_type": "builtin",
+ "plugin_id": "langgenius/google",
+ "plugin_unique_identifier": "langgenius/google:1.0.0",
+ "tool_name": "search",
+ "tool_label": "Search",
+ "description": "Search.",
+ "parameters": [],
+ "output_schema": {},
}
+ ]
+ assert "google/search" in _planner_prompt(generation)
+ assert "A 3-sentence summary" in _planner_prompt(generation)
+ assert result["error"] == ""
+ assert [node["data"]["type"] for node in result["graph"]["nodes"]] == ["start", "end"]
- WorkflowGeneratorService.generate_workflow_graph(
- tenant_id="t-1",
- mode="auto",
- instruction="Summarize a URL",
- model_config=_model_config(),
- )
- assert mock_workflow_generator.generate_workflow_graph.call_args.kwargs["mode"] == "auto"
- # the model registry is consulted exactly once — no classifier resolution
- mock_model_manager.for_tenant.return_value.get_model_instance.assert_called_once()
-
- @patch("services.workflow_generator_service.WorkflowGenerator")
- @patch("services.workflow_generator_service.ModelManager")
- @patch("services.workflow_generator_service.build_tool_catalogue")
- def test_explicit_mode_passes_through_unchanged(
- self,
- mock_build_catalogue: MagicMock,
- mock_model_manager: MagicMock,
- mock_workflow_generator: MagicMock,
- ):
- """A concrete mode reaches the runner verbatim."""
- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = MagicMock()
- mock_build_catalogue.return_value = []
- mock_workflow_generator.generate_workflow_graph.return_value = {
- "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
- "message": "",
- "error": "",
- }
+def test_catalogue_build_failure_falls_back_to_empty_text(
+ generation: GenerationObservations, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ """A discovery outage must still run the real planner and builders without tool validation."""
- WorkflowGeneratorService.generate_workflow_graph(
- tenant_id="t-1",
- mode="advanced-chat",
- instruction="A chat bot",
- model_config=_model_config(),
- )
+ def unavailable(tenant_id: str) -> list[PluginToolProviderController]:
+ assert tenant_id == TENANT_ID
+ raise RuntimeError("plugin daemon unreachable")
+
+ monkeypatch.setattr(ToolManager, "list_builtin_providers", unavailable)
+ result = WorkflowGeneratorService.generate_workflow_graph(
+ tenant_id=TENANT_ID, mode="workflow", instruction="Summarize a URL", model_config=_model_config()
+ )
+ assert result["error"] == ""
+ call = generation.generator_calls[0]
+ assert call["tool_catalogue_text"] == ""
+ assert call["tool_catalogue_entries"] == []
+ assert call["installed_tools"] is None
+ _assert_model_resolution(generation, CreditUsageAppType.WORKFLOW)
+
+
+def test_defaults_ideal_output_to_empty_string(generation: GenerationObservations) -> None:
+ result = WorkflowGeneratorService.generate_workflow_graph(
+ tenant_id=TENANT_ID, mode="advanced-chat", instruction="A chat bot", model_config=_model_config()
+ )
+ assert result["error"] == ""
+ assert generation.generator_calls[0]["ideal_output"] == ""
+ assert generation.generator_calls[0]["mode"] == "advanced-chat"
+ assert "# Ideal output" not in _planner_prompt(generation)
+ _assert_model_resolution(generation, CreditUsageAppType.CHATFLOW)
+
+
+def test_forwards_current_graph_for_refine(generation: GenerationObservations) -> None:
+ graph: dict[str, object] = {"nodes": [{"id": "node1", "data": {"type": "start", "title": "Original"}}], "edges": []}
+ result = WorkflowGeneratorService.generate_workflow_graph(
+ tenant_id=TENANT_ID,
+ mode="workflow",
+ instruction="Add a translation step",
+ model_config=_model_config(),
+ current_graph=graph,
+ )
+ assert result["error"] == ""
+ assert generation.generator_calls[0]["current_graph"] is graph
+ assert "# Existing graph to refine" in _planner_prompt(generation)
+ assert "id='node1' type='start' title='Original'" in _planner_prompt(generation)
- assert mock_workflow_generator.generate_workflow_graph.call_args.kwargs["mode"] == "advanced-chat"
-
- @patch("services.workflow_generator_service.WorkflowGenerator")
- @patch("services.workflow_generator_service.ModelManager")
- @patch("services.workflow_generator_service.build_tool_catalogue")
- def test_stream_delegates_to_runner_stream(
- self,
- mock_build_catalogue: MagicMock,
- mock_model_manager: MagicMock,
- mock_workflow_generator: MagicMock,
- ):
- """Task 2b: the streaming facade resolves context and yields the runner's events through."""
- instance = MagicMock(name="model_instance")
- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = instance
- mock_build_catalogue.return_value = []
-
- def _runner_stream(**_kwargs):
- yield ("plan", {"mode": "workflow"})
- yield ("result", {"error": "", "mode": "workflow"})
-
- mock_workflow_generator.generate_workflow_graph_stream.side_effect = _runner_stream
-
- events = list(
- WorkflowGeneratorService.generate_workflow_graph_stream(
- tenant_id="t-1",
- mode="workflow",
- instruction="Summarize a URL",
- model_config=_model_config(),
- )
- )
- assert [name for name, _ in events] == ["plan", "result"]
- call_kwargs = mock_workflow_generator.generate_workflow_graph_stream.call_args.kwargs
- assert call_kwargs["model_instance"] is instance
- assert call_kwargs["mode"] == "workflow"
- assert call_kwargs["provider"] == "openai"
+def test_defaults_current_graph_to_none_for_create(generation: GenerationObservations) -> None:
+ result = WorkflowGeneratorService.generate_workflow_graph(
+ tenant_id=TENANT_ID, mode="workflow", instruction="Summarize a URL", model_config=_model_config()
+ )
+ assert result["error"] == ""
+ assert generation.generator_calls[0]["current_graph"] is None
+ assert generation.generator_calls[0]["installed_tools"] == set()
+ assert "# Existing graph to refine" not in _planner_prompt(generation)
+
+
+def test_auto_mode_forwards_sentinel_to_runner(generation: GenerationObservations) -> None:
+ result = WorkflowGeneratorService.generate_workflow_graph(
+ tenant_id=TENANT_ID, mode="auto", instruction="Summarize a URL", model_config=_model_config()
+ )
+ assert result["error"] == ""
+ assert result["mode"] == "workflow"
+ assert generation.generator_calls[0]["mode"] == "auto"
+ _assert_model_resolution(generation, CreditUsageAppType.UNKNOWN)
+
+
+def test_explicit_mode_passes_through_unchanged(generation: GenerationObservations) -> None:
+ result = WorkflowGeneratorService.generate_workflow_graph(
+ tenant_id=TENANT_ID, mode="advanced-chat", instruction="A chat bot", model_config=_model_config()
+ )
+ assert result["error"] == ""
+ assert result["mode"] == "advanced-chat"
+ assert generation.generator_calls[0]["mode"] == "advanced-chat"
+ assert result["graph"]["nodes"][-1]["data"]["type"] == "answer"
+
+
+def test_stream_delegates_to_runner_stream(generation: GenerationObservations) -> None:
+ stream = WorkflowGeneratorService.generate_workflow_graph_stream(
+ tenant_id=TENANT_ID, mode="workflow", instruction="Summarize a URL", model_config=_model_config()
+ )
+ name, plan = next(stream)
+ assert name == "plan"
+ assert plan["mode"] == "workflow"
+ assert len(generation.daemon_calls) == 1 # Builders start only after the caller receives the plan.
+ name, result = next(stream)
+ assert name == "result"
+ assert result["error"] == ""
+ assert result["mode"] == "workflow"
+ assert list(stream) == []
+ assert generation.generator_calls[0]["mode"] == "workflow"
+ _assert_model_resolution(generation, CreditUsageAppType.WORKFLOW)