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.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
from __future__ import annotations
import json
from inspect import unwrap as _generator_api_unwrap
from unittest.mock import MagicMock
import pytest
from flask import Flask, request
from sqlalchemy.orm import Session
from controllers.console.app import generator as generator_module
from controllers.console.app.error import ProviderNotInitializeError
from controllers.console.app.generator import (
InstructionGeneratePayload,
InstructionTemplatePayload,
RuleCodeGeneratePayload,
RuleGeneratePayload,
RuleStructuredOutputPayload,
WorkflowGeneratePayload,
WorkflowInstructionSuggestionsPayload,
)
from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
from graphon.model_runtime.errors.invoke import InvokeError
from models.model import App, AppMode
from models.workflow import Workflow
from tests.helpers.unit.model_factories import make_workflow
def _persist_app(session: Session, *, tenant_id: str = "t1") -> App:
app_model = App(
id="app-1",
tenant_id=tenant_id,
name="Workflow App",
description="",
mode=AppMode.WORKFLOW,
enable_site=False,
enable_api=False,
max_active_requests=None,
)
session.add(app_model)
session.commit()
return app_model
def _generator_api_model_config_payload():
return {"provider": "openai", "name": "gpt-4o", "mode": "chat", "completion_params": {}}
def _workflow(graph_dict: dict[str, object]) -> Workflow:
return make_workflow(workflow_id="workflow-1", tenant_id="t1", graph=graph_dict)
def _install_workflow_service(monkeypatch: pytest.MonkeyPatch, workflow):
class _Service:
app_model = None
session = None
def get_draft_workflow(self, app_model, session=None):
self.app_model = app_model
self.session = session
return workflow
service = _Service()
monkeypatch.setattr(generator_module, "WorkflowService", lambda: service)
return service
def test_rule_generate_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = generator_module.RuleGenerateApi()
method = _generator_api_unwrap(api.post)
rule_config = {
"prompt": "You are a helpful assistant.",
"variables": ["topic"],
"opening_statement": "Hi",
"error": "",
}
monkeypatch.setattr(generator_module.LLMGenerator, "generate_rule_config", lambda **_kwargs: rule_config)
with app.test_request_context(
"/console/api/rule-generate",
method="POST",
json={"instruction": "do it", "model_config": _generator_api_model_config_payload()},
):
response = method(api, RuleGeneratePayload.model_validate(request.get_json()), "t1")
assert response == rule_config
def test_rule_code_generate_maps_token_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = generator_module.RuleCodeGenerateApi()
method = _generator_api_unwrap(api.post)
def _raise(*_args, **_kwargs):
raise ProviderTokenNotInitError("missing token")
monkeypatch.setattr(generator_module.LLMGenerator, "generate_code", _raise)
with app.test_request_context(
"/console/api/rule-code-generate",
method="POST",
json={"instruction": "do it", "model_config": _generator_api_model_config_payload()},
):
with pytest.raises(ProviderNotInitializeError):
method(api, RuleCodeGeneratePayload.model_validate(request.get_json()), "t1")
@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_app_not_found(app: Flask, sqlite_session: Session) -> None:
api = generator_module.InstructionGenerateApi()
method = _generator_api_unwrap(api.post)
_persist_app(sqlite_session, tenant_id="other-tenant")
with app.test_request_context(
"/console/api/instruction-generate",
method="POST",
json={
"flow_id": "app-1",
"node_id": "node-1",
"instruction": "do",
"model_config": _generator_api_model_config_payload(),
},
):
response, status = method(
api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1"
)
assert status == 400
assert response["error"] == "app app-1 not found"
assert sqlite_session.get(App, "app-1") is not None
@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_workflow_not_found(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
api = generator_module.InstructionGenerateApi()
method = _generator_api_unwrap(api.post)
_persist_app(sqlite_session)
_install_workflow_service(monkeypatch, workflow=None)
with app.test_request_context(
"/console/api/instruction-generate",
method="POST",
json={
"flow_id": "app-1",
"node_id": "node-1",
"instruction": "do",
"model_config": _generator_api_model_config_payload(),
},
):
response, status = method(
api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1"
)
assert status == 400
assert response["error"] == "workflow app-1 not found"
@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_node_missing(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
api = generator_module.InstructionGenerateApi()
method = _generator_api_unwrap(api.post)
_persist_app(sqlite_session)
workflow = _workflow({"nodes": []})
_install_workflow_service(monkeypatch, workflow=workflow)
with app.test_request_context(
"/console/api/instruction-generate",
method="POST",
json={
"flow_id": "app-1",
"node_id": "node-1",
"instruction": "do",
"model_config": _generator_api_model_config_payload(),
},
):
response, status = method(
api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1"
)
assert status == 400
assert response["error"] == "node node-1 not found"
@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_code_node(app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:
api = generator_module.InstructionGenerateApi()
method = _generator_api_unwrap(api.post)
app_model = _persist_app(sqlite_session)
workflow = _workflow(
{
"nodes": [
{"id": "node-1", "data": {"type": "code"}},
]
}
)
workflow_service = _install_workflow_service(monkeypatch, workflow=workflow)
monkeypatch.setattr(generator_module.LLMGenerator, "generate_code", lambda **_kwargs: {"code": "x"})
with app.test_request_context(
"/console/api/instruction-generate",
method="POST",
json={
"flow_id": "app-1",
"node_id": "node-1",
"instruction": "do",
"model_config": _generator_api_model_config_payload(),
},
):
response = method(api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1")
assert response == {"code": "x"}
assert workflow_service.app_model is app_model
assert workflow_service.session is sqlite_session
@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_legacy_modify(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
api = generator_module.InstructionGenerateApi()
method = _generator_api_unwrap(api.post)
captured: dict = {}
def _capture(**kwargs):
captured.update(kwargs)
return {"instruction": "ok"}
monkeypatch.setattr(generator_module.LLMGenerator, "instruction_modify_legacy", _capture)
with app.test_request_context(
"/console/api/instruction-generate",
method="POST",
json={
"flow_id": "app-1",
"node_id": "",
"current": "old",
"instruction": "do",
"model_config": _generator_api_model_config_payload(),
},
):
response = method(api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1")
assert response == {"instruction": "ok"}
assert captured["session"] is sqlite_session
@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_incompatible_params(app: Flask, sqlite_session: Session) -> None:
api = generator_module.InstructionGenerateApi()
method = _generator_api_unwrap(api.post)
with app.test_request_context(
"/console/api/instruction-generate",
method="POST",
json={
"flow_id": "app-1",
"node_id": "",
"current": "",
"instruction": "do",
"model_config": _generator_api_model_config_payload(),
},
):
response, status = method(
api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1"
)
assert status == 400
assert response["error"] == "incompatible parameters"
def test_instruction_template_prompt(app: Flask) -> None:
api = generator_module.InstructionGenerationTemplateApi()
method = _generator_api_unwrap(api.post)
with app.test_request_context(
"/console/api/instruction-generate/template",
method="POST",
json={"type": "prompt"},
):
response = method(api, InstructionTemplatePayload.model_validate(request.get_json()))
assert "data" in response
def test_instruction_template_invalid_type(app: Flask) -> None:
api = generator_module.InstructionGenerationTemplateApi()
method = _generator_api_unwrap(api.post)
with app.test_request_context(
"/console/api/instruction-generate/template",
method="POST",
json={"type": "unknown"},
):
with pytest.raises(ValueError, match="Invalid type: unknown"):
method(api, InstructionTemplatePayload.model_validate(request.get_json()))
# ─ /workflow-generate ─────────────────────────────────────────────────────────
def _workflow_generate_payload() -> dict:
return {
"mode": "workflow",
"instruction": "Summarize a URL",
"ideal_output": "A 3-sentence summary.",
"model_config": _generator_api_model_config_payload(),
}
def _workflow_graph(*, node_id: str | None = None) -> dict:
nodes = []
if node_id:
nodes.append(
{
"id": node_id,
"type": "custom",
"position": {"x": 0, "y": 0},
"data": {"type": "start", "title": "Start"},
}
)
return {"nodes": nodes, "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}}
def _stub_workflow_service(monkeypatch: pytest.MonkeyPatch, returns=None, raises: Exception | None = None):
def _call(**_kwargs):
if raises is not None:
raise raises
return returns or {
"graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
"message": "",
"error": "",
}
monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _call)
def test_workflow_generate_returns_service_result(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
expected = {
"graph": _workflow_graph(node_id="node-1"),
"message": "Summarize",
"app_name": "",
"icon": "",
"error": "",
"errors": [],
"mode": None,
}
expected["graph"]["nodes"][0]["parentId"] = "container-1"
_stub_workflow_service(monkeypatch, returns=expected)
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=_workflow_generate_payload(),
):
response = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
assert response == expected
def test_workflow_generate_response_schema_is_concrete() -> None:
schema = generator_module.WorkflowGenerateResponse.model_json_schema()
assert schema["properties"]["graph"]["$ref"].endswith("/$defs/WorkflowGraph")
error_items = schema["properties"]["errors"]["items"]
assert error_items["$ref"].endswith("/$defs/WorkflowGenerateErrorResponse")
assert set(schema["$defs"]["WorkflowGenerateErrorCode"]["enum"]) == {
code.value for code in generator_module.WorkflowGenerateErrorCode
}
def test_workflow_generate_maps_provider_token_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""ProviderTokenNotInitError → ProviderNotInitializeError so the frontend
can render the same "provider missing" UX as /rule-generate."""
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
_stub_workflow_service(monkeypatch, raises=ProviderTokenNotInitError("missing token"))
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=_workflow_generate_payload(),
):
with pytest.raises(ProviderNotInitializeError):
method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
def test_workflow_generate_maps_quota_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
from controllers.console.app.error import ProviderQuotaExceededError
from core.errors.error import QuotaExceededError
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
_stub_workflow_service(monkeypatch, raises=QuotaExceededError())
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=_workflow_generate_payload(),
):
with pytest.raises(ProviderQuotaExceededError):
method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
def test_workflow_generate_maps_model_not_support_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
from controllers.console.app.error import ProviderModelCurrentlyNotSupportError
from core.errors.error import ModelCurrentlyNotSupportError
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
_stub_workflow_service(monkeypatch, raises=ModelCurrentlyNotSupportError("not supported"))
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=_workflow_generate_payload(),
):
with pytest.raises(ProviderModelCurrentlyNotSupportError):
method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
def test_workflow_generate_maps_invoke_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
from controllers.console.app.error import CompletionRequestError
from graphon.model_runtime.errors.invoke import InvokeError
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
_stub_workflow_service(monkeypatch, raises=InvokeError("LLM unreachable"))
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=_workflow_generate_payload(),
):
with pytest.raises(CompletionRequestError):
method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
def test_workflow_generate_accepts_advanced_chat_mode(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""The payload Literal must accept advanced-chat as well as workflow."""
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
captured: dict = {}
def _capture(**kwargs):
captured.update(kwargs)
return {
"graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
"message": "",
"error": "",
}
monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _capture)
payload = _workflow_generate_payload()
payload["mode"] = "advanced-chat"
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=payload,
):
method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
assert captured["mode"] == "advanced-chat"
assert captured["instruction"] == "Summarize a URL"
assert captured["ideal_output"] == "A 3-sentence summary."
def test_workflow_generate_forwards_current_graph_for_refine(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""cmd+k `/refine`: the optional current_graph field reaches the service."""
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
captured: dict = {}
def _capture(**kwargs):
captured.update(kwargs)
return {
"graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
"message": "",
"error": "",
}
monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _capture)
graph = _workflow_graph(node_id="node1")
payload = _workflow_generate_payload()
payload["current_graph"] = graph
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=payload,
):
method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
assert captured["current_graph"] == graph
def test_workflow_generate_current_graph_defaults_to_none(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Omitting current_graph (the `/create` path) forwards None to the service."""
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
captured: dict = {}
def _capture(**kwargs):
captured.update(kwargs)
return {
"graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
"message": "",
"error": "",
}
monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _capture)
with app.test_request_context(
"/console/api/workflow-generate",
method="POST",
json=_workflow_generate_payload(),
):
method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
assert captured["current_graph"] is None
def test_workflow_generate_accepts_auto_mode(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Task 3: the payload Literal must accept ``auto``; the controller forwards
it unchanged (the service resolves it) and returns the resolved ``mode``."""
api = generator_module.WorkflowGenerateApi()
method = _generator_api_unwrap(api.post)
captured: dict = {}
def _capture(**kwargs):
captured.update(kwargs)
return {
"graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
"message": "",
"error": "",
"mode": "advanced-chat",
}
monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _capture)
payload = _workflow_generate_payload()
payload["mode"] = "auto"
with app.test_request_context("/console/api/workflow-generate", method="POST", json=payload):
response = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
assert captured["mode"] == "auto"
assert response["mode"] == "advanced-chat"
# ─ /workflow-generate/suggestions ─────────────────────────────────────────────
def test_generate_instruction_suggestions_parses_and_cleans(monkeypatch: pytest.MonkeyPatch) -> None:
"""Task 1c (i): a mocked default model returning a JSON array is parsed + cleaned."""
from core.llm_generator import llm_generator as llm_gen_module
instance = MagicMock()
instance.invoke_llm.return_value.message.get_text_content.return_value = '["Summarize a URL", "Translate text"]'
mock_manager = MagicMock()
mock_manager.for_tenant.return_value.get_default_model_instance.return_value = instance
monkeypatch.setattr(llm_gen_module, "ModelManager", mock_manager)
monkeypatch.setattr(llm_gen_module.LLMGenerator, "_build_suggestion_context", staticmethod(lambda _tenant: ""))
result = llm_gen_module.LLMGenerator.generate_workflow_instruction_suggestions(
tenant_id="t1", mode="workflow", count=4
)
assert result == ["Summarize a URL", "Translate text"]
def test_generate_instruction_suggestions_dedupes_and_caps(monkeypatch: pytest.MonkeyPatch) -> None:
"""Whitespace / surrounding quotes are stripped, case-insensitive dupes dropped, capped to count."""
from core.llm_generator import llm_generator as llm_gen_module
instance = MagicMock()
instance.invoke_llm.return_value.message.get_text_content.return_value = (
'[" Summarize a URL ", "summarize a URL", "\'Translate text\'", "Draft an email", "Extra idea"]'
)
mock_manager = MagicMock()
mock_manager.for_tenant.return_value.get_default_model_instance.return_value = instance
monkeypatch.setattr(llm_gen_module, "ModelManager", mock_manager)
monkeypatch.setattr(llm_gen_module.LLMGenerator, "_build_suggestion_context", staticmethod(lambda _tenant: ""))
result = llm_gen_module.LLMGenerator.generate_workflow_instruction_suggestions(
tenant_id="t1", mode="advanced-chat", count=3
)
assert result == ["Summarize a URL", "Translate text", "Draft an email"]
def test_generate_instruction_suggestions_no_default_model_returns_empty(monkeypatch: pytest.MonkeyPatch) -> None:
"""Task 1c (ii): a missing default model degrades to an empty list, never raising."""
from core.llm_generator import llm_generator as llm_gen_module
mock_manager = MagicMock()
mock_manager.for_tenant.return_value.get_default_model_instance.side_effect = ProviderTokenNotInitError(
"no default model"
)
monkeypatch.setattr(llm_gen_module, "ModelManager", mock_manager)
result = llm_gen_module.LLMGenerator.generate_workflow_instruction_suggestions(tenant_id="t1", mode="workflow")
assert result == []
def test_workflow_instruction_suggestions_route_returns_list(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Task 1c (iii): the route wraps the generator output in {"suggestions": [...]}."""
api = generator_module.WorkflowInstructionSuggestionsApi()
method = _generator_api_unwrap(api.post)
captured: dict = {}
def _suggest(**kwargs):
captured.update(kwargs)
return ["Summarize a URL", "Translate text"]
monkeypatch.setattr(generator_module.LLMGenerator, "generate_workflow_instruction_suggestions", _suggest)
with app.test_request_context(
"/console/api/workflow-generate/suggestions",
method="POST",
json={"mode": "workflow", "language": "French", "count": 3},
):
response = method(api, WorkflowInstructionSuggestionsPayload.model_validate(request.get_json()), "t1")
assert response == {"suggestions": ["Summarize a URL", "Translate text"]}
assert captured["mode"] == "workflow"
assert captured["language"] == "French"
assert captured["count"] == 3
def test_workflow_instruction_suggestions_route_empty_is_valid_200(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Task 1c (iii): an empty list is a valid soft-fail response."""
api = generator_module.WorkflowInstructionSuggestionsApi()
method = _generator_api_unwrap(api.post)
monkeypatch.setattr(
generator_module.LLMGenerator,
"generate_workflow_instruction_suggestions",
lambda **_kwargs: [],
)
with app.test_request_context(
"/console/api/workflow-generate/suggestions",
method="POST",
json={"mode": "advanced-chat"},
):
response = method(api, WorkflowInstructionSuggestionsPayload.model_validate(request.get_json()), "t1")
assert response == {"suggestions": []}
# ─ /workflow-generate/stream ──────────────────────────────────────────────────
def _read_sse_frames(response) -> list[dict]:
"""Decode an SSE Response body into its parsed ``data:`` JSON frames."""
body = response.get_data(as_text=True)
frames = []
for chunk in body.strip().split("\n\n"):
chunk = chunk.strip()
if chunk.startswith("data: "):
frames.append(json.loads(chunk[len("data: ") :]))
return frames
def test_workflow_generate_stream_emits_plan_then_result(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Task 2c: the stream endpoint writes one SSE frame per service event."""
api = generator_module.WorkflowGenerateStreamApi()
method = _generator_api_unwrap(api.post)
def _stream(**_kwargs):
yield ("plan", {"title": "Summarizer", "mode": "workflow", "nodes": []})
yield ("result", {"graph": _workflow_graph(), "error": "", "mode": "workflow"})
monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph_stream", _stream)
with app.test_request_context(
"/console/api/workflow-generate/stream",
method="POST",
json=_workflow_generate_payload(),
):
response = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
assert response.mimetype == "text/event-stream"
frames = _read_sse_frames(response)
assert [f["event"] for f in frames] == ["plan", "result"]
assert frames[0]["title"] == "Summarizer"
assert frames[1]["mode"] == "workflow"
def test_workflow_generate_stream_provider_error_emits_result_event(
app: Flask, monkeypatch: pytest.MonkeyPatch
) -> None:
"""Task 2c: a provider-init error becomes a single MODEL_ERROR result frame, not a non-SSE error."""
api = generator_module.WorkflowGenerateStreamApi()
method = _generator_api_unwrap(api.post)
def _stream(**_kwargs):
raise ProviderTokenNotInitError("missing token")
yield # pragma: no cover - marks this a generator
monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph_stream", _stream)
with app.test_request_context(
"/console/api/workflow-generate/stream",
method="POST",
json=_workflow_generate_payload(),
):
response = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
frames = _read_sse_frames(response)
assert len(frames) == 1
assert frames[0]["event"] == "result"
assert frames[0]["errors"][0]["code"] == "MODEL_ERROR"
assert frames[0]["graph"]["nodes"] == []
def test_workflow_generate_stream_rejects_empty_instruction(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Task 2c: empty instructions get a normal 400 JSON BEFORE the stream opens."""
api = generator_module.WorkflowGenerateStreamApi()
method = _generator_api_unwrap(api.post)
payload = _workflow_generate_payload()
payload["instruction"] = " "
with app.test_request_context("/console/api/workflow-generate/stream", method="POST", json=payload):
response, status = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
assert status == 400
assert response["errors"][0]["code"] == "EMPTY_INSTRUCTION"
def _generator_api_missing_unwrap(func):
"""Unwrap a decorated function to test it directly."""
while hasattr(func, "__wrapped__"):
func = func.__wrapped__
return func
def _generator_api_missing_model_config_payload():
return {
"provider": "test_provider",
"name": "test_model",
"mode": "chat",
"completion_params": {},
}
def test_rule_generate_exceptions(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = generator_module.RuleGenerateApi()
method = _generator_api_missing_unwrap(api.post)
exceptions_to_test = [
(ProviderTokenNotInitError("token error"), generator_module.ProviderNotInitializeError),
(QuotaExceededError("quota error"), generator_module.ProviderQuotaExceededError),
(ModelCurrentlyNotSupportError("model error"), generator_module.ProviderModelCurrentlyNotSupportError),
(InvokeError("invoke error"), generator_module.CompletionRequestError),
]
for err_to_raise, expected_exception in exceptions_to_test:
def _raise(*_args, _err=err_to_raise, **_kwargs):
raise _err
monkeypatch.setattr(generator_module.LLMGenerator, "generate_rule_config", _raise)
with app.test_request_context(
"/console/api/rule-generate",
method="POST",
json={"instruction": "do it", "model_config": _generator_api_missing_model_config_payload()},
):
with pytest.raises(expected_exception):
method(api, RuleGeneratePayload.model_validate(request.get_json()), "t1")
def test_rule_code_generate_exceptions(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = generator_module.RuleCodeGenerateApi()
method = _generator_api_missing_unwrap(api.post)
exceptions_to_test = [
(QuotaExceededError("quota error"), generator_module.ProviderQuotaExceededError),
(ModelCurrentlyNotSupportError("model error"), generator_module.ProviderModelCurrentlyNotSupportError),
(InvokeError("invoke error"), generator_module.CompletionRequestError),
]
for err_to_raise, expected_exception in exceptions_to_test:
def _raise(*_args, _err=err_to_raise, **_kwargs):
raise _err
monkeypatch.setattr(generator_module.LLMGenerator, "generate_code", _raise)
with app.test_request_context(
"/console/api/rule-code-generate",
method="POST",
json={"instruction": "do it", "model_config": _generator_api_missing_model_config_payload()},
):
with pytest.raises(expected_exception):
method(api, RuleCodeGeneratePayload.model_validate(request.get_json()), "t1")
def test_structured_output_generate_exceptions(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = generator_module.RuleStructuredOutputGenerateApi()
method = _generator_api_missing_unwrap(api.post)
exceptions_to_test = [
(ProviderTokenNotInitError("token error"), generator_module.ProviderNotInitializeError),
(QuotaExceededError("quota error"), generator_module.ProviderQuotaExceededError),
(ModelCurrentlyNotSupportError("model error"), generator_module.ProviderModelCurrentlyNotSupportError),
(InvokeError("invoke error"), generator_module.CompletionRequestError),
]
for err_to_raise, expected_exception in exceptions_to_test:
def _raise(*_args, _err=err_to_raise, **_kwargs):
raise _err
monkeypatch.setattr(generator_module.LLMGenerator, "generate_structured_output", _raise)
with app.test_request_context(
"/console/api/structured-output-generate",
method="POST",
json={"instruction": "do it", "model_config": _generator_api_missing_model_config_payload()},
):
with pytest.raises(expected_exception):
method(api, RuleStructuredOutputPayload.model_validate(request.get_json()), "t1")
@pytest.mark.parametrize("sqlite_session", [()], indirect=True)
def test_instruction_generate_exceptions(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
) -> None:
api = generator_module.InstructionGenerateApi()
method = _generator_api_missing_unwrap(api.post)
exceptions_to_test = [
(ProviderTokenNotInitError("token error"), generator_module.ProviderNotInitializeError),
(QuotaExceededError("quota error"), generator_module.ProviderQuotaExceededError),
(ModelCurrentlyNotSupportError("model error"), generator_module.ProviderModelCurrentlyNotSupportError),
(InvokeError("invoke error"), generator_module.CompletionRequestError),
]
for err_to_raise, expected_exception in exceptions_to_test:
def _raise(*_args, _err=err_to_raise, **_kwargs):
raise _err
monkeypatch.setattr(generator_module.LLMGenerator, "instruction_modify_legacy", _raise)
with app.test_request_context(
"/console/api/instruction-generate",
method="POST",
json={
"flow_id": "app-1",
"node_id": "",
"current": "old",
"instruction": "do it",
"model_config": _generator_api_missing_model_config_payload(),
},
):
with pytest.raises(expected_exception):
method(api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1")