chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动

演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
wuzilongandCursor committed 2026-11-18 13:59:25 +08:00
1 parent 60158935f4
commit 6519682885
15831 files changed
+3063428

No files matched your search

@@ -0,0 +1 @@
.env.test
@@ -0,0 +1,286 @@
extend = "../../.ruff.toml"
src = ["../.."]
[lint]
extend-select = ["ANN401", "ARG"]
# Existing strict-mode debt. Remove a file entry when bringing it under strict checking.
[lint.per-file-ignores]
"clients/agent_backend/test_request_builder.py" = ["TID251"]
"commands/test_retention.py" = ["ARG005"]
"commands/test_data_migration.py" = ["ARG001", "ARG002", "ARG005"]
"repositories/test_app_definition_query_repository.py" = ["ARG005", "TID251"]
"controllers/console/agent/test_roster.py" = ["ARG001", "ARG002", "ARG003", "ARG005", "TID251"]
"controllers/console/app/test_agent_config_inspector.py" = ["ARG005"]
"controllers/console/app/test_agent_manage_guard.py" = ["ARG001"]
"controllers/console/app/test_annotation.py" = ["ARG002"]
"controllers/console/app/test_app.py" = ["ARG001", "ARG002", "ARG004", "ARG005"]
"controllers/console/app/test_app_import.py" = ["ARG001", "ARG002", "ARG005"]
"controllers/console/app/test_conversation.py" = ["ARG001"]
"controllers/console/app/test_generator.py" = ["ARG001"]
"controllers/console/app/test_mcp_server.py" = ["ARG002"]
"controllers/console/app/test_message.py" = ["ARG001", "ARG004"]
"controllers/console/app/test_statistic.py" = ["ANN401", "ARG001", "TID251"]
"controllers/console/app/test_workflow.py" = ["ARG001", "ARG004", "ARG005"]
"controllers/console/app/test_workflow_node_output_inspector.py" = ["ANN401", "ARG001", "TID251"]
"controllers/console/app/test_workflow_run.py" = ["ANN401", "TID251"]
"fields/test_workflow_draft_variable_fields.py" = ["TID251"]
"controllers/console/auth/test_activate.py" = ["ARG002"]
"controllers/console/auth/test_login.py" = ["ARG002"]
"controllers/console/auth/test_oauth.py" = ["ARG002"]
"controllers/console/auth/test_oauth_timezone.py" = ["ARG001"]
"controllers/console/billing/test_billing.py" = ["ARG002"]
"controllers/console/datasets/test_datasets.py" = ["ARG005"]
"controllers/console/datasets/test_datasets_document.py" = ["ARG002", "ARG005"]
"controllers/console/datasets/test_datasets_segments.py" = ["TID251"]
"controllers/console/datasets/test_external.py" = ["TID251"]
"controllers/console/explore/test_trial.py" = ["ANN401", "ARG001", "ARG005", "TID251"]
"controllers/console/explore/test_wraps.py" = ["ARG001"]
"controllers/console/snippets/test_snippet_workflow.py" = ["ARG001"]
"controllers/console/tag/test_tags.py" = ["ARG002"]
"controllers/console/test_files.py" = ["ARG001", "ARG002"]
"controllers/console/test_human_input_form.py" = ["ARG001", "ARG005"]
"controllers/console/test_wraps.py" = ["ARG001", "ARG002"]
"controllers/console/workspace/test_plugin.py" = ["ARG002", "TID251"]
"controllers/console/workspace/test_snippets.py" = ["ARG002"]
"controllers/console/workspace/test_tool_providers.py" = ["ARG001", "ARG004", "ARG005"]
"controllers/inner_api/plugin/test_plugin.py" = ["ARG002"]
"controllers/inner_api/plugin/test_wraps.py" = ["ARG001", "ARG002", "ARG003", "TID251"]
"controllers/inner_api/test_runtime_credentials.py" = ["ARG001"]
"controllers/mcp/test_mcp.py" = ["ARG002"]
"controllers/openapi/test_account.py" = ["ARG005"]
"controllers/openapi/test_app_run.py" = ["ARG001"]
"controllers/openapi/test__contract.py" = ["ARG001", "TID251"]
"controllers/openapi/test__errors.py" = ["ARG002"]
"controllers/openapi/test_human_input_form.py" = ["ARG002"]
"controllers/openapi/test_workflow_events.py" = ["ARG002", "ARG005"]
"controllers/openapi/test_workspaces.py" = ["ARG001"]
"controllers/service_api/app/test_app.py" = ["ARG002"]
"controllers/service_api/app/test_completion.py" = ["ARG001", "ARG002", "ARG004"]
"controllers/service_api/app/test_file.py" = ["ARG002"]
"controllers/service_api/app/test_workflow_events.py" = ["ARG002", "ARG005"]
"controllers/service_api/dataset/rag_pipeline/test_rag_pipeline_workflow.py" = ["ARG002"]
"controllers/service_api/dataset/test_segment.py" = ["ARG002"]
"controllers/service_api/dataset/test_document.py" = ["ARG001", "ARG002"]
"controllers/service_api/test_wraps.py" = ["ARG001", "ARG002"]
"controllers/trigger/test_trigger.py" = ["ARG002"]
"controllers/trigger/test_webhook.py" = ["ARG002"]
"controllers/web/test_app.py" = ["ARG002", "ARG005"]
"controllers/web/test_audio.py" = ["ARG002"]
"controllers/web/test_completion.py" = ["ARG002"]
"controllers/web/test_human_input_form.py" = ["ARG001", "ARG002", "ARG005"]
"controllers/web/test_message.py" = ["ARG002"]
"controllers/web/test_login.py" = ["ARG002"]
"controllers/web/test_workflow.py" = ["ARG002"]
"core/agent/test_base_agent_runner.py" = ["ARG002"]
"core/agent/test_cot_agent_runner.py" = ["ARG001"]
"core/agent/test_cot_chat_agent_runner.py" = ["ARG002"]
"core/agent/test_fc_agent_runner.py" = ["TID251"]
"core/app/app_config/easy_ui_based_app/model_config/test_converter.py" = ["ARG002"]
"core/app/app_config/easy_ui_based_app/variables/test_manager.py" = ["ARG002"]
"core/app/apps/advanced_chat/test_app_generator.py" = ["ANN401", "ARG001", "ARG002", "ARG005", "TID251"]
"core/app/apps/advanced_chat/test_app_runner.py" = ["ARG001", "ARG005"]
"core/app/apps/advanced_chat/test_generate_task_pipeline.py" = ["ARG001", "ARG002", "ARG005"]
"core/app/apps/agent_app/test_app_generator.py" = ["ANN401", "ARG001", "ARG002", "ARG005", "TID251"]
"core/app/apps/agent_app/test_app_runner.py" = ["ANN401", "ARG002", "ARG005", "TID251"]
"core/app/apps/agent_app/test_runtime_request_builder.py" = ["ARG002", "TID251"]
"core/app/apps/agent_chat/test_app_config_manager.py" = ["ARG005"]
"core/app/apps/agent_chat/test_app_generator.py" = ["ARG001"]
"core/app/apps/chat/test_app_config_manager.py" = ["ARG001"]
"core/app/apps/chat/test_app_generator.py" = ["ARG001", "ARG002", "ARG005"]
"core/app/apps/common/test_workflow_response_converter.py" = ["ARG005", "TID251"]
"core/app/apps/completion/test_app_runner.py" = ["ARG001", "ARG002", "ARG005"]
"core/app/apps/pipeline/test_pipeline_generator.py" = ["ARG001", "ARG002", "ARG005"]
"core/app/apps/pipeline/test_pipeline_runner.py" = ["ARG001", "ARG002"]
"core/app/apps/test_base_app_generator.py" = ["ARG005"]
"core/app/apps/test_base_app_runner.py" = ["ARG001", "ARG002", "ARG005"]
"core/app/apps/test_streaming_utils.py" = ["ARG001"]
"core/app/apps/workflow/test_app_generator.py" = ["ARG005"]
"core/app/apps/test_workflow_app_runner.py" = ["ANN401", "ARG001", "ARG002", "ARG004", "ARG005", "TID251"]
"core/app/apps/workflow/test_generate_task_pipeline.py" = ["ARG002", "ARG005"]
"core/app/features/rate_limiting/test_rate_limit.py" = ["ARG001"]
"core/app/task_pipeline/test_easy_ui_based_generate_task_pipeline.py" = ["ARG001", "ARG002", "ARG005"]
"core/app/task_pipeline/test_message_cycle_manager.py" = ["ARG002"]
"core/app/app_config/easy_ui_based_app/model_config/test_manager.py" = ["ARG005"]
"services/test_workflow_persistence.py" = ["ANN401", "ARG005", "TID251"]
"core/app/workflow/test_file_runtime.py" = ["ARG001", "ARG005"]
"core/app/workflow/layers/test_observability.py" = ["ARG002", "ARG005"]
"core/base/tts/test_app_generator_tts_publisher.py" = ["ARG002"]
"core/callback_handler/test_agent_tool_callback_handler.py" = ["ARG002"]
"core/callback_handler/test_workflow_tool_callback_handler.py" = ["ARG002"]
"core/entities/test_mcp_provider.py" = ["ARG001"]
"core/entities/test_provider_configuration.py" = ["ANN401", "ARG001", "ARG005", "TID251"]
"core/external_data_tool/api/test_api.py" = ["ARG001"]
"core/external_data_tool/test_base.py" = ["TID251"]
"core/external_data_tool/test_external_data_fetch.py" = ["ARG001"]
"core/helper/code_executor/test_code_executor.py" = ["TID251"]
"core/llm_generator/test_llm_generator.py" = ["ARG002"]
"core/mcp/auth/test_auth_flow.py" = ["ARG002"]
"core/mcp/session/test_client_session.py" = ["ARG001", "ARG005", "TID251"]
"core/mcp/client/test_sse_client.py" = ["ARG001", "TID251"]
"core/mcp/client/test_streamable_client.py" = ["ARG001", "ARG005", "S110", "TID251"]
"core/mcp/session/test_base_session.py" = ["S110"]
"core/mcp/test_mcp_client.py" = ["ARG002"]
"core/memory/test_token_buffer_memory.py" = ["ARG002"]
"core/plugin/impl/test_agent.py" = ["ARG001"]
"core/plugin/impl/test_datasource.py" = ["ARG001"]
"core/plugin/impl/test_oauth.py" = ["ARG001"]
"core/plugin/impl/test_tool.py" = ["ARG001"]
"core/plugin/impl/test_trigger.py" = ["ARG001"]
"core/plugin/impl/test_endpoint.py" = ["ARG002"]
"core/plugin/impl/test_model_runtime.py" = ["ARG002"]
"core/plugin/impl/test_plugin.py" = ["ARG001", "ARG002", "TID251"]
"core/prompt/test_advanced_prompt_transform.py" = ["ARG005"]
"core/rag/datasource/keyword/jieba/test_jieba.py" = ["ARG001", "TID251"]
"core/rag/datasource/keyword/jieba/test_jieba_keyword_table_handler.py" = ["ARG004"]
"core/rag/datasource/test_retrieval_service.py" = ["ARG001", "ARG002", "ARG005", "TID251"]
"core/rag/datasource/vdb/test_vector_factory.py" = ["ARG002"]
"core/rag/embedding/test_cached_embedding.py" = ["ARG001"]
"core/rag/extractor/test_csv_extractor.py" = ["ARG001", "ARG005"]
"core/rag/extractor/test_excel_extractor.py" = ["ARG002", "ARG005"]
"core/rag/extractor/test_extract_processor.py" = ["ARG001", "ARG005"]
"core/rag/extractor/test_helpers.py" = ["ARG002"]
"core/rag/extractor/test_markdown_extractor.py" = ["ARG001"]
"core/rag/extractor/test_word_extractor.py" = ["ARG001", "ARG002", "ARG005"]
"core/rag/extractor/unstructured/test_unstructured_doc_extractor.py" = ["ARG001", "ARG005"]
"core/rag/extractor/watercrawl/test_client.py" = ["ARG001", "ARG005", "TID251"]
"core/rag/index_processor/processor/test_paragraph_index_processor.py" = ["ARG002", "TID251"]
"core/rag/index_processor/processor/test_qa_index_processor.py" = ["ARG001", "TID251"]
"core/rag/index_processor/test_index_processor.py" = ["ARG005"]
"core/rag/retrieval/test_dataset_retrieval.py" = ["ARG001", "ARG002", "ARG005", "TID251"]
"core/rag/splitter/test_text_splitter.py" = ["ARG002", "ARG005"]
"core/repositories/test_celery_workflow_execution_repository.py" = ["ARG002"]
"core/repositories/test_celery_workflow_node_execution_repository.py" = ["ARG002"]
"core/repositories/test_human_input_repository.py" = ["ANN401", "ARG001", "ARG004", "ARG005", "TID251"]
"core/repositories/test_sqlalchemy_workflow_node_execution_repository.py" = ["ANN401", "ARG002", "ARG005", "TID251"]
"core/schemas/test_resolver.py" = ["ARG005", "T201"]
"core/telemetry/test_gateway.py" = ["ARG002"]
"core/test_model_manager.py" = ["ARG001"]
"core/trigger/debug/test_event_selectors.py" = ["ARG002"]
"core/tools/__base/test_tool.py" = ["ANN401", "ARG002", "TID251"]
"core/tools/builtin_tool/test_tool.py" = ["ARG001", "ARG002", "TID251"]
"core/tools/builtin_tool/test_provider.py" = ["ARG001", "ARG005", "TID251"]
"core/tools/builtin_tool/providers/time/tools/test_localtime_to_timestamp.py" = ["ARG005"]
"core/tools/custom_tool/test_tool.py" = ["ARG001", "ARG005", "TID251"]
"core/tools/utils/test_dataset_retriever_tool.py" = ["ARG005"]
"core/tools/mcp_tool/test_tool.py" = ["S110", "TID251"]
"core/tools/test_tool_engine.py" = ["ANN401", "ARG002", "ARG005", "TID251"]
"core/tools/test_tool_file_manager.py" = ["ARG001"]
"core/tools/test_tool_label_manager.py" = ["TID251"]
"core/tools/test_tool_manager.py" = ["ANN401", "ARG001", "ARG005", "TID251"]
"core/tools/__base/test_tool_provider.py" = ["TID251"]
"core/tools/utils/test_configuration.py" = ["ARG001", "ARG002", "TID251"]
"core/tools/utils/test_message_transformer.py" = ["TID251"]
"core/tools/utils/dataset_retriever/test_dataset_multi_retriever_tool.py" = ["ARG002"]
"core/tools/utils/test_model_invocation_utils.py" = ["ARG005", "TID251"]
"core/tools/utils/test_parser.py" = ["TID251"]
"core/tools/utils/test_web_reader_tool.py" = ["ARG001", "ARG002", "ARG005"]
"core/tools/workflow_as_tool/test_provider.py" = ["TID251"]
"core/tools/workflow_as_tool/test_tool.py" = ["ANN401", "ARG001", "ARG005", "TID251"]
"context/test_execution_context.py" = ["ANN401", "ARG002", "S110", "TID251"]
"context/test_flask_app_context.py" = ["ARG002"]
"core/workflow/generator/test_runner.py" = ["ARG001", "ARG002", "ARG003", "TID251"]
"core/workflow/generator/test_tool_catalogue.py" = ["ARG002"]
"../helpers/workflow/mock_config.py" = ["TID251"]
"../helpers/workflow/mock_factory.py" = ["TID251"]
"../helpers/workflow/mock_nodes.py" = ["ANN401", "S110", "TID251"]
"../e2e_tests/contracts/core/workflow/graph_engine/test_parallel_human_input_join_resume.py" = ["ARG002", "TID251"]
"../helpers/workflow/table_runner.py" = ["ARG001", "TID251"]
"core/workflow/nodes/agent_v2/test_agent_node.py" = ["ARG001", "ARG002", "ARG005"]
"core/workflow/nodes/agent_v2/test_dify_tools_builder.py" = ["ANN401", "ARG001", "ARG002", "ARG005", "TID251"]
"core/workflow/nodes/agent_v2/test_output_adapter.py" = ["ARG005"]
"core/workflow/nodes/agent_v2/test_runtime_request_builder.py" = ["ARG002"]
"core/workflow/nodes/agent_v2/test_validators.py" = ["ARG001"]
"../e2e_tests/contracts/core/workflow/nodes/http_request/test_http_request_node.py" = ["ANN401", "ARG002", "TID251"]
"core/workflow/nodes/human_input/test_entities.py" = ["TID251"]
"core/workflow/nodes/knowledge_index/test_knowledge_index_node.py" = ["ARG002"]
"core/workflow/nodes/knowledge_retrieval/test_knowledge_retrieval_node.py" = ["ARG002"]
"../e2e_tests/contracts/core/workflow/nodes/llm/test_node.py" = ["ARG002"]
"../e2e_tests/contracts/core/workflow/nodes/parameter_extractor/test_parameter_extractor_node.py" = ["TID251"]
"../e2e_tests/contracts/core/workflow/nodes/test_document_extractor_node.py" = ["ARG001"]
"../e2e_tests/contracts/core/workflow/nodes/tool/test_tool_node.py" = ["ANN401", "ARG002", "TID251"]
"core/workflow/nodes/trigger_webhook/test_node.py" = ["TID251"]
"core/workflow/nodes/human_input/test_pause_reason.py" = ["ANN401", "TID251"]
"core/workflow/test_human_input_adapter.py" = ["ARG005"]
"core/workflow/test_node_factory.py" = ["ARG002"]
"core/workflow/test_workflow_entry.py" = ["ARG001"]
"enterprise/telemetry/test_enterprise_trace.py" = ["ARG002", "TID251"]
"events/event_handlers/test_delete_tool_parameters_cache_when_sync_draft_workflow.py" = ["ARG005"]
"extensions/logstore/test_sql_escape.py" = ["ARG001", "ARG002"]
"extensions/otel/decorators/handlers/test_generate_handler.py" = ["ARG001", "ARG002"]
"extensions/otel/decorators/handlers/test_workflow_app_runner_handler.py" = ["ARG001"]
"core/workflow/nodes/knowledge_retrieval/test_retrieval.py" = ["ARG001"]
"factories/file_factory/test_builders.py" = ["ARG001"]
"factories/file_factory/test_remote.py" = ["ARG001"]
"fields/test_file_fields.py" = ["ARG005"]
"../helpers/unit/libs/_human_input/support.py" = ["TID251"]
"libs/broadcast_channel/redis/test_pubsub_channel.py" = ["ARG002", "ARG005"]
"libs/broadcast_channel/redis/test_streams_channel.py" = ["ARG001", "ARG002", "TID251"]
"libs/test_schedule_utils.py" = ["S110"]
"libs/test_email_i18n.py" = ["ANN401", "TID251"]
"models/test_dataset.py" = ["ARG005"]
"services/agent/test_observability_service.py" = ["ARG002", "ARG005"]
"services/agent/test_roster_service.py" = ["ARG001", "ARG002", "ARG003", "ARG005"]
"../helpers/unit/services/controller_api.py" = ["ARG002"]
"services/data_migration/test_import_service.py" = ["ARG002", "ARG005"]
"../helpers/unit/services/dataset_service_test_helpers.py" = ["TID251"]
"services/enterprise/test_account_deletion_sync.py" = ["ARG001"]
"services/enterprise/test_base.py" = ["ARG002"]
"../helpers/unit/services/hit_service.py" = ["TID251"]
"services/plugin/test_plugin_parameter_service.py" = ["ARG002"]
"services/rag_pipeline/pipeline_template/built_in/test_built_in_retrieval.py" = ["ARG001"]
"services/rag_pipeline/test_rag_pipeline_dsl_service.py" = ["ARG001", "ARG005", "T201", "TID251"]
"services/rag_pipeline/test_rag_pipeline.py" = ["ARG001", "ARG004", "ARG005"]
"services/rag_pipeline/test_rag_pipeline_task_proxy.py" = ["ARG001", "ARG002", "ARG004", "ARG005"]
"services/rag_pipeline/test_rag_pipeline_transform_service.py" = ["ARG001"]
"services/retention/workflow_run/test_archive_download_preparation.py" = ["ARG002"]
"services/retention/workflow_run/test_archive_log_service.py" = ["ARG001", "ARG002"]
"services/retention/workflow_run/test_bundle_archive_maintenance.py" = ["TID251"]
"services/retention/workflow_run/test_restore_archived_workflow_run.py" = ["ARG002"]
"services/test_annotation_service.py" = ["ANN401", "ARG002", "TID251"]
"services/test_api_token_service.py" = ["ARG002"]
"services/test_app_generate_service.py" = ["ARG001", "ARG002", "ARG004", "TID251"]
"services/test_audio_service.py" = ["ARG002", "TID251"]
"services/test_billing_service.py" = ["ARG001", "ARG002"]
"services/retention/workflow_run/test_clear_free_plan_expired_workflow_run_logs.py" = ["ANN401", "ARG002", "ARG005", "TID251"]
"services/test_clear_free_plan_tenant_expired_logs.py" = ["ARG002", "ARG003"]
"services/knowledge/test_dataset_service.py" = ["ARG002"]
"services/data_source/test_provider_service.py" = ["ARG002"]
"services/knowledge/external/test_service.py" = ["ARG002", "TID251"]
"services/test_human_input_delivery_test_service.py" = ["ARG005"]
"services/test_message_service.py" = ["ARG002"]
"services/model_provider/test_service.py" = ["ANN401", "TID251"]
"services/test_operation_service.py" = ["TID251"]
"services/trigger/test_schedule_service.py" = ["ANN401", "TID251"]
"services/test_snippet_service.py" = ["ARG001", "ARG002"]
"services/knowledge/summaries/test_adapters.py" = ["ARG001"]
"services/test_variable_truncator.py" = ["ARG002", "TID251"]
"services/trigger/test_webhook_service.py" = ["ANN401", "ARG002", "TID251"]
"services/data_source/test_website_service.py" = ["TID251"]
"services/test_workflow_run_service.py" = ["ANN401", "ARG002", "TID251"]
"services/test_workflow_service.py" = ["ANN401", "ARG002", "TID251"]
"services/tools/test_builtin_tools_manage_service.py" = ["ARG001", "ARG002"]
"services/tools/test_tools_manage_service.py" = ["ARG002"]
"services/workflow/test_node_output_inspector_service.py" = ["TID251"]
"services/workflow/test_workflow_converter.py" = ["ANN401", "ARG001", "ARG005", "TID251"]
"services/test_workflow_event_snapshot_service.py" = ["ANN401", "ARG002", "ARG005", "TID251"]
"services/workflow/test_workflow_event_snapshot_service_additional.py" = ["ANN401", "ARG002", "ARG005", "TID251"]
"tasks/test_clean_dataset_task.py" = ["ARG002"]
"tasks/test_clean_document_task.py" = ["ARG002"]
"tasks/test_document_indexing_task.py" = ["ARG001", "ARG002"]
"tasks/test_document_indexing_sync_task.py" = ["ARG002"]
"tasks/test_human_input_timeout_tasks.py" = ["ARG001", "ARG002", "ARG005", "TID251"]
"tasks/test_initialize_created_app_rbac_access_task.py" = ["ARG005"]
"tasks/test_process_tenant_plugin_autoupgrade_check_task.py" = ["ARG001"]
"tasks/test_remove_app_and_related_data_task.py" = ["ARG002"]
"tasks/app_generate/test_workflow_execute_task.py" = ["ARG005"]
"../e2e_tests/contracts/test_pytest_dify.py" = ["ARG001"]
[lint.flake8-tidy-imports.banned-api."flask_restx.reqparse"]
msg = "Use Pydantic payload/query models instead of reqparse."
[lint.flake8-tidy-imports.banned-api."flask_restx.reqparse.RequestParser"]
msg = "Use Pydantic payload/query models instead of reqparse."
[lint.flake8-tidy-imports.banned-api."typing.Any"]
msg = "Use object, Protocol, TypedDict, TypeVar, ParamSpec, or a localized cast instead."
Whitespace-only changes.
@@ -0,0 +1 @@
"""Client unit tests."""
@@ -0,0 +1 @@
"""Agent backend client contract tests."""
@@ -0,0 +1,188 @@
from collections.abc import Callable, Iterator
from typing import cast, override
import pytest
from dify_agent.client import DifyAgentHTTPError, DifyAgentStreamError, DifyAgentTimeoutError, DifyAgentValidationError
from dify_agent.layers.execution_context import DifyExecutionContextLayerConfig
from dify_agent.protocol import (
CancelRunRequest,
CancelRunResponse,
CreateRunRequest,
CreateRunResponse,
RunCancelledEvent,
RunCancelledEventData,
RunEvent,
RunStartedEvent,
RunStatusResponse,
)
from clients.agent_backend import (
AgentBackendHTTPError,
AgentBackendModelConfig,
AgentBackendRunRequestBuilder,
AgentBackendStreamError,
AgentBackendTransportError,
AgentBackendValidationError,
AgentBackendWorkflowNodeRunInput,
DifyAgentBackendRunClient,
)
_STREAM_TIMEOUT_UNSET = object()
def _request() -> CreateRunRequest:
return AgentBackendRunRequestBuilder().build_for_workflow_node(
AgentBackendWorkflowNodeRunInput(
model=AgentBackendModelConfig(
plugin_id="langgenius/openai",
model_provider="openai",
model="gpt-test",
),
execution_context=DifyExecutionContextLayerConfig(
tenant_id="tenant-1",
user_from="account",
agent_mode="workflow_run",
invoke_from="debugger",
),
backend_binding_ref="binding-ref-1",
workflow_node_job_prompt="Do the task.",
user_prompt="hello",
)
)
class _SuccessfulClient:
stream_options: tuple[int | None, object, Callable[[], bool] | None] | None = None
cancel_after: str | None = None
def create_run_sync(self, request: CreateRunRequest) -> CreateRunResponse:
assert isinstance(request, CreateRunRequest)
return CreateRunResponse(run_id="run-1", status="running")
def cancel_run_sync(self, run_id: str, request: CancelRunRequest | None = None) -> CancelRunResponse:
del request
return CancelRunResponse(run_id=run_id, status="cancelled")
def cancel_run_and_wait_sync(
self,
run_id: str,
request: CancelRunRequest | None = None,
*,
after: str | None = None,
) -> RunCancelledEvent:
self.cancel_after = after
request = request or CancelRunRequest()
return RunCancelledEvent(
id="2-0",
run_id=run_id,
data=RunCancelledEventData(reason=request.reason, message=request.message),
)
def stream_events_sync(
self,
run_id: str,
*,
after: str | None = None,
max_reconnects: int | None = None,
timeout_seconds: float | None = cast(float | None, _STREAM_TIMEOUT_UNSET),
should_stop: Callable[[], bool] | None = None,
) -> Iterator[RunEvent]:
del after
self.stream_options = (max_reconnects, timeout_seconds, should_stop)
yield RunStartedEvent(id="1-0", run_id=run_id)
def wait_run_sync(self, run_id: str, *, timeout_seconds: float | None = None) -> RunStatusResponse:
del timeout_seconds
return RunStatusResponse.model_validate(
{
"run_id": run_id,
"status": "succeeded",
"created_at": "2026-01-01T00:00:00+00:00",
"updated_at": "2026-01-01T00:00:00+00:00",
}
)
def test_dify_agent_backend_run_client_delegates_sync_methods() -> None:
wrapped = _SuccessfulClient()
client = DifyAgentBackendRunClient(wrapped, stream_max_reconnects=2)
def should_stop() -> bool:
return False
created = client.create_run(_request())
cancelled = client.cancel_run(created.run_id)
cancelled_event = client.cancel_run_and_wait(
created.run_id,
CancelRunRequest(reason="stopped"),
after="1-0",
)
events = list(client.stream_events(created.run_id, should_stop=should_stop))
status = client.wait_run(created.run_id)
assert created.run_id == "run-1"
assert cancelled.status == "cancelled"
assert cancelled_event.data.reason == "stopped"
assert events[0].type == "run_started"
assert status.status == "succeeded"
assert wrapped.cancel_after == "1-0"
assert wrapped.stream_options == (2, _STREAM_TIMEOUT_UNSET, should_stop)
def test_dify_agent_backend_run_client_maps_validation_error() -> None:
class InvalidClient(_SuccessfulClient):
@override
def create_run_sync(self, request: CreateRunRequest) -> CreateRunResponse:
raise DifyAgentValidationError(detail={"field": "bad"})
with pytest.raises(AgentBackendValidationError) as exc_info:
DifyAgentBackendRunClient(InvalidClient()).create_run(_request())
assert exc_info.value.detail == {"field": "bad"}
def test_dify_agent_backend_run_client_maps_http_error() -> None:
class HTTPErrorClient(_SuccessfulClient):
@override
def create_run_sync(self, request: CreateRunRequest) -> CreateRunResponse:
raise DifyAgentHTTPError(status_code=503, detail="unavailable")
with pytest.raises(AgentBackendHTTPError) as exc_info:
DifyAgentBackendRunClient(HTTPErrorClient()).create_run(_request())
assert exc_info.value.status_code == 503
assert exc_info.value.detail == "unavailable"
def test_dify_agent_backend_run_client_maps_timeout_error() -> None:
class TimeoutClient(_SuccessfulClient):
@override
def wait_run_sync(self, run_id: str, *, timeout_seconds: float | None = None) -> RunStatusResponse:
raise DifyAgentTimeoutError("timeout")
with pytest.raises(AgentBackendTransportError) as exc_info:
DifyAgentBackendRunClient(TimeoutClient()).wait_run("run-1")
assert str(exc_info.value) == "timeout"
def test_dify_agent_backend_run_client_maps_stream_error() -> None:
class StreamClient(_SuccessfulClient):
@override
def stream_events_sync(
self,
run_id: str,
*,
after: str | None = None,
max_reconnects: int | None = None,
timeout_seconds: float | None = None,
should_stop: Callable[[], bool] | None = None,
) -> Iterator[RunEvent]:
del run_id, after, max_reconnects, timeout_seconds, should_stop
raise DifyAgentStreamError("bad stream")
yield
with pytest.raises(AgentBackendStreamError) as exc_info:
list(DifyAgentBackendRunClient(StreamClient()).stream_events("run-1"))
assert str(exc_info.value) == "bad stream"
@@ -0,0 +1,207 @@
from decimal import Decimal
from dify_agent.protocol import (
AgentRunUsage,
PydanticAIStreamRunEvent,
RunCancelledEvent,
RunCancelledEventData,
RunFailedEvent,
RunFailedEventData,
RunFailureType,
RunStartedEvent,
RunSucceededEvent,
RunSucceededEventData,
)
from dify_agent.protocol.snapshot import SessionSnapshot
from pydantic_ai.messages import FinalResultEvent
from clients.agent_backend import (
AgentBackendAgentMessageDeltaInternalEvent,
AgentBackendInternalEventType,
AgentBackendRunCancelledInternalEvent,
AgentBackendRunEventAdapter,
AgentBackendRunFailedInternalEvent,
AgentBackendRunStartedInternalEvent,
AgentBackendRunSucceededInternalEvent,
AgentBackendStreamInternalEvent,
)
def test_event_adapter_maps_run_started() -> None:
adapted = AgentBackendRunEventAdapter().adapt(RunStartedEvent(id="1-0", run_id="run-1"))
assert adapted == [
AgentBackendRunStartedInternalEvent(
run_id="run-1",
source_event_id="1-0",
)
]
def test_event_adapter_maps_pydantic_ai_stream_event() -> None:
adapted = AgentBackendRunEventAdapter().adapt(
PydanticAIStreamRunEvent(
id="2-0",
run_id="run-1",
data=FinalResultEvent(tool_name=None, tool_call_id=None),
)
)
assert len(adapted) == 1
event = adapted[0]
assert isinstance(event, AgentBackendStreamInternalEvent)
assert event.type == AgentBackendInternalEventType.STREAM_EVENT
assert event.event_kind == "final_result"
assert isinstance(event.data, dict)
assert event.data["event_kind"] == "final_result"
def test_event_adapter_maps_pydantic_ai_stream_event_agent_message_delta_annotation() -> None:
adapted = AgentBackendRunEventAdapter().adapt(
PydanticAIStreamRunEvent(
id="2-0",
run_id="run-1",
data=FinalResultEvent(tool_name=None, tool_call_id=None),
agent_message_delta="hello",
)
)
assert adapted == [
AgentBackendAgentMessageDeltaInternalEvent(
run_id="run-1",
source_event_id="2-0",
delta="hello",
)
]
def test_event_adapter_maps_run_succeeded_to_final_output() -> None:
snapshot = SessionSnapshot(layers={})
adapted = AgentBackendRunEventAdapter().adapt(
RunSucceededEvent(
id="3-0",
run_id="run-1",
data=RunSucceededEventData(
output={"summary": "done"},
session_snapshot=snapshot,
usage=AgentRunUsage(
prompt_tokens=2,
prompt_unit_price=Decimal(5),
prompt_price_unit=Decimal("0.000001"),
prompt_price=Decimal("0.000010"),
completion_tokens=3,
completion_unit_price=Decimal(30),
completion_price_unit=Decimal("0.000001"),
completion_price=Decimal("0.000090"),
total_price=Decimal("0.000100"),
currency="USD",
latency=0.4,
),
),
)
)
assert adapted == [
AgentBackendRunSucceededInternalEvent(
run_id="run-1",
source_event_id="3-0",
output={"summary": "done"},
session_snapshot=snapshot,
usage={
"prompt_tokens": 2,
"prompt_unit_price": "5",
"prompt_price_unit": "0.000001",
"prompt_price": "0.000010",
"completion_tokens": 3,
"completion_unit_price": "30",
"completion_price_unit": "0.000001",
"completion_price": "0.000090",
"total_tokens": 5,
"total_price": "0.000100",
"currency": "USD",
"latency": 0.4,
"time_to_first_token": None,
"time_to_generate": None,
},
)
]
def test_event_adapter_maps_run_failed_to_failed_result() -> None:
adapted = AgentBackendRunEventAdapter().adapt(
RunFailedEvent(
id="4-0",
run_id="run-1",
data=RunFailedEventData(
error="boom",
error_type=RunFailureType.AGENT_RUN_LIMIT_EXCEEDED,
reason="runtime",
usage=AgentRunUsage(prompt_tokens=13, completion_tokens=8),
),
)
)
assert adapted == [
AgentBackendRunFailedInternalEvent(
run_id="run-1",
source_event_id="4-0",
error="boom",
error_type=RunFailureType.AGENT_RUN_LIMIT_EXCEEDED,
reason="runtime",
usage={
"prompt_tokens": 13,
"completion_tokens": 8,
"total_tokens": 21,
"prompt_unit_price": "0",
"prompt_price_unit": "0",
"prompt_price": "0",
"completion_unit_price": "0",
"completion_price_unit": "0",
"completion_price": "0",
"total_price": "0",
"currency": "USD",
"latency": 0.0,
"time_to_first_token": None,
"time_to_generate": None,
},
)
]
def test_event_adapter_maps_run_cancelled_to_terminal_cancelled() -> None:
adapted = AgentBackendRunEventAdapter().adapt(
RunCancelledEvent(
id="6-0",
run_id="run-1",
data=RunCancelledEventData(
reason="user_cancelled",
message="Stopped by user",
usage=AgentRunUsage(prompt_tokens=5, completion_tokens=3),
),
)
)
assert adapted == [
AgentBackendRunCancelledInternalEvent(
run_id="run-1",
source_event_id="6-0",
reason="user_cancelled",
message="Stopped by user",
usage={
"prompt_tokens": 5,
"completion_tokens": 3,
"total_tokens": 8,
"prompt_unit_price": "0",
"prompt_price_unit": "0",
"prompt_price": "0",
"completion_unit_price": "0",
"completion_price_unit": "0",
"completion_price": "0",
"total_price": "0",
"currency": "USD",
"latency": 0.0,
"time_to_first_token": None,
"time_to_generate": None,
},
)
]
@@ -0,0 +1,103 @@
from collections.abc import Callable
from types import ModuleType
from unittest.mock import MagicMock, patch
import pytest
from dify_agent.client import Client
from clients.agent_backend.factory import create_agent_backend_client, create_agent_backend_run_client
from configs import dify_config
from services.agent import home_snapshot_service, workspace_service
from services.app import agent_sandbox_file_gateway
from tests.helpers.unit.config_override import apply_config_overrides
@pytest.mark.parametrize(
("api_token", "headers"),
[
("secret-token", {"Authorization": "Bearer secret-token"}),
(" secret-token ", {"Authorization": "Bearer secret-token"}),
(" ", None),
(None, None),
],
)
@patch("clients.agent_backend.factory.Client")
def test_create_agent_backend_client_forwards_authentication(
client_cls: MagicMock,
api_token: str | None,
headers: dict[str, str] | None,
) -> None:
create_agent_backend_client(base_url="http://agent-backend", api_token=api_token)
client_cls.assert_called_once_with(
base_url="http://agent-backend",
stream_timeout=30,
timeout=30.0,
binding_file_download_timeout=240,
headers=headers,
)
@patch("clients.agent_backend.factory.create_agent_backend_client")
def test_create_agent_backend_run_client_forwards_stream_read_timeout(create_client: MagicMock) -> None:
create_agent_backend_run_client(
base_url="http://agent-backend",
api_token="secret-token",
stream_read_timeout_seconds=17.5,
)
create_client.assert_called_once_with(
base_url="http://agent-backend",
api_token="secret-token",
stream_timeout=17.5,
)
@pytest.mark.parametrize(
("factory", "module", "extra_kwargs"),
[
(
home_snapshot_service.AgentHomeSnapshotService._client,
home_snapshot_service,
{"timeout": dify_config.AGENT_BACKEND_HOME_SNAPSHOT_TIMEOUT_SECONDS},
),
(
workspace_service.AgentWorkspaceService._client,
workspace_service,
{"timeout": dify_config.AGENT_BACKEND_HOME_SNAPSHOT_TIMEOUT_SECONDS},
),
(
agent_sandbox_file_gateway.create_sandbox_client,
agent_sandbox_file_gateway,
{"binding_file_download_timeout": 123.5},
),
],
)
def test_default_agent_backend_clients_forward_authentication(
monkeypatch: pytest.MonkeyPatch,
factory: Callable[[], Client],
module: ModuleType,
extra_kwargs: dict[str, float],
) -> None:
apply_config_overrides(
monkeypatch,
AGENT_BACKEND_BASE_URL="http://agent-backend",
AGENT_BACKEND_API_TOKEN="secret-token",
AGENT_BACKEND_BINDING_FILE_DOWNLOAD_TIMEOUT_SECONDS=123.5,
)
client_calls: list[dict[str, object]] = []
def record_client_call(**kwargs: object) -> None:
client_calls.append(kwargs)
monkeypatch.setattr(module, "create_agent_backend_client", record_client_call)
factory()
assert client_calls == [
{
"base_url": "http://agent-backend",
"api_token": "secret-token",
**extra_kwargs,
}
]
@@ -0,0 +1,80 @@
from dify_agent.layers.execution_context import DifyExecutionContextLayerConfig
from dify_agent.protocol import CreateRunRequest
from clients.agent_backend import (
AgentBackendModelConfig,
AgentBackendRunRequestBuilder,
AgentBackendWorkflowNodeRunInput,
FakeAgentBackendRunClient,
FakeAgentBackendScenario,
)
def _request() -> CreateRunRequest:
return AgentBackendRunRequestBuilder().build_for_workflow_node(
AgentBackendWorkflowNodeRunInput(
model=AgentBackendModelConfig(
plugin_id="langgenius/openai",
model_provider="openai",
model="gpt-test",
),
execution_context=DifyExecutionContextLayerConfig(
tenant_id="tenant-1",
user_from="account",
agent_mode="workflow_run",
invoke_from="debugger",
),
backend_binding_ref="binding-ref-1",
workflow_node_job_prompt="Do the task.",
user_prompt="hello",
)
)
def test_fake_client_stream_is_deterministic() -> None:
client = FakeAgentBackendRunClient()
request = _request()
created = client.create_run(request)
first = [event.model_dump(mode="json") for event in client.stream_events(created.run_id)]
second = [event.model_dump(mode="json") for event in client.stream_events(created.run_id)]
assert created.run_id == "fake-run-1"
assert client.request is request
assert first == second
assert [event["type"] for event in first] == ["run_started", "run_succeeded"]
assert first[-1]["data"]["output"] == {"text": "hello agent"}
def test_fake_client_stream_honors_cursor() -> None:
events = list(FakeAgentBackendRunClient().stream_events("fake-run-1", after="1-0"))
assert len(events) == 1
assert events[0].type == "run_succeeded"
def test_fake_client_failed_scenario_returns_failed_status_and_event() -> None:
client = FakeAgentBackendRunClient(scenario=FakeAgentBackendScenario.FAILED)
status = client.wait_run("fake-run-1")
events = list(client.stream_events("fake-run-1"))
assert status.status == "failed"
assert status.error == "fake failure"
assert events[-1].type == "run_failed"
assert events[-1].data.error == "fake failure"
def test_fake_client_cancel_run_returns_cancelled_status() -> None:
cancelled = FakeAgentBackendRunClient().cancel_run("fake-run-1")
assert cancelled.run_id == "fake-run-1"
assert cancelled.status == "cancelled"
def test_fake_client_success_wait_run_returns_succeeded_status() -> None:
"""Covers the default SUCCESS branch of ``wait_run`` directly."""
status = FakeAgentBackendRunClient().wait_run("fake-run-1")
assert status.status == "succeeded"
assert status.error is None
@@ -0,0 +1,620 @@
import asyncio
import json
from typing import Any, cast
import httpx
import pytest
from dify_agent.adapters.llm.model import _get_stop_sequences, _map_model_settings_to_parameters
from dify_agent.layers.dify_core_tools import DifyCoreToolConfig, DifyCoreToolsLayerConfig
from dify_agent.layers.dify_plugin import DifyPluginLLMLayerConfig, DifyPluginToolConfig, DifyPluginToolsLayerConfig
from dify_agent.layers.execution_context import ApplicationTracingContext, DifyExecutionContextLayerConfig
from dify_agent.layers.knowledge import DifyKnowledgeBaseLayerConfig
from dify_agent.layers.knowledge_fs import DifyKnowledgeFsLayerConfig
from dify_agent.layers.prompt import Config as PromptConfig
from dify_agent.layers.shell import DifyShellEnvVarConfig, DifyShellLayerConfig
from dify_agent.layers.user_prompt import DifyUserPromptDownloadConfig, DifyUserPromptImageConfig
from dify_agent.protocol import (
DIFY_AGENT_HISTORY_LAYER_ID,
DIFY_AGENT_MODEL_LAYER_ID,
DIFY_AGENT_OUTPUT_LAYER_ID,
CreateRunRequest,
)
from dify_agent.runtime.context import Services
from dify_agent.runtime.modules import create_modules, load_modules
from pydantic import JsonValue, ValidationError
from clients.agent_backend import (
AGENT_SOUL_PROMPT_LAYER_ID,
DIFY_CORE_TOOLS_LAYER_ID,
DIFY_EXECUTION_CONTEXT_LAYER_ID,
DIFY_KNOWLEDGE_BASE_LAYER_ID,
DIFY_PLUGIN_TOOLS_LAYER_ID,
WORKFLOW_NODE_JOB_PROMPT_LAYER_ID,
WORKFLOW_USER_PROMPT_LAYER_ID,
AgentBackendAgentAppRunInput,
AgentBackendModelConfig,
AgentBackendOutputConfig,
AgentBackendRunRequestBuilder,
AgentBackendWorkflowNodeRunInput,
redact_for_agent_backend_log,
)
from clients.agent_backend.request_builder import DIFY_SHELL_LAYER_ID
from models.agent_config_entities import AgentSoulModelSettings
def _run_input() -> AgentBackendWorkflowNodeRunInput:
return AgentBackendWorkflowNodeRunInput(
model=AgentBackendModelConfig(
plugin_id="langgenius/openai",
model_provider="openai",
model="gpt-test",
),
execution_context=DifyExecutionContextLayerConfig(
tenant_id="tenant-1",
user_id="user-1",
user_from="account",
workflow_id="workflow-1",
workflow_run_id="workflow-run-1",
node_id="node-1",
node_execution_id="node-execution-1",
agent_mode="workflow_run",
invoke_from="debugger",
),
backend_binding_ref="binding-ref-1",
idempotency_key="workflow-run-1:node-execution-1",
agent_soul_prompt="You are a careful reviewer.",
workflow_node_job_prompt="Review the previous node output.",
user_prompt="Summarize the report.",
output=AgentBackendOutputConfig(
json_schema={
"type": "object",
"properties": {"summary": {"type": "string"}},
"required": ["summary"],
}
),
metadata={"workflow_id": "workflow-1", "node_id": "node-1"},
)
def test_request_builder_outputs_dify_agent_create_run_request() -> None:
request = AgentBackendRunRequestBuilder().build_for_workflow_node(_run_input())
dumped = request.model_dump(mode="json")
assert isinstance(request, CreateRunRequest)
assert [layer.name for layer in request.composition.layers] == [
AGENT_SOUL_PROMPT_LAYER_ID,
WORKFLOW_NODE_JOB_PROMPT_LAYER_ID,
WORKFLOW_USER_PROMPT_LAYER_ID,
DIFY_EXECUTION_CONTEXT_LAYER_ID,
DIFY_AGENT_HISTORY_LAYER_ID,
DIFY_AGENT_MODEL_LAYER_ID,
DIFY_AGENT_OUTPUT_LAYER_ID,
]
assert request.idempotency_key == "workflow-run-1:node-execution-1"
assert request.metadata == {"workflow_id": "workflow-1", "node_id": "node-1"}
assert "purpose" not in dumped
def test_request_builder_separates_agent_soul_and_workflow_job_prompt() -> None:
request = AgentBackendRunRequestBuilder().build_for_workflow_node(_run_input())
{layer.name: layer for layer in request.composition.layers}
dumped = request.model_dump(mode="json")
assert dumped["composition"]["layers"][0]["config"]["prefix"] == "You are a careful reviewer."
workflow_job_config = dumped["composition"]["layers"][1]["config"]
assert workflow_job_config["user"] == "Review the previous node output."
assert not workflow_job_config.get("prefix")
assert dumped["composition"]["layers"][2]["config"]["user"] == "Summarize the report."
def test_request_builder_forwards_plugin_specific_model_settings_via_extra_body() -> None:
run_input = _run_input().model_copy(
update={
"model": AgentBackendModelConfig(
plugin_id="langgenius/tongyi",
model_provider="tongyi",
model="qwen-plus-latest",
model_settings={"temperature": 0.7, "enable_thinking": True, "thinking_budget": 4096},
)
}
)
request = AgentBackendRunRequestBuilder().build_for_workflow_node(run_input)
layers = {layer.name: layer for layer in request.composition.layers}
model_config = DifyPluginLLMLayerConfig.model_validate(layers[DIFY_AGENT_MODEL_LAYER_ID].config)
assert model_config.model_settings == {
"temperature": 0.7,
"extra_body": {"enable_thinking": True, "thinking_budget": 4096},
}
@pytest.mark.parametrize("builder_kind", ["agent_app", "workflow_node"])
@pytest.mark.parametrize(
"settings",
[
pytest.param({}, id="default"),
pytest.param({"response_format": None}, id="none"),
pytest.param({"response_format": "text"}, id="plugin-text"),
pytest.param(
{
"response_format": "json_schema",
"json_schema": json.dumps(
{"type": "object", "properties": {"answer": {"type": "string"}}, "required": ["answer"]}
),
},
id="plugin-json-schema",
),
pytest.param({"response_format": {"type": "text"}}, id="legacy-text"),
pytest.param(
{
"response_format": {
"type": "json_schema",
"json_schema": {"name": "response", "schema": {"type": "object"}},
}
},
id="legacy-json-schema",
),
],
)
def test_response_format_reaches_plugin_parameters_through_real_request_serialization(
builder_kind: str, settings: dict[str, JsonValue]
) -> None:
soul_settings = AgentSoulModelSettings.model_validate(
{**settings, "temperature": 0.2, "stop": ["END"], "enable_thinking": True}
)
model = AgentBackendModelConfig(
plugin_id="langgenius/openai",
model_provider="openai",
model="gpt-test",
model_settings=soul_settings.model_dump(mode="json", exclude_none=True),
)
builder = AgentBackendRunRequestBuilder()
if builder_kind == "agent_app":
request = builder.build_for_agent_app(_agent_app_input().model_copy(update={"model": model}))
else:
request = builder.build_for_workflow_node(_run_input().model_copy(update={"model": model}))
request = CreateRunRequest.model_validate_json(request.model_dump_json())
model_layer = next(layer for layer in request.composition.layers if layer.name == DIFY_AGENT_MODEL_LAYER_ID)
model_config = DifyPluginLLMLayerConfig.model_validate(model_layer.config)
plugin_settings = {key: value for key, value in settings.items() if value is not None}
assert model_config.model_settings == {
"temperature": 0.2,
"stop_sequences": ["END"],
"extra_body": {"enable_thinking": True, **plugin_settings},
}
assert _map_model_settings_to_parameters(model_config.model_settings) == {
"temperature": 0.2,
"enable_thinking": True,
**plugin_settings,
}
assert _get_stop_sequences(model_config.model_settings) == ["END"]
@pytest.mark.parametrize("agent_config_version_kind", ["snapshot", "draft"])
def test_agent_app_request_builder_keeps_agent_soul_prompt_for_snapshot_and_draft(
agent_config_version_kind: str,
) -> None:
original_prompt = " You are Iris. \n"
run_input = _agent_app_input().model_copy(
update={
"agent_config_version_kind": agent_config_version_kind,
"agent_soul_prompt": original_prompt,
}
)
request = AgentBackendRunRequestBuilder().build_for_agent_app(run_input)
layers = {layer.name: layer for layer in request.composition.layers}
prompt_config = PromptConfig.model_validate(layers[AGENT_SOUL_PROMPT_LAYER_ID].config)
assert prompt_config.prefix == original_prompt
def test_agent_app_request_builder_wraps_agent_soul_prompt_for_build_draft() -> None:
original_prompt = " You are Iris. \n"
run_input = _agent_app_input().model_copy(
update={
"agent_config_version_kind": "build_draft",
"agent_soul_prompt": original_prompt,
}
)
request = AgentBackendRunRequestBuilder().build_for_agent_app(run_input)
layers = {layer.name: layer for layer in request.composition.layers}
prompt_config = PromptConfig.model_validate(layers[AGENT_SOUL_PROMPT_LAYER_ID].config)
assert prompt_config.prefix != original_prompt
assert isinstance(prompt_config.prefix, str)
assert prompt_config.prefix.startswith("You are running in build mode.")
assert "```text\nYou are Iris.\n```" in prompt_config.prefix
def test_agent_app_request_builder_uses_longer_fence_for_build_draft_prompt_body() -> None:
run_input = _agent_app_input().model_copy(
update={
"agent_config_version_kind": "build_draft",
"agent_soul_prompt": "Keep this snippet:\n```python\nprint('hi')\n```",
}
)
request = AgentBackendRunRequestBuilder().build_for_agent_app(run_input)
layers = {layer.name: layer for layer in request.composition.layers}
prompt_config = PromptConfig.model_validate(layers[AGENT_SOUL_PROMPT_LAYER_ID].config)
assert "````text" in prompt_config.prefix
assert "```python" in prompt_config.prefix
def test_request_builder_sets_model_and_output_layer_contract_ids() -> None:
request = AgentBackendRunRequestBuilder().build_for_workflow_node(_run_input())
layers = {layer.name: layer for layer in request.composition.layers}
execution_context_config = DifyExecutionContextLayerConfig.model_validate(
layers[DIFY_EXECUTION_CONTEXT_LAYER_ID].config
)
assert execution_context_config.user_id == "user-1"
assert execution_context_config.user_from == "account"
assert execution_context_config.agent_mode == "workflow_run"
assert execution_context_config.invoke_from == "debugger"
model_config = DifyPluginLLMLayerConfig.model_validate(layers[DIFY_AGENT_MODEL_LAYER_ID].config)
assert model_config.plugin_id == "langgenius/openai"
assert "credentials" not in model_config.model_dump(mode="json")
assert layers[DIFY_AGENT_MODEL_LAYER_ID].config["execution_context"] == DIFY_EXECUTION_CONTEXT_LAYER_ID
@pytest.mark.parametrize("mode", ["agent_app", "workflow_node"])
@pytest.mark.parametrize("traced", [False, True])
def test_context_wire_contract_omits_tracing_for_legacy_runtime(mode: str, traced: bool) -> None:
run_input = _agent_app_input() if mode == "agent_app" else _run_input()
tracing = ApplicationTracingContext(
run_id="00000000-0000-0000-0000-000000000001",
invocation_id="00000000-0000-0000-0000-000000000002",
trace_id="a" * 32,
parent_span_id="b" * 16,
session_id="session",
capture_content=False,
)
if traced:
run_input = run_input.model_copy(
update={"execution_context": run_input.execution_context.model_copy(update={"tracing": tracing})}
)
builder = AgentBackendRunRequestBuilder()
request = (
builder.build_for_agent_app(run_input)
if isinstance(run_input, AgentBackendAgentAppRunInput)
else builder.build_for_workflow_node(run_input)
)
payload = next(
layer.config for layer in request.composition.layers if layer.name == DIFY_EXECUTION_CONTEXT_LAYER_ID
)
if traced:
assert payload["tracing"] == tracing.model_dump(mode="json")
else:
# Pre-tracing runtimes reject even a null unknown field (extra=forbid).
assert "tracing" not in payload
def test_request_builder_adds_dify_plugin_tools_layer_when_configured() -> None:
run_input = _run_input()
run_input.tools = DifyPluginToolsLayerConfig(
tools=[
DifyPluginToolConfig(
plugin_id="langgenius/time",
provider="time",
tool_name="current_time",
credential_type="unauthorized",
name="current_time",
description="Get current time.",
credentials={},
runtime_parameters={},
parameters=[],
parameters_json_schema={"type": "object", "properties": {}, "required": []},
plugin_unique_identifier="langgenius/time:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
)
]
)
request = AgentBackendRunRequestBuilder().build_for_workflow_node(run_input)
layers = {layer.name: layer for layer in request.composition.layers}
assert layers[DIFY_PLUGIN_TOOLS_LAYER_ID].config["execution_context"] == DIFY_EXECUTION_CONTEXT_LAYER_ID
tools_config = DifyPluginToolsLayerConfig.model_validate(layers[DIFY_PLUGIN_TOOLS_LAYER_ID].config)
assert tools_config.tools[0].tool_name == "current_time"
def test_request_builder_adds_dify_core_tools_layer_when_configured() -> None:
run_input = _run_input()
run_input.core_tools = DifyCoreToolsLayerConfig(
tools=[
DifyCoreToolConfig(
provider_type="builtin",
provider_id="audio",
tool_name="transcribe",
name="transcribe",
description="Transcribe audio.",
runtime_parameters={"language": "en"},
parameters=[],
parameters_json_schema={"type": "object", "properties": {}, "required": []},
)
]
)
request = AgentBackendRunRequestBuilder().build_for_workflow_node(run_input)
layers = {layer.name: layer for layer in request.composition.layers}
assert layers[DIFY_CORE_TOOLS_LAYER_ID].config["execution_context"] == DIFY_EXECUTION_CONTEXT_LAYER_ID
def test_request_builder_adds_knowledge_layer_when_configured() -> None:
run_input = _run_input()
run_input.knowledge = DifyKnowledgeBaseLayerConfig.model_validate(
{
"sets": [
{
"id": "support",
"name": "Support KB",
"datasets": [{"id": "dataset-1"}],
"query": {"mode": "generated_query"},
"retrieval": {"mode": "multiple", "top_k": 4},
}
],
}
)
request = AgentBackendRunRequestBuilder().build_for_workflow_node(run_input)
layers = {layer.name: layer for layer in request.composition.layers}
assert DIFY_KNOWLEDGE_BASE_LAYER_ID in layers
assert layers[DIFY_KNOWLEDGE_BASE_LAYER_ID].config["execution_context"] == DIFY_EXECUTION_CONTEXT_LAYER_ID
knowledge_config = DifyKnowledgeBaseLayerConfig.model_validate(layers[DIFY_KNOWLEDGE_BASE_LAYER_ID].config)
assert knowledge_config.sets[0].dataset_ids == ["dataset-1"]
def test_request_builder_rejects_blank_prompts() -> None:
with pytest.raises(ValidationError, match="prompt must not be blank"):
AgentBackendWorkflowNodeRunInput(
model=AgentBackendModelConfig(
plugin_id="langgenius/openai",
model_provider="openai",
model="gpt-test",
),
execution_context=DifyExecutionContextLayerConfig(
tenant_id="tenant-1",
user_from="account",
agent_mode="workflow_run",
invoke_from="debugger",
),
backend_binding_ref="binding-ref-1",
workflow_node_job_prompt=" ",
user_prompt="hello",
)
def test_agent_backend_request_does_not_contain_llm_credentials() -> None:
request = AgentBackendRunRequestBuilder().build_for_workflow_node(_run_input())
redacted = cast(dict[str, Any], redact_for_agent_backend_log(request))
assert "credentials" not in redacted["composition"]["layers"][5]["config"]
def _agent_app_input(*, include_shell: bool = False) -> AgentBackendAgentAppRunInput:
return AgentBackendAgentAppRunInput(
model=AgentBackendModelConfig(
plugin_id="langgenius/openai",
model_provider="openai",
model="gpt-test",
),
execution_context=DifyExecutionContextLayerConfig(
tenant_id="tenant-1",
user_id="user-1",
user_from="end-user",
conversation_id="conv-1",
agent_mode="agent_app",
invoke_from="web-app",
),
backend_binding_ref="binding-ref-1",
agent_soul_prompt="You are Iris.",
user_prompt="List files.",
include_shell=include_shell,
metadata={"conversation_id": "conv-1"},
)
def test_workflow_request_builder_omits_shell_layer_by_default() -> None:
request = AgentBackendRunRequestBuilder().build_for_workflow_node(_run_input())
assert DIFY_SHELL_LAYER_ID not in {layer.name for layer in request.composition.layers}
def test_workflow_request_builder_adds_shell_layer_when_include_shell() -> None:
run_input = _run_input()
run_input.include_shell = True
run_input.shell_config = DifyShellLayerConfig(env=[DifyShellEnvVarConfig(name="PROJECT_NAME", value="demo")])
request = AgentBackendRunRequestBuilder().build_for_workflow_node(run_input)
layers = {layer.name: layer for layer in request.composition.layers}
assert DIFY_SHELL_LAYER_ID in layers
shell = layers[DIFY_SHELL_LAYER_ID]
# The shell layer depends on execution_context so the agent server can mint
# per-command Agent Stub env for sandbox CLI forwarding.
assert shell.config["execution_context"] == DIFY_EXECUTION_CONTEXT_LAYER_ID
assert shell.config["runtime"] == "runtime"
shell_config = DifyShellLayerConfig.model_validate(shell.config)
assert shell_config.env[0].name == "PROJECT_NAME"
def test_agent_app_request_builder_omits_shell_layer_by_default() -> None:
request = AgentBackendRunRequestBuilder().build_for_agent_app(_agent_app_input())
assert DIFY_SHELL_LAYER_ID not in {layer.name for layer in request.composition.layers}
def test_agent_app_request_builder_emits_multimodal_user_prompt_layer() -> None:
run_input = _agent_app_input()
run_input.user_files = [
DifyUserPromptDownloadConfig(
type="document", transfer_method="remote_url", url="https://example.com/brief.pdf"
),
DifyUserPromptImageConfig(
filename="earth.png",
mime_type="image/png",
format="png",
url="https://files.example.com/earth.png?sign=secret",
detail="high",
),
]
request = AgentBackendRunRequestBuilder().build_for_agent_app(run_input)
layer = next(layer for layer in request.composition.layers if layer.name == "agent_app_user_prompt")
assert layer.config["text"] == "List files."
assert layer.config["files"] == [f.model_dump(mode="json") for f in run_input.user_files]
restored_request = CreateRunRequest.model_validate_json(request.model_dump_json())
restored_layer = next(
layer for layer in restored_request.composition.layers if layer.name == "agent_app_user_prompt"
)
assert restored_layer.config == layer.config
assert "locators" not in restored_layer.config
def test_agent_backend_log_redacts_multimodal_file_transport() -> None:
run_input = _agent_app_input()
run_input.metadata = {"source_url": "https://example.com/docs"}
run_input.user_files = [
DifyUserPromptImageConfig(
filename="earth.png",
mime_type="image/png",
format="png",
url="https://files.example.com/earth.png?sign=secret",
),
DifyUserPromptImageConfig(
filename="inline.png",
mime_type="image/png",
format="png",
base64_data="aW1hZ2UtYnl0ZXM=",
),
]
redacted = cast(
dict[str, Any],
redact_for_agent_backend_log(AgentBackendRunRequestBuilder().build_for_agent_app(run_input)),
)
layer = next(item for item in redacted["composition"]["layers"] if item["name"] == "agent_app_user_prompt")
assert layer["config"]["files"][0]["url"] == "[REDACTED]"
assert layer["config"]["files"][1]["base64_data"] == "[REDACTED]"
assert redacted["metadata"]["source_url"] == "https://example.com/docs"
def test_agent_app_request_builder_keeps_build_draft_prompt_when_agent_soul_prompt_is_blank() -> None:
run_input = _agent_app_input().model_copy(
update={"agent_soul_prompt": " ", "agent_config_version_kind": "build_draft"}
)
request = AgentBackendRunRequestBuilder().build_for_agent_app(run_input)
layers = {layer.name: layer for layer in request.composition.layers}
prompt_config = PromptConfig.model_validate(layers[AGENT_SOUL_PROMPT_LAYER_ID].config)
assert "You are running in build mode." in prompt_config.prefix
assert "No task prompt was provided." in prompt_config.prefix
def test_agent_app_request_builder_adds_shell_layer_when_include_shell() -> None:
run_input = _agent_app_input(include_shell=True)
run_input.shell_config = DifyShellLayerConfig(env=[DifyShellEnvVarConfig(name="APP_ENV", value="enabled")])
request = AgentBackendRunRequestBuilder().build_for_agent_app(run_input)
layers = {layer.name: layer for layer in request.composition.layers}
assert DIFY_SHELL_LAYER_ID in layers
assert layers[DIFY_SHELL_LAYER_ID].config["execution_context"] == DIFY_EXECUTION_CONTEXT_LAYER_ID
assert layers[DIFY_SHELL_LAYER_ID].config["runtime"] == "runtime"
shell_config = DifyShellLayerConfig.model_validate(layers[DIFY_SHELL_LAYER_ID].config)
assert shell_config.env[0].name == "APP_ENV"
def test_agent_app_request_builder_adds_knowledge_layer_when_configured() -> None:
run_input = _agent_app_input()
run_input.knowledge = DifyKnowledgeBaseLayerConfig.model_validate(
{
"sets": [
{
"id": "support",
"name": "Support KB",
"datasets": [{"id": "dataset-1"}, {"id": "dataset-2"}],
"query": {"mode": "generated_query"},
"retrieval": {"mode": "multiple", "top_k": 2},
}
],
}
)
request = AgentBackendRunRequestBuilder().build_for_agent_app(run_input)
layers = {layer.name: layer for layer in request.composition.layers}
assert DIFY_KNOWLEDGE_BASE_LAYER_ID in layers
assert layers[DIFY_KNOWLEDGE_BASE_LAYER_ID].config["execution_context"] == DIFY_EXECUTION_CONTEXT_LAYER_ID
knowledge_config = DifyKnowledgeBaseLayerConfig.model_validate(layers[DIFY_KNOWLEDGE_BASE_LAYER_ID].config)
assert knowledge_config.sets[0].dataset_ids == ["dataset-1", "dataset-2"]
@pytest.mark.parametrize("mode", ["agent_app", "workflow"])
def test_knowledge_fs_requires_shell_and_can_coexist_with_classic_knowledge(mode: str) -> None:
config = DifyKnowledgeFsLayerConfig.model_validate(
{"spaces": [{"id": "docs", "name": "Docs", "control_space_id": "00000000-0000-4000-8000-000000000001"}]}
)
run_input = _agent_app_input() if mode == "agent_app" else _run_input()
run_input.knowledge_fs = config
builder = AgentBackendRunRequestBuilder()
def build() -> CreateRunRequest:
if isinstance(run_input, AgentBackendAgentAppRunInput):
return builder.build_for_agent_app(run_input)
return builder.build_for_workflow_node(run_input)
with pytest.raises(ValueError, match="requires shell"):
build()
run_input.include_shell = True
layers = {layer.name: layer for layer in build().composition.layers}
knowledge_fs = DifyKnowledgeFsLayerConfig.model_validate(layers["knowledge_fs"].config)
assert knowledge_fs == config
assert knowledge_fs.execution_context == DIFY_EXECUTION_CONTEXT_LAYER_ID
assert knowledge_fs.shell == DIFY_SHELL_LAYER_ID
assert DIFY_KNOWLEDGE_BASE_LAYER_ID not in layers
assert not any("search" in layer.name or "retriev" in layer.name for layer in layers.values())
run_input.knowledge = DifyKnowledgeBaseLayerConfig.model_validate(
{
"sets": [
{
"id": "legacy",
"name": "Legacy",
"datasets": [{"id": "dataset-1"}],
"query": {"mode": "generated_query"},
"retrieval": {"mode": "multiple", "top_k": 2},
}
]
}
)
mixed_layers = {layer.name: layer for layer in build().composition.layers}
assert DIFY_KNOWLEDGE_BASE_LAYER_ID in mixed_layers
assert "knowledge_fs" in mixed_layers
classic_config = DifyKnowledgeBaseLayerConfig.model_validate(mixed_layers[DIFY_KNOWLEDGE_BASE_LAYER_ID].config)
knowledge_fs_config = DifyKnowledgeFsLayerConfig.model_validate(mixed_layers["knowledge_fs"].config)
assert classic_config.sets[0].id == "legacy"
assert knowledge_fs_config.spaces[0].id == "docs"
run_input.execution_context.app_id = "app-1"
client = httpx.AsyncClient()
try:
services = Services(
plugin_daemon_http_client=client,
dify_api_http_client=client,
runtime_backend_profile=cast(Any, object()),
knowledge_session_store=cast(Any, object()),
)
modules = create_modules(load_modules(build(), services, "mixed-knowledge-run"))
assert DIFY_KNOWLEDGE_BASE_LAYER_ID in modules
assert "knowledge_fs" in modules
finally:
asyncio.run(client.aclose())
@@ -0,0 +1,94 @@
"""Keep migration command ownership and the public Flask CLI layout stable."""
import pytest
import commands
from dify_app import DifyApp
from extensions import ext_commands
@pytest.fixture
def migration_app() -> DifyApp:
app = DifyApp(__name__)
ext_commands.init_app(app)
return app
def test_migration_commands_are_registered_from_consolidated_module(migration_app: DifyApp) -> None:
expected_commands = {
"data-migrate": commands.data_migrate,
"app-migration-template": commands.export_migration_data_template,
"export-app-migration": commands.export_migration_data,
"import-app-migration": commands.import_migration_data,
"app-migration-wizard": commands.migration_data_wizard,
}
for name, command in expected_commands.items():
assert migration_app.cli.commands[name] is command
assert command.callback is not None
assert command.callback.__module__ == "commands.data_migration"
assert commands.legacy_model_types.callback is not None
assert commands.legacy_model_types.callback.__module__ == "commands.data_migration"
assert "legacy-model-types" not in migration_app.cli.commands
def test_data_migrate_keeps_existing_subcommands_and_top_level_rbac_command(migration_app: DifyApp) -> None:
assert commands.data_migrate.commands == {
"legacy-model-types": commands.legacy_model_types,
"rbac-migrate-dataset-permissions": commands.migrate_dataset_permissions_to_rbac,
"rbac-migrate-resource-whitelist-scopes": (
commands.migrate_only_me_resource_whitelist_scopes_to_automatic_include
),
}
assert (
migration_app.cli.commands["rbac-migrate-dataset-permissions"] is commands.migrate_dataset_permissions_to_rbac
)
@pytest.mark.parametrize(
("command_path", "expected_help"),
[
(
("data-migrate",),
("legacy-model-types", "rbac-migrate-dataset-permissions", "rbac-migrate-resource-whitelist-scopes"),
),
(
("data-migrate", "legacy-model-types"),
("--apply", "--tables", "--model-types", "--tenant-id-file", "--output", "--concurrency"),
),
(
("data-migrate", "rbac-migrate-dataset-permissions"),
("--tenant-id", "--batch-size", "--dry-run"),
),
(
("data-migrate", "rbac-migrate-resource-whitelist-scopes"),
("--tenant-id", "--resource-type", "--batch-size", "--dry-run"),
),
(("app-migration-template",), ("--output", "--overwrite")),
(("export-app-migration",), ("--input", "--output", "--overwrite")),
(
("import-app-migration",),
(
"--input",
"--target-tenant",
"--operator-email",
"--id-strategy",
"--conflict-strategy",
"--create-app-api-token-on-import",
"--no-create-app-api-token-on-import",
),
),
(("app-migration-wizard",), ("Interactively export workflow migration data.",)),
],
)
def test_migration_command_help_remains_available(
migration_app: DifyApp,
command_path: tuple[str, ...],
expected_help: tuple[str, ...],
) -> None:
result = migration_app.test_cli_runner().invoke(args=[*command_path, "--help"])
assert result.exit_code == 0, result.output
for text in expected_help:
assert text in result.output
@@ -0,0 +1,49 @@
import pytest
from click.testing import CliRunner
from sqlalchemy.orm import Session
from commands.account import reset_email, reset_password
from extensions.ext_application_services import ApplicationServices
from models.account import Account
def _raise_keyboard_interrupt(*_args: object, **_kwargs: object) -> None:
raise KeyboardInterrupt
def test_reset_password_does_not_swallow_keyboard_interrupt(
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
account_application_services: ApplicationServices,
) -> None:
sqlite_session.add(Account(name="Command User", email="a@example.com"))
sqlite_session.commit()
monkeypatch.setattr("commands.account.application_services", lambda: account_application_services)
monkeypatch.setattr("commands.account.valid_password", _raise_keyboard_interrupt)
result = CliRunner().invoke(
reset_password,
["--email", "a@example.com", "--new-password", "whatever", "--password-confirm", "whatever"],
)
assert not isinstance(result.exception, SystemExit) or result.exception.code != 0
assert "Invalid password" not in result.output
def test_reset_email_does_not_swallow_keyboard_interrupt(
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
account_application_services: ApplicationServices,
) -> None:
sqlite_session.add(Account(name="Command User", email="a@example.com"))
sqlite_session.commit()
monkeypatch.setattr("commands.account.application_services", lambda: account_application_services)
monkeypatch.setattr("commands.account.email_validate", _raise_keyboard_interrupt)
result = CliRunner().invoke(
reset_email,
["--email", "a@example.com", "--new-email", "b@example.com", "--email-confirm", "b@example.com"],
)
assert not isinstance(result.exception, SystemExit) or result.exception.code != 0
assert "Invalid email" not in result.output
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,972 @@
from __future__ import annotations
import json
from dataclasses import dataclass, field
from pathlib import Path
from unittest.mock import patch
import click
import pytest
from click.testing import CliRunner
from commands import knowledge_fs as commands
from commands.knowledge_fs import _cutover_service, _read_jsonl, knowledge_fs_control_space
from models.knowledge_fs import (
KnowledgeFSControlSpace,
KnowledgeFSControlSpaceState,
KnowledgeFSDeleteCommandPayload,
KnowledgeFSLifecycleOperation,
KnowledgeFSLifecycleOutbox,
)
from services.knowledge_fs.cleanup import CleanupCompletionReport, CleanupStartReport
from services.knowledge_fs.control_space_commands import KnowledgeFSDeletionIntentResult
from services.knowledge_fs.control_space_management import (
KnowledgeFSControlSpaceDryRunReport,
KnowledgeFSControlSpaceRegistration,
)
from services.knowledge_fs.cutover import (
CutoverBackfillReport,
QuarantineResolutionReport,
ShadowCompletionReport,
WorkspaceInventoryInput,
)
@dataclass(frozen=True)
class _TenantPayload:
tenant_id: str
class _Report:
"""Operator report shape: the commands only serialize ``_asdict()``."""
def __init__(self, **values: object) -> None:
self._values = values
def _asdict(self) -> dict[str, object]:
return self._values
def _control_space(
control_space_id: str, state: KnowledgeFSControlSpaceState = KnowledgeFSControlSpaceState.ACTIVE
) -> KnowledgeFSControlSpace:
control_space = KnowledgeFSControlSpace(
tenant_id="tenant-1",
owner_account_id="account-1",
provisioning_key="provision-1",
state=state,
)
control_space.id = control_space_id
return control_space
def _deletion_outbox(control_space: KnowledgeFSControlSpace, operation_id: str) -> KnowledgeFSLifecycleOutbox:
return KnowledgeFSLifecycleOutbox(
tenant_id=control_space.tenant_id,
control_space_id=control_space.id,
operation_id=operation_id,
idempotency_key="delete:one",
operation=KnowledgeFSLifecycleOperation.DELETE,
command_payload=KnowledgeFSDeleteCommandPayload(
schema_version=1,
idempotency_key="delete:one",
expected_revision=0,
knowledge_space_id=None,
provisioning_key="provision-1",
),
expected_control_space_version=0,
)
@dataclass
class _WorkspaceDeletionLifecycleService:
purged_control_spaces: int
preflight_tenants: list[str] = field(default_factory=list)
finalized_tenants: list[str] = field(default_factory=list)
def assert_workspace_deletion_allowed(self, *, tenant_id: str) -> None:
self.preflight_tenants.append(tenant_id)
def finalize_workspace_deletion(self, *, tenant_id: str) -> int:
self.finalized_tenants.append(tenant_id)
return self.purged_control_spaces
@dataclass
class _ObservationCutoverService:
status_report: dict[str, object]
observation_calls: list[tuple[str, dict[str, object]]] = field(default_factory=list)
status_tenants: list[str] = field(default_factory=list)
def status(self, *, tenant_id: str) -> dict[str, object]:
self.status_tenants.append(tenant_id)
return self.status_report
def begin_observation(self, **kwargs: object) -> None:
self.observation_calls.append(("begin", kwargs))
def complete_observation(self, **kwargs: object) -> None:
self.observation_calls.append(("complete", kwargs))
@dataclass
class _ManagementService:
registered: KnowledgeFSControlSpace
repaired: KnowledgeFSControlSpace
registrations: list[KnowledgeFSControlSpaceRegistration] = field(default_factory=list)
repair_calls: list[dict[str, object]] = field(default_factory=list)
dry_run_tenants: list[str | None] = field(default_factory=list)
def dry_run(self, *, tenant_id: str | None) -> _Report:
self.dry_run_tenants.append(tenant_id)
return _Report(total=1, by_state={"active": 1})
def register(self, registration: KnowledgeFSControlSpaceRegistration) -> tuple[KnowledgeFSControlSpace, bool]:
self.registrations.append(registration)
return self.registered, True
def repair_registration(self, **kwargs: object) -> KnowledgeFSControlSpace:
self.repair_calls.append(kwargs)
return self.repaired
@dataclass
class _CleanupService:
request_calls: list[tuple[object, bool]] = field(default_factory=list)
approve_calls: list[tuple[object, bool]] = field(default_factory=list)
status_calls: list[dict[str, str]] = field(default_factory=list)
def request_cleanup(self, payload: object, *, apply: bool) -> _Report:
self.request_calls.append((payload, apply))
return _Report(applied=False)
def approve_cleanup(self, payload: object, *, apply: bool) -> _Report:
self.approve_calls.append((payload, apply))
return _Report(applied=True)
def status(self, *, tenant_id: str, request_id: str) -> dict[str, object]:
self.status_calls.append({"tenant_id": tenant_id, "request_id": request_id})
return {"state": "approved"}
@dataclass
class _OrphanReconciler:
calls: list[dict[str, object]] = field(default_factory=list)
def reconcile(self, *, limit: int, apply_repairs: bool) -> _Report:
self.calls.append({"limit": limit, "apply_repairs": apply_repairs})
return _Report(scanned=3, repaired=0)
def test_control_space_command_exposes_all_p1a_management_operations() -> None:
assert {
"backfill",
"dry-run",
"orphan-report",
"register",
"repair",
"workspace-delete-finalize",
"workspace-delete-request",
} <= set(knowledge_fs_control_space.commands)
def test_workspace_delete_request_is_dry_run_unless_apply_is_explicit() -> None:
with (
patch("commands.knowledge_fs._management_service") as management_factory,
patch("commands.knowledge_fs._lifecycle_service") as lifecycle_factory,
):
management_factory.return_value.dry_run.return_value = KnowledgeFSControlSpaceDryRunReport(
total=2,
by_state={"active": 2},
irreversible_deletions=0,
)
dry_run = CliRunner().invoke(
knowledge_fs_control_space,
["workspace-delete-request", "--tenant-id", "tenant-1"],
)
control_space = _control_space("control-1")
lifecycle_factory.return_value.request_workspace_cleanup.return_value = (
KnowledgeFSDeletionIntentResult(
control_space=control_space,
outbox=_deletion_outbox(control_space, "operation-1"),
),
)
applied = CliRunner().invoke(
knowledge_fs_control_space,
["workspace-delete-request", "--tenant-id", "tenant-1", "--apply"],
)
assert dry_run.exit_code == 0
assert '"apply": false' in dry_run.output
lifecycle_factory.return_value.request_workspace_cleanup.assert_called_once_with(tenant_id="tenant-1")
assert applied.exit_code == 0
assert '"operation-1"' in applied.output
def test_workspace_delete_finalize_requires_terminal_preflight_and_explicit_purge_ack() -> None:
lifecycle = _WorkspaceDeletionLifecycleService(purged_control_spaces=2)
with patch("commands.knowledge_fs._lifecycle_service", return_value=lifecycle):
preflight = CliRunner().invoke(
knowledge_fs_control_space,
["workspace-delete-finalize", "--tenant-id", "tenant-1"],
)
denied = CliRunner().invoke(
knowledge_fs_control_space,
["workspace-delete-finalize", "--tenant-id", "tenant-1", "--apply"],
)
applied = CliRunner().invoke(
knowledge_fs_control_space,
[
"workspace-delete-finalize",
"--tenant-id",
"tenant-1",
"--apply",
"--acknowledge-control-plane-purge",
],
)
assert preflight.exit_code == 0
assert lifecycle.preflight_tenants == ["tenant-1"]
assert denied.exit_code == 2
assert "--acknowledge-control-plane-purge" in denied.output
assert lifecycle.finalized_tenants == ["tenant-1"]
assert applied.exit_code == 0
assert '"purged_control_spaces": 2' in applied.output
def test_control_space_command_exposes_p8_migration_and_cutover_operations() -> None:
assert {
"inventory",
"backfill",
"shadow-start",
"shadow-report",
"shadow-complete",
"legacy-dashboard",
"legacy-check",
"freeze",
"final-delta",
"greenfield-initialize",
"cutover",
"smoke",
"observe",
"quarantine-resolve",
"rollback",
"status",
"cleanup-request",
"cleanup-approve",
"cleanup-start",
"cleanup-complete",
"cleanup-status",
} <= set(knowledge_fs_control_space.commands)
def test_greenfield_initialize_cli_runs_the_automatic_initializer() -> None:
with (
patch("commands.knowledge_fs._greenfield_initializer") as initializer_factory,
patch("commands.knowledge_fs._cutover_service") as cutover_factory,
):
cutover_factory.return_value.status.return_value = {
"tenant_id": "00000000-0000-0000-0000-000000000001",
"phase": "cutover",
}
result = CliRunner().invoke(
knowledge_fs_control_space,
[
"greenfield-initialize",
"--tenant-id",
"00000000-0000-0000-0000-000000000001",
],
)
assert result.exit_code == 0
initializer_factory.return_value.ensure_initialized.assert_called_once_with(
tenant_id="00000000-0000-0000-0000-000000000001"
)
assert '"phase": "cutover"' in result.output
def test_operator_cutover_service_installs_remote_registry_lazily() -> None:
with patch("commands.knowledge_fs.get_knowledge_fs_lifecycle_remote") as remote_factory:
service = _cutover_service()
remote_factory.assert_not_called()
assert service._remote_factory is remote_factory
def test_shadow_complete_cli_reads_strict_jsonl_and_defaults_to_dry_run(tmp_path: Path) -> None:
input_path = tmp_path / "shadow-completion.jsonl"
input_path.write_text(
json.dumps(
{
"schema_version": "knowledge-fs-p8-shadow-completion/v1",
"tenant_id": "00000000-0000-0000-0000-000000000001",
"expected_cas_version": 3,
"producer": "dify-shadow-authorizer",
"completed_by_operator": "knowledge-fs-cutover",
"completed_by_account_id": "00000000-0000-0000-0000-000000000002",
"completed_at": "2026-07-21T16:00:00Z",
"traffic_zero": False,
"window_started_at": "2026-07-21T12:00:00Z",
"window_ended_at": "2026-07-21T15:00:00Z",
}
),
encoding="utf-8",
)
with patch("commands.knowledge_fs._cutover_service") as service_factory:
service_factory.return_value.complete_shadow.return_value = ShadowCompletionReport(
"00000000-0000-0000-0000-000000000001",
7,
False,
f"sha256:{'a' * 64}",
{
"membership_epoch": 1,
"space_acl_epoch": 1,
"external_access_epoch": 1,
"content_policy_revision": 1,
},
False,
False,
)
result = CliRunner().invoke(
knowledge_fs_control_space,
["shadow-complete", "--input", str(input_path)],
)
assert result.exit_code == 0
assert service_factory.return_value.complete_shadow.call_args.kwargs == {"apply": False}
assert '"applied": false' in result.output
invalid = json.loads(input_path.read_text(encoding="utf-8"))
invalid["unknown"] = True
input_path.write_text(json.dumps(invalid), encoding="utf-8")
rejected = CliRunner().invoke(
knowledge_fs_control_space,
["shadow-complete", "--input", str(input_path)],
)
assert rejected.exit_code == 1
assert "invalid strict JSONL" in rejected.output
def test_quarantine_resolve_cli_reads_strict_jsonl_and_is_dry_run_without_apply(tmp_path: Path) -> None:
input_path = tmp_path / "quarantine-resolution.jsonl"
input_path.write_text(
json.dumps(
{
"schema_version": "knowledge-fs-p8-quarantine-resolution/v1",
"tenant_id": "00000000-0000-0000-0000-000000000001",
"source_kind": "legacy_api_key",
"source_id": "legacy-key-1",
"expected_row_version": 0,
"resolved_by_operator": "migration-oncall",
"resolved_by_account_id": "00000000-0000-0000-0000-000000000002",
"evidence": {
"schema_version": "knowledge-fs-p8-credential-rotation/v1",
"legacy_key_id": "legacy-key-1",
"knowledge_space_id": "00000000-0000-0000-0000-000000000003",
"control_space_id": "00000000-0000-0000-0000-000000000004",
"dify_credential_id": "00000000-0000-0000-0000-000000000005",
"dify_credential_revision": 1,
"legacy_revoked_at": "2026-07-21T11:00:00Z",
"verification_reference": "change://key-rotation/1",
"plaintext_migrated": False,
},
"resolved_at": "2026-07-21T12:00:00Z",
}
),
encoding="utf-8",
)
with patch("commands.knowledge_fs._cutover_service") as service_factory:
service_factory.return_value.resolve_quarantine.return_value = QuarantineResolutionReport(
"00000000-0000-0000-0000-000000000001",
"legacy_api_key",
"legacy-key-1",
"rotate_credential",
0,
False,
False,
)
result = CliRunner().invoke(
knowledge_fs_control_space,
["quarantine-resolve", "--input", str(input_path)],
)
assert result.exit_code == 0
assert service_factory.return_value.resolve_quarantine.call_args.kwargs == {"apply": False}
assert '"applied": false' in result.output
invalid_path = tmp_path / "invalid-quarantine-resolution.jsonl"
invalid_payload = json.loads(input_path.read_text(encoding="utf-8"))
invalid_payload["unknown"] = True
invalid_path.write_text(json.dumps(invalid_payload), encoding="utf-8")
invalid = CliRunner().invoke(
knowledge_fs_control_space,
["quarantine-resolve", "--input", str(invalid_path)],
)
assert invalid.exit_code == 1
assert "invalid strict JSONL" in invalid.output
def test_strict_jsonl_rejects_unknown_credential_fields(tmp_path: Path) -> None:
input_path = tmp_path / "inventory.jsonl"
input_path.write_text(
json.dumps(
{
"tenant_id": "00000000-0000-0000-0000-000000000001",
"source_revision_watermark": {
"membership_epoch": 1,
"space_acl_epoch": 1,
"external_access_epoch": 1,
"content_policy_revision": 1,
},
"task_watermark": 1,
"spaces": [
{
"knowledge_space_id": "00000000-0000-0000-0000-000000000002",
"knowledge_space_revision": 1,
"provisioning_key": "p-1",
"owner_subject_id": "owner-1",
"owner_account_id": "00000000-0000-0000-0000-000000000003",
"visibility": "only_me",
"legacy_api_keys": [
{
"key_id": "key-1",
"prefix": "kfs_",
"last4": "1234",
"secret": "must-not-be-accepted",
}
],
}
],
}
),
encoding="utf-8",
)
with pytest.raises(click.ClickException, match="invalid strict JSONL at line 1"):
_read_jsonl(input_path, WorkspaceInventoryInput)
def test_backfill_cli_is_dry_run_without_explicit_apply(tmp_path: Path) -> None:
input_path = tmp_path / "inventory.jsonl"
input_path.write_text(
json.dumps(
{
"tenant_id": "00000000-0000-0000-0000-000000000001",
"source_revision_watermark": {
"membership_epoch": 1,
"space_acl_epoch": 1,
"external_access_epoch": 1,
"content_policy_revision": 1,
},
"task_watermark": 1,
"spaces": [],
}
),
encoding="utf-8",
)
with patch("commands.knowledge_fs._cutover_service") as service_factory:
service_factory.return_value.backfill.return_value = CutoverBackfillReport(
"00000000-0000-0000-0000-000000000001",
0,
0,
0,
0,
"inventory",
False,
)
result = CliRunner().invoke(knowledge_fs_control_space, ["backfill", "--input", str(input_path)])
assert result.exit_code == 0
assert service_factory.return_value.backfill.call_args.kwargs == {"apply": False}
def test_cleanup_start_cli_defaults_to_no_mutation_and_requires_irreversible_ack_for_apply(
tmp_path: Path,
) -> None:
input_path = tmp_path / "cleanup-start.jsonl"
input_path.write_text(
json.dumps(
{
"schema_version": "knowledge-fs-p9-cleanup-start/v1",
"tenant_id": "00000000-0000-0000-0000-000000000001",
"request_id": "00000000-0000-0000-0000-000000000002",
"expected_cas_version": 7,
"plan_digest": f"sha256:{'a' * 64}",
"started_by_account_id": "00000000-0000-0000-0000-000000000003",
"started_at": "2026-07-21T12:00:00Z",
"confirmation": "START-KNOWLEDGE-FS-IRREVERSIBLE-CLEANUP",
}
),
encoding="utf-8",
)
with patch("commands.knowledge_fs._cleanup_service") as service_factory:
service_factory.return_value.start_cleanup.return_value = CleanupStartReport(
"00000000-0000-0000-0000-000000000001",
"00000000-0000-0000-0000-000000000002",
True,
(),
"approved",
False,
False,
None,
False,
)
dry_run = CliRunner().invoke(
knowledge_fs_control_space,
["cleanup-start", "--input", str(input_path)],
)
denied_apply = CliRunner().invoke(
knowledge_fs_control_space,
["cleanup-start", "--input", str(input_path), "--apply"],
)
assert dry_run.exit_code == 0
assert service_factory.return_value.start_cleanup.call_args.kwargs == {"apply": False}
assert denied_apply.exit_code == 2
assert "--acknowledge-irreversible" in denied_apply.output
def test_cleanup_complete_cli_requires_explicit_executed_ack_for_apply(tmp_path: Path) -> None:
input_path = tmp_path / "cleanup-completion.jsonl"
input_path.write_text(
json.dumps(
{
"schema_version": "knowledge-fs-p9-cleanup-completion/v1",
"tenant_id": "00000000-0000-0000-0000-000000000001",
"request_id": "00000000-0000-0000-0000-000000000002",
"expected_cas_version": 8,
"plan_digest": f"sha256:{'a' * 64}",
"migration_bundle_digest": f"sha256:{'a' * 64}",
"database_engine": "postgresql",
"migration_revision": "knowledge-fs-p9-removal/v1",
"archived_row_counts": {
"knowledge_space_members": 0,
"knowledge_space_access_policies": 0,
"knowledge_space_access_policy_members": 0,
"knowledge_space_api_access": 0,
"knowledge_space_api_keys": 0,
"knowledge_space_permission_snapshots": 0,
},
"checks": {
"legacy_foreign_keys_remaining": 0,
"legacy_tables_remaining": 0,
"legacy_routes_registered": 0,
"legacy_v1_auth_acceptances": 0,
"raw_proxy_routes_registered": 0,
"post_cleanup_smoke_passed": True,
"recovery_material_verified": True,
},
"archive_reference": "archive://kfs/p9",
"catalog_verification_reference": "catalog://kfs/p9",
"route_metric_reference": "metrics://kfs/p9",
"post_cleanup_smoke_reference": "smoke://kfs/p9",
"recovery_material_reference": "recovery://kfs/p9",
"completed_by_account_id": "00000000-0000-0000-0000-000000000003",
"completed_at": "2026-07-21T12:00:00Z",
}
),
encoding="utf-8",
)
with patch("commands.knowledge_fs._cleanup_service") as service_factory:
service_factory.return_value.complete_cleanup.return_value = CleanupCompletionReport(
"00000000-0000-0000-0000-000000000001",
"00000000-0000-0000-0000-000000000002",
True,
(),
"started",
False,
False,
False,
)
dry_run = CliRunner().invoke(
knowledge_fs_control_space,
["cleanup-complete", "--input", str(input_path)],
)
denied_apply = CliRunner().invoke(
knowledge_fs_control_space,
["cleanup-complete", "--input", str(input_path), "--apply"],
)
assert dry_run.exit_code == 0
assert service_factory.return_value.complete_cleanup.call_args.kwargs == {"apply": False}
assert denied_apply.exit_code == 2
assert "--acknowledge-executed" in denied_apply.output
def test_operator_commands_delegate_cutover_mutations_with_validated_timestamps(
tmp_path: Path,
) -> None:
input_path = tmp_path / "operator-input.jsonl"
input_path.write_text("{}\n", encoding="utf-8")
payload = _TenantPayload(tenant_id="tenant-1")
runner = CliRunner()
with (
patch("commands.knowledge_fs._cutover_service") as service_factory,
patch("commands.knowledge_fs._read_jsonl", return_value=(payload,)),
patch("commands.knowledge_fs._read_one_jsonl", return_value=payload),
):
service = service_factory.return_value
service.status.return_value = {
"legacy_dependency_ready": True,
"open_issues": 0,
"unresolved_cutover_quarantine": 0,
}
for method_name, method in (
("inventory", service.inventory),
("record_shadow_report", service.record_shadow_report),
("legacy_dependency_dashboard", service.legacy_dependency_dashboard),
):
method.return_value = _Report(operation=method_name)
invocations = [
["inventory", "--input", str(input_path)],
[
"shadow-start",
"--tenant-id",
"tenant-1",
"--expected-cas-version",
"2",
"--at",
"2026-07-21T12:00:00+00:00",
],
["shadow-report", "--input", str(input_path), "--apply"],
[
"issue-approve",
"--tenant-id",
"tenant-1",
"--issue-key",
"issue-1",
"--account-id",
"account-1",
"--at",
"2026-07-21T12:00:00+00:00",
],
[
"issue-resolve",
"--tenant-id",
"tenant-1",
"--issue-key",
"issue-1",
"--account-id",
"account-1",
"--at",
"2026-07-21T13:00:00+00:00",
],
[
"shadow-approve",
"--tenant-id",
"tenant-1",
"--diff-key",
"diff-1",
"--account-id",
"account-1",
"--at",
"2026-07-21T12:00:00+00:00",
],
[
"shadow-resolve",
"--tenant-id",
"tenant-1",
"--diff-key",
"diff-1",
"--account-id",
"account-1",
"--at",
"2026-07-21T13:00:00+00:00",
],
[
"legacy-dashboard",
"--tenant-id",
"tenant-1",
"--input",
str(input_path),
"--checked-at",
"2026-07-21T14:00:00+00:00",
],
[
"freeze",
"--tenant-id",
"tenant-1",
"--expected-cas-version",
"3",
"--at",
"2026-07-21T15:00:00+00:00",
],
["final-delta", "--input", str(input_path)],
[
"cutover",
"--tenant-id",
"tenant-1",
"--expected-cas-version",
"4",
"--at",
"2026-07-21T16:00:00+00:00",
"--rollback-cutoff-at",
"2026-07-21T18:00:00+00:00",
],
[
"smoke",
"--tenant-id",
"tenant-1",
"--expected-cas-version",
"5",
"--input",
str(input_path),
],
[
"rollback",
"--tenant-id",
"tenant-1",
"--expected-cas-version",
"6",
"--at",
"2026-07-21T17:00:00+00:00",
],
["status", "--tenant-id", "tenant-1"],
]
results = [runner.invoke(knowledge_fs_control_space, arguments) for arguments in invocations]
assert all(result.exit_code == 0 for result in results), [(result.output, result.exception) for result in results]
service.inventory.assert_called_once_with(payload, apply=False)
assert service.begin_shadow.call_args.kwargs["started_at"].utcoffset().total_seconds() == 0
service.record_shadow_report.assert_called_once_with((payload,), apply=True)
service.approve_issue_fail_closed.assert_called_once()
service.resolve_issue.assert_called_once()
service.approve_shadow_diff.assert_called_once()
service.resolve_shadow_diff.assert_called_once()
service.legacy_dependency_dashboard.assert_called_once()
service.freeze.assert_called_once()
service.apply_final_delta.assert_called_once_with(payload)
service.cutover.assert_called_once()
service.record_smoke_results.assert_called_once_with(
tenant_id="tenant-1",
expected_cas_version=5,
results=payload,
)
service.rollback.assert_called_once()
def test_observation_command_enforces_mutually_exclusive_start_and_completion_modes() -> None:
service = _ObservationCutoverService(status_report={"phase": "observing"})
runner = CliRunner()
base = ["observe", "--tenant-id", "tenant-1", "--expected-cas-version", "7"]
with patch("commands.knowledge_fs._cutover_service", return_value=service):
started = runner.invoke(
knowledge_fs_control_space,
[
*base,
"--started-at",
"2026-07-21T12:00:00+00:00",
"--window-ends-at",
"2026-07-21T14:00:00+00:00",
"--maximum-task-expires-at",
"2026-07-21T13:00:00+00:00",
],
)
completed = runner.invoke(
knowledge_fs_control_space,
[*base, "--observed-at", "2026-07-21T14:00:00+00:00"],
)
conflicting = runner.invoke(
knowledge_fs_control_space,
[
*base,
"--observed-at",
"2026-07-21T14:00:00+00:00",
"--started-at",
"2026-07-21T12:00:00+00:00",
],
)
incomplete = runner.invoke(
knowledge_fs_control_space,
[*base, "--started-at", "2026-07-21T12:00:00+00:00"],
)
assert started.exit_code == 0
assert completed.exit_code == 0
assert conflicting.exit_code == 2
assert "cannot be combined" in conflicting.output
assert incomplete.exit_code == 2
assert "observation start requires" in incomplete.output
assert [name for name, _ in service.observation_calls] == ["begin", "complete"]
def test_legacy_check_returns_a_process_failure_when_any_cutover_gate_is_open() -> None:
runner = CliRunner()
passing: dict[str, object] = {
"legacy_dependency_ready": True,
"open_issues": 0,
"unresolved_cutover_quarantine": 0,
}
failing_reports: tuple[dict[str, object], ...] = (
{**passing, "legacy_dependency_ready": False},
{**passing, "open_issues": 1},
{**passing, "unresolved_cutover_quarantine": 1},
)
service = _ObservationCutoverService(status_report=passing)
with patch("commands.knowledge_fs._cutover_service", return_value=service):
passed = runner.invoke(knowledge_fs_control_space, ["legacy-check", "--tenant-id", "tenant-1"])
failed = []
for report in failing_reports:
service.status_report = report
failed.append(runner.invoke(knowledge_fs_control_space, ["legacy-check", "--tenant-id", "tenant-1"]))
assert passed.exit_code == 0
assert '"passed": true' in passed.output
assert all(result.exit_code == 1 for result in failed)
assert all('"passed": false' in result.output for result in failed)
def test_management_cleanup_and_reconciliation_commands_preserve_apply_safety(
tmp_path: Path,
) -> None:
input_path = tmp_path / "operator-input.jsonl"
input_path.write_text("{}\n", encoding="utf-8")
payload = _TenantPayload(tenant_id="tenant-1")
management = _ManagementService(registered=_control_space("control-1"), repaired=_control_space("control-1"))
cleanup = _CleanupService()
reconciler = _OrphanReconciler()
runner = CliRunner()
with (
patch("commands.knowledge_fs._management_service", return_value=management),
patch("commands.knowledge_fs._cleanup_service", return_value=cleanup),
patch("commands.knowledge_fs._read_one_jsonl", return_value=payload),
patch("commands.knowledge_fs.KnowledgeFSOrphanReconciler", return_value=reconciler),
patch("commands.knowledge_fs.session_factory.get_session_maker", return_value=object()),
patch("commands.knowledge_fs.get_knowledge_fs_lifecycle_remote", return_value=object()),
):
invocations = [
["dry-run", "--tenant-id", "tenant-1"],
[
"register",
"--tenant-id",
"tenant-1",
"--owner-account-id",
"account-1",
"--provisioning-key",
"provision-1",
"--knowledge-space-id",
"knowledge-space-1",
"--knowledge-space-revision",
"2",
],
[
"repair",
"--tenant-id",
"tenant-1",
"--control-space-id",
"control-1",
"--expected-resource-version",
"3",
"--knowledge-space-id",
"knowledge-space-1",
"--knowledge-space-revision",
"4",
],
["orphan-report", "--limit", "25"],
["cleanup-request", "--input", str(input_path)],
["cleanup-approve", "--input", str(input_path), "--apply"],
["cleanup-status", "--tenant-id", "tenant-1", "--request-id", "request-1"],
]
results = [runner.invoke(knowledge_fs_control_space, arguments) for arguments in invocations]
assert all(result.exit_code == 0 for result in results), [(result.output, result.exception) for result in results]
assert management.dry_run_tenants == ["tenant-1"]
assert len(management.registrations) == 1
registration = management.registrations[0]
assert registration.tenant_id == "tenant-1"
assert registration.knowledge_space_revision == 2
assert management.repair_calls == [
{
"tenant_id": "tenant-1",
"control_space_id": "control-1",
"expected_resource_version": 3,
"knowledge_space_id": "knowledge-space-1",
"knowledge_space_revision": 4,
}
]
assert reconciler.calls == [{"limit": 25, "apply_repairs": False}]
assert cleanup.request_calls == [(payload, False)]
assert cleanup.approve_calls == [(payload, True)]
assert cleanup.status_calls == [{"tenant_id": "tenant-1", "request_id": "request-1"}]
def test_jsonl_and_timestamp_helpers_reject_ambiguous_operator_input(tmp_path: Path) -> None:
from pydantic import BaseModel, ConfigDict
class StrictRecord(BaseModel):
value: int
model_config = ConfigDict(extra="forbid")
input_path = tmp_path / "records.jsonl"
input_path.write_text('\n{"value": 1}\n\n{"value": 2}\n', encoding="utf-8")
records = commands._read_jsonl(input_path, StrictRecord)
assert [record.value for record in records] == [1, 2]
with pytest.raises(click.ClickException, match="exactly one"):
commands._read_one_jsonl(input_path, StrictRecord)
input_path.write_text("\n", encoding="utf-8")
assert commands._read_jsonl(input_path, StrictRecord, allow_empty=True) == ()
with pytest.raises(click.ClickException, match="at least one"):
commands._read_jsonl(input_path, StrictRecord)
with pytest.raises(click.ClickException, match="invalid ISO-8601"):
commands._parse_timestamp("not-a-timestamp")
with pytest.raises(click.ClickException, match="explicit timezone"):
commands._parse_timestamp("2026-07-21T12:00:00")
def test_operator_error_adapters_preserve_domain_messages() -> None:
from services.knowledge_fs.cleanup import KnowledgeFSCleanupError
from services.knowledge_fs.control_space_lifecycle import KnowledgeFSControlSpaceLifecycleError
from services.knowledge_fs.cutover import KnowledgeFSCutoverError
adapters = (
(commands._operator_call, KnowledgeFSCutoverError("cutover blocked"), "cutover blocked"),
(commands._cleanup_call, KnowledgeFSCleanupError("approval missing"), "approval missing"),
(commands._lifecycle_call, KnowledgeFSControlSpaceLifecycleError("space busy"), "space busy"),
)
for adapter, error, message in adapters:
with pytest.raises(click.ClickException, match=message):
adapter(lambda error=error: (_ for _ in ()).throw(error))
assert commands._operator_call(lambda: "ok") == "ok"
assert commands._cleanup_call(lambda: "ok") == "ok"
assert commands._lifecycle_call(lambda: "ok") == "ok"
def test_operator_service_factories_share_the_configured_session_maker() -> None:
session_maker = object()
management = object()
cutover = object()
cleanup = object()
lifecycle = object()
with (
patch("commands.knowledge_fs.session_factory.get_session_maker", return_value=session_maker),
patch(
"commands.knowledge_fs.KnowledgeFSControlSpaceManagementService", return_value=management
) as management_factory,
patch("commands.knowledge_fs.KnowledgeFSWorkspaceCutoverService", return_value=cutover) as cutover_factory,
patch("commands.knowledge_fs.KnowledgeFSCleanupService", return_value=cleanup) as cleanup_factory,
patch(
"commands.knowledge_fs.KnowledgeFSControlSpaceCommandService", return_value=lifecycle
) as lifecycle_factory,
patch("commands.knowledge_fs.get_knowledge_fs_lifecycle_remote") as remote_factory,
):
assert commands._management_service() is management
assert commands._cutover_service() is cutover
assert commands._cleanup_service() is cleanup
assert commands._lifecycle_service() is lifecycle
management_factory.assert_called_once_with(session_maker)
cutover_factory.assert_called_once_with(session_maker, remote_factory=remote_factory)
cleanup_factory.assert_called_once_with(session_maker)
lifecycle_factory.assert_called_once_with(session_maker)
@@ -0,0 +1,177 @@
import json
from collections.abc import Iterator
import pytest
from click.testing import CliRunner
from commands import rbac
from enums.account import TenantAccountRole
from models import TenantAccountJoin
from models.agent import Agent, AgentScope, AgentSource
from tests.helpers.unit.model_factories import make_tenant
from tests.helpers.unit.rbac_fakes import RBACDomain
"""Exercise migration queries against SQLite and the shared RBAC transport fake."""
def _events(output: str) -> list[dict[str, object]]:
return [json.loads(line) for line in output.splitlines() if line.startswith("{")]
def _seed_agent(domain: RBACDomain) -> None:
with domain.sessions.begin() as session:
session.add(make_tenant(tenant_id="t1"))
session.add(
Agent(
id="ag1",
tenant_id="t1",
name="Agent",
scope=AgentScope.ROSTER,
source=AgentSource.ROSTER,
created_by="c1",
)
)
for index, account_id in enumerate(("owner-1", "m1", "admin-1", "m2", "m3")):
membership = TenantAccountJoin(tenant_id="t1", account_id=account_id, role=TenantAccountRole.NORMAL)
membership.id = f"membership-{index}"
session.add(membership)
session.add(TenantAccountJoin(tenant_id="other", account_id="foreign", role=TenantAccountRole.NORMAL))
domain.transport.responses["/rbac/agents/whitelist"] = {"rbac_whitelist_scope": "all"}
# Remote RBAC bindings protect administrators even when the local role is normal.
domain.transport.responses["/rbac/members/rbac-roles/batch"] = {
f"{role_tag}-1": [
{
"id": f"role-{role_tag}",
"type": "workspace",
"category": "global_system_default",
"name": role_tag,
"is_builtin": True,
"role_tag": role_tag,
}
]
for role_tag in ("owner", "admin")
}
class TestRbacAgentMigrationCases:
@staticmethod
@pytest.fixture(autouse=True)
def migration_database(monkeypatch: pytest.MonkeyPatch, rbac_domain: RBACDomain) -> None:
monkeypatch.setattr(rbac.session_factory, "create_session", rbac_domain.sessions)
@staticmethod
def test_apply_flag_writes_and_reports_applied(rbac_domain: RBACDomain) -> None:
with rbac_domain.sessions.begin() as session:
session.add_all([make_tenant(tenant_id="t1"), make_tenant(tenant_id="t2")])
rbac_domain.transport.response = {
"roles": [{"role_id": "r1", "role_name": "ops", "added_keys": ["agent.create"]}]
}
result = CliRunner().invoke(rbac.migrate_agent_permissions_to_rbac, ["--apply"])
assert result.exit_code == 0, result.output
assert len(rbac_domain.transport.requests) == 2
for request in rbac_domain.transport.requests:
assert (request.method, request.endpoint) == ("POST", "/rbac/migrations/agent-manage-roles")
assert request.json == {"apply": True}
events = _events(result.output)
assert [event["event"] for event in events] == ["agent_manage_role_migration_applied"] * 2
assert {event["tenant_id"] for event in events} == {"t1", "t2"}
assert "changed" in result.output
@staticmethod
def test_agent_bootstrap_apply_writes_whitelist_member_batches_and_creator_sync(rbac_domain: RBACDomain) -> None:
_seed_agent(rbac_domain)
result = CliRunner().invoke(rbac.migrate_agent_permissions_to_rbac, ["--apply", "--member-batch-size", "2"])
assert result.exit_code == 0, result.output
assert [event["event"] for event in _events(result.output)] == ["agent_access_bootstrap_applied"]
assert _events(result.output)[0]["dry_run"] is False
role_queries = [
request
for request in rbac_domain.transport.requests
if request.endpoint == "/rbac/members/rbac-roles/batch"
]
assert [request.json for request in role_queries] == [
{"member_ids": ["owner-1", "m1"]},
{"member_ids": ["admin-1", "m2"]},
{"member_ids": ["m3"]},
]
for request in role_queries:
assert (request.method, request.tenant_id, request.account_id) == ("POST", "t1", "c1")
writes = [request for request in rbac_domain.transport.requests if request.method == "PUT"]
assert [request.endpoint for request in writes] == [
"/rbac/agents/user-access-policies",
"/rbac/agents/user-access-policies",
"/rbac/agents/user-access-policies",
"/rbac/access-policies/creator-member-bindings",
"/rbac/agents/whitelist",
]
first, second, third, creator, whitelist = writes
for request in writes:
assert (request.tenant_id, request.account_id) == ("t1", "c1")
for request, account_ids in ((first, ["m1"]), (second, ["m2"]), (third, ["m3"])):
assert request.params == {"agent_id": "ag1", "account_id": None}
assert request.json == {"account_ids": account_ids, "access_policy_ids": ["default"]}
assert creator.params == {"resource_type": "agent", "agent_id": "ag1"}
assert whitelist.params == {"agent_id": "ag1"}
assert whitelist.json == {"automatic_include_workspace_members": True}
assert "1 agent(s) changed, 0 already initialised" in result.output
@staticmethod
def test_agent_bootstrap_is_idempotent_on_a_second_apply(rbac_domain: RBACDomain) -> None:
_seed_agent(rbac_domain)
first = CliRunner().invoke(rbac.migrate_agent_permissions_to_rbac, ["--apply"])
assert first.exit_code == 0, first.output
assert any(request.method == "PUT" for request in rbac_domain.transport.requests)
rbac_domain.transport.requests.clear()
rbac_domain.transport.responses["/rbac/migrations/agent-access-state"] = {"configured_agent_ids": ["ag1"]}
result = CliRunner().invoke(rbac.migrate_agent_permissions_to_rbac, ["--apply"])
assert result.exit_code == 0, result.output
events = _events(result.output)
assert [event["event"] for event in events] == ["agent_access_bootstrap_skipped"]
assert events[0]["reason"] == "already_initialized"
assert not any(request.method == "PUT" for request in rbac_domain.transport.requests)
assert "0 agent(s) changed, 1 already initialised" in result.output
class TestRbacMemberMigrationCases:
@staticmethod
@pytest.mark.parametrize("workers", [1, 2])
def test_member_migration_uses_shared_remote_adapter_without_write_sessions(
monkeypatch: pytest.MonkeyPatch, rbac_domain: RBACDomain, workers: int
) -> None:
def batches(
tenant_id: str | None, *, db_batch_size: int, api_batch_size: int
) -> Iterator[tuple[str, str, list[tuple[str, str]]]]:
assert tenant_id is None
assert db_batch_size > 0
assert api_batch_size > 0
yield "workspace", "owner", [("first", "editor"), ("second", "normal")]
def unexpected_session() -> None:
raise AssertionError("A remote role replacement must not open a database session")
monkeypatch.setattr(rbac, "_iter_tenant_member_batches", batches)
monkeypatch.setattr(
rbac, "_resolve_builtin_role_ids", lambda *_args: {"editor": "role-editor", "normal": "role-normal"}
)
monkeypatch.setattr(rbac.RBACService.MemberRoles, "batch_get", lambda **_kwargs: [])
monkeypatch.setattr(rbac.session_factory, "create_session", unexpected_session)
rbac_domain.transport.response = {"account_id": "member", "roles": []}
result = CliRunner().invoke(rbac.migrate_member_roles_to_rbac, ["--workers", str(workers)])
assert result.exit_code == 0, result.output
sent = rbac_domain.transport.requests
assert len(sent) == 2
for request in sent:
assert (request.method, request.endpoint) == ("PUT", "/rbac/members/rbac-roles")
assert (request.tenant_id, request.account_id) == ("workspace", "owner")
assert request.params is not None
expected_role = "role-editor" if request.params["account_id"] == "first" else "role-normal"
assert request.json == {"role_ids": [expected_role]}
assert {request.params["account_id"] for request in sent if request.params} == {"first", "second"}
@@ -0,0 +1,826 @@
import datetime
import logging
import re
from dataclasses import dataclass
from types import SimpleNamespace
from unittest.mock import MagicMock, Mock, patch
from uuid import uuid4
import click
import pytest
from click.testing import CliRunner
from sqlalchemy import Engine, event, text
from sqlalchemy.exc import OperationalError
from sqlalchemy.orm import Session, scoped_session, sessionmaker
from commands import clean_expired_messages, retention
from graphon.enums import WorkflowExecutionStatus, WorkflowNodeExecutionStatus
from models.base import TypeBase
from models.enums import CreatorUserRole, WorkflowRunTriggeredFrom
from models.workflow import (
WorkflowNodeExecutionModel,
WorkflowNodeExecutionTriggeredFrom,
WorkflowRun,
WorkflowType,
)
from services.retention.workflow_run import bundle_archive_maintenance
from services.retention.workflow_run.bundle_archive_maintenance import (
BundleOperationResult,
BundleOperationSummary,
)
"""Tests for workflow-run archive command database boundaries.
Planning deliberately creates a fresh session for every tenant prefix and for
every database retry. SQLite-backed tests keep the query, filtering, counting,
and session lifecycle real while clocks, billing lookup, and command failures
remain narrow external-boundary substitutions.
"""
_CURSOR_0 = "00000000-0000-0000-0000-000000000000"
_CURSOR_1 = "00000000-0000-0000-0000-000000000001"
_CURSOR_2 = "00000000-0000-0000-0000-000000000002"
def _db_disconnect_error() -> OperationalError:
return OperationalError(
"select 1",
{},
RuntimeError("server closed the connection unexpectedly"),
connection_invalidated=True,
)
@dataclass(frozen=True)
class ArchiveDatabase:
"""Creates archive candidates and their node executions in SQLite."""
session_maker: sessionmaker[Session]
end_before: datetime.datetime
def add_run(
self,
tenant_id: str,
*,
created_at: datetime.datetime | None = None,
status: WorkflowExecutionStatus = WorkflowExecutionStatus.SUCCEEDED,
run_type: WorkflowType = WorkflowType.WORKFLOW,
) -> str:
run_id = str(uuid4())
with self.session_maker.begin() as session:
workflow_record = WorkflowRun(
id=run_id,
tenant_id=tenant_id,
app_id=str(uuid4()),
workflow_id=str(uuid4()),
type=run_type,
triggered_from=WorkflowRunTriggeredFrom.APP_RUN,
version="1",
graph="{}",
inputs="{}",
status=status,
outputs="{}",
error=None,
elapsed_time=0,
total_tokens=0,
total_steps=1,
created_by_role=CreatorUserRole.ACCOUNT,
created_by=str(uuid4()),
)
workflow_record.created_at = created_at or self.end_before - datetime.timedelta(days=1)
session.add(workflow_record)
return run_id
def add_node(self, run_id: str, tenant_id: str, *, index: int) -> None:
with self.session_maker.begin() as session:
session.add(
WorkflowNodeExecutionModel(
id=str(uuid4()),
tenant_id=tenant_id,
app_id=str(uuid4()),
workflow_id=str(uuid4()),
triggered_from=WorkflowNodeExecutionTriggeredFrom.WORKFLOW_RUN,
workflow_run_id=run_id,
index=index,
predecessor_node_id=None,
node_execution_id=None,
node_id=f"node-{index}",
node_type="start",
title="Start",
inputs="{}",
process_data="{}",
outputs="{}",
status=WorkflowNodeExecutionStatus.SUCCEEDED,
error=None,
elapsed_time=0,
execution_metadata="{}",
created_by_role=CreatorUserRole.ACCOUNT,
created_by=str(uuid4()),
)
)
def _delete_summary(
*,
processed: int,
succeeded: int = 0,
failed: int = 0,
next_catalog_id: str | None = None,
preview_next_catalog_id: str | None = None,
results: list[BundleOperationResult] | None = None,
) -> BundleOperationSummary:
return BundleOperationSummary(
operation="delete",
bundles_processed=processed,
bundles_succeeded=succeeded,
bundles_failed=failed,
next_catalog_id=next_catalog_id,
preview_next_catalog_id=preview_next_catalog_id,
results=results or [],
)
def _patch_bundle_deleter(
monkeypatch: pytest.MonkeyPatch,
summaries: list[BundleOperationSummary],
) -> MagicMock:
deleter = MagicMock()
deleter.delete_batch.side_effect = summaries
monkeypatch.setattr(
bundle_archive_maintenance,
"WorkflowRunBundleArchiveMaintenance",
MagicMock(return_value=deleter),
)
return deleter
def _tenant_id(prefix: str, suffix: int) -> str:
return f"{prefix}{suffix:07x}-0000-0000-0000-000000000000"
class TestArchiveWorkflowRunsCases:
@staticmethod
@pytest.mark.parametrize(
"command",
[retention.restore_workflow_runs, retention.delete_archived_workflow_runs],
)
def test_v2_archive_maintenance_rejects_explicitly_empty_tenant_ids(command):
result = CliRunner().invoke(
command,
["--tenant-ids", "", "--target-month", "2025-03"],
)
assert result.exit_code == 2
assert "tenant-ids must not be empty" in result.output
@staticmethod
def test_archive_tenant_id_parser_keeps_omitted_scope_unset():
assert retention._parse_comma_separated_ids(None, param_name="tenant-ids") is None
@staticmethod
@pytest.fixture
def archive_db(sqlite_engine: Engine) -> ArchiveDatabase:
"""Create only the workflow tables used by archive planning."""
TypeBase.metadata.create_all(
sqlite_engine,
tables=[WorkflowRun.__table__, WorkflowNodeExecutionModel.__table__],
)
return ArchiveDatabase(
session_maker=sessionmaker(bind=sqlite_engine, expire_on_commit=False),
end_before=datetime.datetime(2025, 4, 1, tzinfo=datetime.UTC),
)
@staticmethod
def test_resolve_archive_tenant_ids_from_plan_uses_fresh_real_sessions(
archive_db: ArchiveDatabase, monkeypatch: pytest.MonkeyPatch
) -> None:
paid_a = _tenant_id("a", 1)
free_a = _tenant_id("a", 2)
paid_b = _tenant_id("b", 1)
free_b = _tenant_id("b", 2)
for tenant_id in (paid_a, free_a, paid_b, free_b):
archive_db.add_run(tenant_id)
# These decoys verify the real candidate query's time, status, and type filters.
archive_db.add_run(
_tenant_id("a", 3),
created_at=archive_db.end_before + datetime.timedelta(seconds=1),
)
archive_db.add_run(_tenant_id("a", 4), status=WorkflowExecutionStatus.RUNNING)
archive_db.add_run(_tenant_id("a", 5), run_type=WorkflowType.CHAT)
opened_sessions: list[Session] = []
def record_session(session: Session, _transaction: object, _connection: object) -> None:
opened_sessions.append(session)
event.listen(archive_db.session_maker.class_, "after_begin", record_session)
monkeypatch.setattr(
retention,
"_filter_paid_workflow_archive_tenant_ids",
lambda tenant_ids: ([paid_a, paid_b], sorted(set(tenant_ids) - {paid_a, paid_b})),
)
try:
tenant_plan = retention._resolve_archive_tenant_ids_from_plan(
session_maker=archive_db.session_maker,
tenant_ids=None,
tenant_prefixes=["a", "b"],
start_from=None,
end_before=archive_db.end_before,
)
finally:
event.remove(archive_db.session_maker.class_, "after_begin", record_session)
assert tenant_plan == {
"archive_tenant_ids": [paid_a, paid_b],
"paid_tenant_ids": [paid_a, paid_b],
"unpaid_tenant_ids": [free_a, free_b],
}
assert len(opened_sessions) == 2
assert opened_sessions[0] is not opened_sessions[1]
@staticmethod
def test_safe_remove_scoped_session_recovers_from_real_closed_connection(
sqlite_engine: Engine,
monkeypatch: pytest.MonkeyPatch,
caplog: pytest.LogCaptureFixture,
) -> None:
maker = sessionmaker(bind=sqlite_engine)
registry = scoped_session(maker)
registry().execute(text("select 1"))
dbapi_connection = registry().connection().connection.dbapi_connection
assert dbapi_connection is not None
dbapi_connection.close()
monkeypatch.setattr(retention, "db", SimpleNamespace(session=registry, engine=sqlite_engine))
with caplog.at_level(logging.WARNING, logger="commands.retention"):
retention._safe_remove_scoped_session("archive workflow run command")
assert not registry.registry.has()
assert any("Ignoring DB scoped-session cleanup error" in message for message in caplog.messages)
@staticmethod
def test_archive_command_db_retry_retries_retryable_db_disconnect(monkeypatch: pytest.MonkeyPatch) -> None:
attempts = iter([_db_disconnect_error(), "ok"])
sleep = Mock()
monkeypatch.setattr("services.retention.workflow_run.db_retry.time.sleep", sleep)
def operation() -> str:
result = next(attempts)
if isinstance(result, Exception):
raise result
return result
assert retention._run_archive_command_db_retry("archive plan", operation) == "ok"
sleep.assert_called_once_with(1.0)
@staticmethod
def test_archive_plan_prefix_stats_retries_with_fresh_session_and_real_counts(
archive_db: ArchiveDatabase, sqlite_engine: Engine, monkeypatch: pytest.MonkeyPatch
) -> None:
tenant_id = _tenant_id("a", 1)
run_ids = [archive_db.add_run(tenant_id) for _ in range(7)]
for index in range(9):
archive_db.add_node(run_ids[index % len(run_ids)], tenant_id, index=index)
# Decoys outside the selected prefix and archive window must not affect counts.
decoy_run_id = archive_db.add_run(_tenant_id("b", 1))
archive_db.add_node(decoy_run_id, _tenant_id("b", 1), index=99)
archive_db.add_run(
tenant_id,
created_at=archive_db.end_before + datetime.timedelta(seconds=1),
)
fail_next_query = True
def disconnect_once(
_connection: object,
_cursor: object,
_statement: str,
_parameters: object,
_context: object,
_executemany: bool,
) -> None:
nonlocal fail_next_query
if fail_next_query:
fail_next_query = False
raise _db_disconnect_error()
opened_sessions: list[Session] = []
def record_session(session: Session, _transaction: object, _connection: object) -> None:
opened_sessions.append(session)
sleep = Mock()
monkeypatch.setattr("services.retention.workflow_run.db_retry.time.sleep", sleep)
event.listen(sqlite_engine, "before_cursor_execute", disconnect_once)
event.listen(archive_db.session_maker.class_, "after_begin", record_session)
try:
stats = retention._get_archive_plan_prefix_stats(
archive_db.session_maker,
"a",
start_from=None,
end_before=archive_db.end_before,
)
finally:
event.remove(sqlite_engine, "before_cursor_execute", disconnect_once)
event.remove(archive_db.session_maker.class_, "after_begin", record_session)
assert stats == {
"tenant_ids": [tenant_id],
"workflow_runs": 7,
"workflow_node_executions": 9,
}
assert len(opened_sessions) == 2
assert opened_sessions[0] is not opened_sessions[1]
sleep.assert_called_once_with(1.0)
@staticmethod
def test_archive_workflow_runs_raises_click_exception_when_tenant_plan_fails(
sqlite_engine: Engine, monkeypatch: pytest.MonkeyPatch
) -> None:
registry = scoped_session(sessionmaker(bind=sqlite_engine))
monkeypatch.setattr(retention, "db", SimpleNamespace(engine=sqlite_engine, session=registry))
monkeypatch.setattr(
retention,
"_resolve_archive_tenant_ids_from_plan",
Mock(side_effect=RuntimeError("tenant plan failed")),
)
with pytest.raises(click.ClickException, match="Failed to resolve workflow archive tenant plan"):
retention.archive_workflow_runs.callback(
tenant_ids="tenant-1",
tenant_prefixes=None,
before_days=90,
from_days_ago=None,
to_days_ago=None,
start_from=None,
end_before=None,
batch_size=10000,
workers=1,
run_shard_index=None,
run_shard_total=None,
limit=None,
dry_run=True,
delete_after_archive=False,
)
@staticmethod
def test_delete_archived_workflow_runs_keeps_single_page_behavior_without_all_pages(
monkeypatch: pytest.MonkeyPatch,
):
deleter = _patch_bundle_deleter(
monkeypatch,
[_delete_summary(processed=2, succeeded=2, next_catalog_id=_CURSOR_1)],
)
result = CliRunner().invoke(
retention.delete_archived_workflow_runs,
["--target-month", "2025-03", "--limit", "2"],
)
assert result.exit_code == 0
deleter.delete_batch.assert_called_once()
assert deleter.delete_batch.call_args.kwargs["target_year"] == 2025
assert deleter.delete_batch.call_args.kwargs["target_month"] == 3
assert deleter.delete_batch.call_args.kwargs["after_catalog_id"] is None
assert deleter.delete_batch.call_args.kwargs["limit"] == 2
@staticmethod
def test_delete_archived_workflow_runs_all_pages_continues_until_empty_page(monkeypatch: pytest.MonkeyPatch):
deleter = _patch_bundle_deleter(
monkeypatch,
[
_delete_summary(processed=2, succeeded=2, next_catalog_id=_CURSOR_1),
_delete_summary(processed=1, succeeded=1, next_catalog_id=_CURSOR_2),
_delete_summary(processed=0),
],
)
result = CliRunner().invoke(
retention.delete_archived_workflow_runs,
["--target-month", "2025-03", "--all-pages", "--limit", "2"],
)
assert result.exit_code == 0
assert [call.kwargs["after_catalog_id"] for call in deleter.delete_batch.call_args_list] == [
None,
_CURSOR_1,
_CURSOR_2,
]
@staticmethod
def test_delete_archived_workflow_runs_all_pages_fetches_empty_page_after_exact_full_page(
monkeypatch: pytest.MonkeyPatch,
):
deleter = _patch_bundle_deleter(
monkeypatch,
[
_delete_summary(processed=2, succeeded=2, next_catalog_id=_CURSOR_1),
_delete_summary(processed=0),
],
)
result = CliRunner().invoke(
retention.delete_archived_workflow_runs,
["--target-month", "2025-03", "--all-pages", "--limit", "2"],
)
assert result.exit_code == 0
assert deleter.delete_batch.call_count == 2
assert deleter.delete_batch.call_args_list[1].kwargs["after_catalog_id"] == _CURSOR_1
@staticmethod
def test_delete_archived_workflow_runs_all_pages_stops_at_first_failed_page(monkeypatch: pytest.MonkeyPatch):
failed_result = BundleOperationResult(
catalog_id=_CURSOR_2,
bundle_id="bundle-failed",
tenant_id="tenant-1",
object_prefix="workflow-runs/v2/tenant-1/2025/03/00-of-16/bundle-failed",
error="archive checksum mismatch",
)
deleter = _patch_bundle_deleter(
monkeypatch,
[
_delete_summary(processed=1, succeeded=1, next_catalog_id=_CURSOR_1),
_delete_summary(processed=1, failed=1, results=[failed_result]),
_delete_summary(processed=0),
],
)
result = CliRunner().invoke(
retention.delete_archived_workflow_runs,
["--target-month", "2025-03", "--all-pages"],
)
assert result.exit_code == 1
assert deleter.delete_batch.call_count == 2
assert "target_month=2025-03" in result.output
assert f"failed_catalog_id={_CURSOR_2}" in result.output
assert f"resume_after_catalog_id={_CURSOR_1}" in result.output
@staticmethod
def test_delete_archived_workflow_runs_all_pages_fails_when_cursor_does_not_advance(
monkeypatch: pytest.MonkeyPatch,
):
deleter = _patch_bundle_deleter(
monkeypatch,
[_delete_summary(processed=1, succeeded=1, next_catalog_id=None)],
)
result = CliRunner().invoke(
retention.delete_archived_workflow_runs,
["--target-month", "2025-03", "--all-pages"],
)
assert result.exit_code == 1
deleter.delete_batch.assert_called_once()
assert "cursor did not advance" in result.output.lower()
@staticmethod
def test_delete_archived_workflow_runs_all_pages_uses_preview_cursor_for_dry_run(monkeypatch: pytest.MonkeyPatch):
deleter = _patch_bundle_deleter(
monkeypatch,
[
_delete_summary(processed=1, succeeded=1, preview_next_catalog_id=_CURSOR_1),
_delete_summary(processed=0),
],
)
result = CliRunner().invoke(
retention.delete_archived_workflow_runs,
["--target-month", "2025-03", "--all-pages", "--dry-run"],
)
assert result.exit_code == 0
assert [call.kwargs["after_catalog_id"] for call in deleter.delete_batch.call_args_list] == [
None,
_CURSOR_1,
]
@staticmethod
def test_delete_archived_workflow_runs_dry_run_failure_separates_preview_and_destructive_cursors(
monkeypatch: pytest.MonkeyPatch,
):
failed_result = BundleOperationResult(
catalog_id=_CURSOR_2,
bundle_id="bundle-failed",
tenant_id="tenant-1",
object_prefix="workflow-runs/v2/tenant-1/2025/03/00-of-16/bundle-failed",
error="archive checksum mismatch",
)
deleter = _patch_bundle_deleter(
monkeypatch,
[
_delete_summary(
processed=1,
succeeded=1,
preview_next_catalog_id=_CURSOR_1,
),
_delete_summary(
processed=1,
failed=1,
results=[failed_result],
),
],
)
result = CliRunner().invoke(
retention.delete_archived_workflow_runs,
[
"--target-month",
"2025-03",
"--after-catalog-id",
_CURSOR_0,
"--all-pages",
"--dry-run",
],
)
assert result.exit_code == 1
assert deleter.delete_batch.call_count == 2
assert f"failed_catalog_id={_CURSOR_2}" in result.output
assert f"preview_after_catalog_id={_CURSOR_1}" in result.output
assert f"destructive_retry_after_catalog_id={_CURSOR_0}" in result.output
@staticmethod
def test_delete_archived_workflow_runs_all_pages_starts_after_explicit_cursor(monkeypatch: pytest.MonkeyPatch):
deleter = _patch_bundle_deleter(monkeypatch, [_delete_summary(processed=0)])
result = CliRunner().invoke(
retention.delete_archived_workflow_runs,
[
"--target-month",
"2025-03",
"--after-catalog-id",
_CURSOR_0,
"--all-pages",
],
)
assert result.exit_code == 0
deleter.delete_batch.assert_called_once()
assert deleter.delete_batch.call_args.kwargs["after_catalog_id"] == _CURSOR_0
@staticmethod
@pytest.mark.parametrize(
"shard_args",
[
["--run-shard-index", "0"],
["--run-shard-total", "16"],
["--run-shard-index", "16", "--run-shard-total", "16"],
["--run-shard-index", "-1", "--run-shard-total", "16"],
["--run-shard-index", "0", "--run-shard-total", "0"],
["--run-shard-index", "0", "--run-shard-total", "17"],
],
)
def test_delete_archived_workflow_runs_rejects_invalid_run_shard_options(monkeypatch, shard_args):
deleter = _patch_bundle_deleter(monkeypatch, [_delete_summary(processed=0)])
result = CliRunner().invoke(
retention.delete_archived_workflow_runs,
["--target-month", "2025-03", *shard_args],
)
assert result.exit_code == 2
deleter.delete_batch.assert_not_called()
@staticmethod
def test_delete_archived_workflow_runs_passes_formatted_run_shard_to_service(monkeypatch: pytest.MonkeyPatch):
deleter = _patch_bundle_deleter(monkeypatch, [_delete_summary(processed=0)])
result = CliRunner().invoke(
retention.delete_archived_workflow_runs,
[
"--target-month",
"2025-03",
"--tenant-ids",
"tenant-1",
"--run-shard-index",
"3",
"--run-shard-total",
"16",
],
)
assert result.exit_code == 0
deleter.validate_catalog_shards.assert_called_once_with(
target_year=2025,
target_month=3,
shard_total=16,
tenant_ids=["tenant-1"],
)
deleter.delete_batch.assert_called_once()
assert deleter.delete_batch.call_args.kwargs["shard"] == "03-of-16"
@staticmethod
def test_delete_archived_workflow_runs_rejects_mixed_catalog_shards_before_delete(monkeypatch: pytest.MonkeyPatch):
deleter = _patch_bundle_deleter(monkeypatch, [_delete_summary(processed=0)])
deleter.validate_catalog_shards.side_effect = ValueError("unexpected shards: 00-of-01")
result = CliRunner().invoke(
retention.delete_archived_workflow_runs,
[
"--target-month",
"2025-03",
"--run-shard-index",
"3",
"--run-shard-total",
"16",
],
)
assert result.exit_code == 1
assert "shard preflight failed" in result.output.lower()
assert "00-of-01" in result.output
deleter.delete_batch.assert_not_called()
def _mock_service() -> MagicMock:
service = MagicMock()
service.run.return_value = {
"batches": 1,
"total_messages": 10,
"filtered_messages": 5,
"total_deleted": 5,
}
return service
def _invoke_clean_expired_messages(**kwargs: object) -> None:
callback = clean_expired_messages.callback
assert callback is not None
callback(**kwargs)
class TestCleanExpiredMessagesCases:
@staticmethod
def test_absolute_mode_calls_from_time_range() -> None:
policy = object()
service = _mock_service()
start_from = datetime.datetime(2024, 1, 1, 0, 0, 0)
end_before = datetime.datetime(2024, 2, 1, 0, 0, 0)
with (
patch("commands.retention.create_message_clean_policy", return_value=policy),
patch(
"commands.retention.MessagesCleanService.from_time_range", return_value=service
) as mock_from_time_range,
patch("commands.retention.MessagesCleanService.from_days") as mock_from_days,
):
_invoke_clean_expired_messages(
batch_size=200,
graceful_period=21,
start_from=start_from,
end_before=end_before,
from_days_ago=None,
before_days=None,
dry_run=True,
)
mock_from_time_range.assert_called_once_with(
policy=policy,
start_from=start_from,
end_before=end_before,
batch_size=200,
dry_run=True,
task_label="custom",
)
mock_from_days.assert_not_called()
@staticmethod
def test_relative_mode_before_days_only_calls_from_days() -> None:
policy = object()
service = _mock_service()
with (
patch("commands.retention.create_message_clean_policy", return_value=policy),
patch("commands.retention.MessagesCleanService.from_days", return_value=service) as mock_from_days,
patch("commands.retention.MessagesCleanService.from_time_range") as mock_from_time_range,
):
_invoke_clean_expired_messages(
batch_size=500,
graceful_period=14,
start_from=None,
end_before=None,
from_days_ago=None,
before_days=30,
dry_run=False,
)
mock_from_days.assert_called_once_with(
policy=policy,
days=30,
batch_size=500,
dry_run=False,
task_label="before-30",
)
mock_from_time_range.assert_not_called()
@staticmethod
def test_relative_mode_with_from_days_ago_calls_from_time_range() -> None:
policy = object()
service = _mock_service()
fixed_now = datetime.datetime(2024, 8, 20, 12, 0, 0)
with (
patch("commands.retention.create_message_clean_policy", return_value=policy),
patch(
"commands.retention.MessagesCleanService.from_time_range", return_value=service
) as mock_from_time_range,
patch("commands.retention.MessagesCleanService.from_days") as mock_from_days,
patch("commands.retention.naive_utc_now", return_value=fixed_now),
):
_invoke_clean_expired_messages(
batch_size=1000,
graceful_period=21,
start_from=None,
end_before=None,
from_days_ago=60,
before_days=30,
dry_run=False,
)
mock_from_time_range.assert_called_once_with(
policy=policy,
start_from=fixed_now - datetime.timedelta(days=60),
end_before=fixed_now - datetime.timedelta(days=30),
batch_size=1000,
dry_run=False,
task_label="60to30",
)
mock_from_days.assert_not_called()
@staticmethod
@pytest.mark.parametrize(
("kwargs", "message"),
[
(
{
"start_from": datetime.datetime(2024, 1, 1),
"end_before": datetime.datetime(2024, 2, 1),
"from_days_ago": None,
"before_days": 30,
},
"mutually exclusive",
),
(
{
"start_from": datetime.datetime(2024, 1, 1),
"end_before": None,
"from_days_ago": None,
"before_days": None,
},
"Both --start-from and --end-before are required",
),
(
{
"start_from": None,
"end_before": None,
"from_days_ago": 10,
"before_days": None,
},
"--from-days-ago must be used together with --before-days",
),
(
{
"start_from": None,
"end_before": None,
"from_days_ago": None,
"before_days": -1,
},
"--before-days must be >= 0",
),
(
{
"start_from": None,
"end_before": None,
"from_days_ago": 30,
"before_days": 30,
},
"--from-days-ago must be greater than --before-days",
),
(
{
"start_from": None,
"end_before": None,
"from_days_ago": None,
"before_days": None,
},
"You must provide either (--start-from,--end-before) or (--before-days [--from-days-ago])",
),
],
)
def test_invalid_inputs_raise_usage_error(kwargs: dict[str, object], message: str) -> None:
with pytest.raises(click.UsageError, match=re.escape(message)):
_invoke_clean_expired_messages(
batch_size=1000,
graceful_period=21,
start_from=kwargs["start_from"],
end_before=kwargs["end_before"],
from_days_ago=kwargs["from_days_ago"],
before_days=kwargs["before_days"],
dry_run=False,
)
@@ -0,0 +1,455 @@
import sys
import threading
import types
import uuid
from types import SimpleNamespace
from unittest.mock import MagicMock
import pytest
from sqlalchemy import event, select
from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session, scoped_session, sessionmaker
import commands
from commands import system as system_commands
from core.tools.entities.tool_entities import ApiProviderSchemaType
from enums import DeploymentEdition
from graphon.model_runtime.entities.model_entities import ModelType
from libs.db_migration_lock import LockNotOwnedError, RedisError
from models import Tenant as _reset_encrypt_key_pair_Tenant
from models.account import Account, TenantAccountJoin, TenantAccountRole
from models.account import Tenant as _fix_app_site_missing_Tenant
from models.enums import CustomizeTokenStrategy
from models.model import App, AppMode, IconType, Site
from models.provider import Provider, ProviderModel, ProviderType
from models.tools import ApiToolProvider, BuiltinToolProvider, MCPToolProvider
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.model_factories import make_tenant
def _persist_missing_site_owner(session: Session) -> tuple[Account, App]:
"""Persist an app without a Site and its complete tenant owner chain."""
tenant = _fix_app_site_missing_Tenant(name="Command workspace")
account = Account(name="Owner", email=f"owner-{uuid.uuid4()}@example.com")
membership = TenantAccountJoin(
tenant_id=tenant.id,
account_id=account.id,
current=True,
role=TenantAccountRole.OWNER,
)
app = App(
id=str(uuid.uuid4()),
tenant_id=tenant.id,
name="Missing Site App",
mode=AppMode.CHAT,
icon_type=IconType.EMOJI,
icon="chat",
icon_background="#FFFFFF",
enable_site=True,
enable_api=False,
created_by=account.id,
)
session.add_all([tenant, account, membership, app])
session.commit()
return account, app
def _site_for(app: App) -> Site:
return Site(
app_id=app.id,
title=app.name,
default_language="en-US",
customize_token_strategy=CustomizeTokenStrategy.UUID,
code=f"site-{app.id}",
)
def _bind_command_database(
monkeypatch: pytest.MonkeyPatch,
sqlite_engine: Engine,
sqlite_session_factory: sessionmaker[Session],
) -> tuple[scoped_session[Session], Session]:
"""Expose a callable real scoped session through the Flask-SQLAlchemy shape."""
command_sessions = scoped_session(sqlite_session_factory)
command_session = command_sessions()
monkeypatch.setattr(
system_commands,
"db",
SimpleNamespace(engine=sqlite_engine, session=command_sessions),
)
return command_sessions, command_session
def _run_fix_app_site_missing() -> None:
"""Invoke the command callback through a narrowed, non-optional reference."""
callback = system_commands.fix_app_site_missing.callback
assert callback is not None
callback()
def test_fix_app_site_missing_passes_loaded_session_to_signal(
monkeypatch: pytest.MonkeyPatch,
sqlite_engine: Engine,
sqlite_session: Session,
sqlite_session_factory: sessionmaker[Session],
) -> None:
account, app = _persist_missing_site_owner(sqlite_session)
command_sessions, command_session = _bind_command_database(monkeypatch, sqlite_engine, sqlite_session_factory)
phase_events: list[str] = []
event.listen(command_session, "after_commit", lambda _session: phase_events.append("commit"))
def create_site(sender: App, *, account: Account, session: Session) -> None:
phase_events.append("signal")
assert sender.id == app.id
assert account.id == account_id
assert session is command_session
session.add(_site_for(sender))
account_id = account.id
send = MagicMock(side_effect=create_site)
monkeypatch.setattr(system_commands.app_was_created, "send", send)
try:
_run_fix_app_site_missing()
finally:
command_sessions.remove()
send.assert_called_once()
assert phase_events == ["signal", "commit"]
sqlite_session.expire_all()
persisted_site = sqlite_session.query(Site).filter_by(app_id=app.id).one()
assert persisted_site.title == app.name
def test_fix_app_site_missing_rolls_back_when_signal_fails(
monkeypatch: pytest.MonkeyPatch,
sqlite_engine: Engine,
sqlite_session: Session,
sqlite_session_factory: sessionmaker[Session],
) -> None:
_account, app = _persist_missing_site_owner(sqlite_session)
command_sessions, command_session = _bind_command_database(monkeypatch, sqlite_engine, sqlite_session_factory)
phase_events: list[str] = []
event.listen(command_session, "after_rollback", lambda _session: phase_events.append("rollback"))
def fail_signal(sender: App, **_kwargs: object) -> None:
phase_events.append("signal")
# Ensure the command's next raw scan terminates while its own transaction
# still exercises the rollback path.
with sqlite_session_factory() as observer:
observer.add(_site_for(sender))
observer.commit()
raise RuntimeError("failed")
monkeypatch.setattr(system_commands.app_was_created, "send", MagicMock(side_effect=fail_signal))
try:
_run_fix_app_site_missing()
finally:
command_sessions.remove()
assert phase_events == ["signal", "rollback"]
sqlite_session.expire_all()
assert sqlite_session.get(App, app.id) is not None
"""SQLite-backed tests for the reset-encrypt-key-pair CLI command (#35396).
The command must purge every table that stores ciphertext encrypted with the
tenant's asymmetric key, otherwise stale rows cause downstream API failures
such as `/console/api/workspaces/current/tool-providers` returning 500.
Tests bind the command-owned transaction to the fixture engine and assert the
committed state rather than inspecting fabricated ``Session.execute`` calls.
"""
def _invoke_reset() -> int:
callback = commands.reset_encrypt_key_pair.callback
assert callback is not None
try:
callback()
except SystemExit as e:
return int(e.code or 0)
return 0
TENANT_ID = "11111111-1111-1111-1111-111111111111"
OTHER_TENANT_ID = "11111111-1111-1111-1111-111111111112"
USER_ID = "22222222-2222-2222-2222-222222222222"
def _tenant(tenant_id: str, *, name: str = "Test tenant") -> _reset_encrypt_key_pair_Tenant:
return make_tenant(tenant_id=tenant_id, name=name, encrypt_public_key="old-key")
def _encrypted_rows(tenant_id: str, *, suffix: str = "1") -> tuple[object, ...]:
"""Build one persisted credential-bearing row for every purge target."""
return (
Provider(tenant_id=tenant_id, provider_name=f"provider-{suffix}"),
ProviderModel(
tenant_id=tenant_id,
provider_name=f"provider-{suffix}",
model_name=f"model-{suffix}",
model_type=ModelType.LLM,
),
BuiltinToolProvider(
name=f"builtin-credential-{suffix}",
tenant_id=tenant_id,
user_id=USER_ID,
provider=f"builtin-{suffix}",
encrypted_credentials="ciphertext",
),
ApiToolProvider(
name=f"api-{suffix}",
icon="icon",
schema="{}",
schema_type_str=ApiProviderSchemaType.OPENAPI,
user_id=USER_ID,
tenant_id=tenant_id,
description="description",
tools_str="[]",
credentials_str="{}",
),
MCPToolProvider(
name=f"mcp-{suffix}",
server_identifier=f"server-{suffix}",
server_url="ciphertext",
server_url_hash=f"hash-{suffix}",
icon=None,
tenant_id=tenant_id,
user_id=USER_ID,
encrypted_credentials="ciphertext",
),
)
def _bind_command_to_sqlite(monkeypatch: pytest.MonkeyPatch, session: Session) -> None:
monkeypatch.setattr(system_commands, "db", SimpleNamespace(engine=session.get_bind()))
def test_reset_aborts_when_not_self_hosted(monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]) -> None:
apply_config_overrides(monkeypatch, DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
exit_code = _invoke_reset()
captured = capsys.readouterr()
assert exit_code == 0
assert "only for SELF_HOSTED" in captured.out
@pytest.mark.parametrize(
"sqlite_session",
[(_reset_encrypt_key_pair_Tenant, Provider, ProviderModel, BuiltinToolProvider, ApiToolProvider, MCPToolProvider)],
indirect=True,
)
def test_reset_purges_provider_and_tool_tables_for_each_tenant(
monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], sqlite_session: Session
) -> None:
"""The command must purge LLM provider rows AND every tool provider table
that stores ciphertext encrypted under the tenant key (#35396)."""
apply_config_overrides(monkeypatch, DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)
monkeypatch.setattr(system_commands, "generate_key_pair", lambda tenant_id: f"new-key-{tenant_id}")
_bind_command_to_sqlite(monkeypatch, sqlite_session)
tenant = _tenant(TENANT_ID)
other_tenant = _tenant(OTHER_TENANT_ID, name="Other tenant")
system_provider = Provider(
tenant_id=TENANT_ID,
provider_name="system-provider",
provider_type=ProviderType.SYSTEM,
)
sqlite_session.add_all((tenant, other_tenant, system_provider, *_encrypted_rows(TENANT_ID)))
sqlite_session.commit()
exit_code = _invoke_reset()
captured = capsys.readouterr()
assert exit_code == 0
assert TENANT_ID in captured.out
sqlite_session.expire_all()
tenant_after = sqlite_session.get(_reset_encrypt_key_pair_Tenant, TENANT_ID)
other_tenant_after = sqlite_session.get(_reset_encrypt_key_pair_Tenant, OTHER_TENANT_ID)
assert tenant_after is not None
assert other_tenant_after is not None
assert tenant_after.encrypt_public_key == f"new-key-{TENANT_ID}"
assert other_tenant_after.encrypt_public_key == f"new-key-{OTHER_TENANT_ID}"
assert sqlite_session.scalars(select(Provider).where(Provider.provider_type == ProviderType.CUSTOM)).all() == []
assert sqlite_session.scalars(select(ProviderModel)).all() == []
assert sqlite_session.scalars(select(BuiltinToolProvider)).all() == []
assert sqlite_session.scalars(select(ApiToolProvider)).all() == []
assert sqlite_session.scalars(select(MCPToolProvider)).all() == []
assert (
sqlite_session.scalar(select(Provider).where(Provider.provider_type == ProviderType.SYSTEM)) is system_provider
)
@pytest.mark.parametrize(
"sqlite_session",
[(_reset_encrypt_key_pair_Tenant, Provider, ProviderModel, BuiltinToolProvider, ApiToolProvider, MCPToolProvider)],
indirect=True,
)
def test_reset_iterates_all_tenants(monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:
"""Multi-tenant deployments must purge every tenant, not just the first."""
apply_config_overrides(monkeypatch, DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)
monkeypatch.setattr(system_commands, "generate_key_pair", lambda tenant_id: f"new-key-{tenant_id}")
_bind_command_to_sqlite(monkeypatch, sqlite_session)
tenant_ids = [f"11111111-1111-1111-1111-{index:012d}" for index in range(3)]
tenants = [_tenant(tenant_id, name=f"Tenant {index}") for index, tenant_id in enumerate(tenant_ids)]
for index, tenant in enumerate(tenants):
sqlite_session.add(tenant)
sqlite_session.add_all(_encrypted_rows(tenant.id, suffix=str(index)))
sqlite_session.commit()
assert _invoke_reset() == 0
sqlite_session.expire_all()
persisted_tenants = sqlite_session.scalars(
select(_reset_encrypt_key_pair_Tenant).order_by(_reset_encrypt_key_pair_Tenant.id)
).all()
assert [tenant.encrypt_public_key for tenant in persisted_tenants] == [
f"new-key-{tenant_id}" for tenant_id in tenant_ids
]
for model in (Provider, ProviderModel, BuiltinToolProvider, ApiToolProvider, MCPToolProvider):
assert sqlite_session.scalars(select(model)).all() == []
HEARTBEAT_WAIT_TIMEOUT_SECONDS = 5.0
def _install_fake_flask_migrate(monkeypatch, upgrade_impl) -> None:
module = types.ModuleType("flask_migrate")
module.upgrade = upgrade_impl
monkeypatch.setitem(sys.modules, "flask_migrate", module)
def _invoke_upgrade_db() -> int:
try:
commands.upgrade_db.callback()
except SystemExit as e:
return int(e.code or 0)
return 0
def test_upgrade_db_skips_when_lock_not_acquired(monkeypatch, capsys):
monkeypatch.setattr(system_commands, "DB_UPGRADE_LOCK_TTL_SECONDS", 1234)
lock = MagicMock()
lock.acquire.return_value = False
system_commands.redis_client.lock.return_value = lock
exit_code = _invoke_upgrade_db()
captured = capsys.readouterr()
assert exit_code == 0
assert "Database migration skipped" in captured.out
system_commands.redis_client.lock.assert_called_once_with(name="db_upgrade_lock", timeout=1234, thread_local=False)
lock.acquire.assert_called_once_with(blocking=False)
lock.release.assert_not_called()
def test_upgrade_db_failure_not_masked_by_lock_release(monkeypatch, capsys):
monkeypatch.setattr(system_commands, "DB_UPGRADE_LOCK_TTL_SECONDS", 321)
lock = MagicMock()
lock.acquire.return_value = True
lock.release.side_effect = LockNotOwnedError("simulated")
system_commands.redis_client.lock.return_value = lock
def _upgrade():
raise RuntimeError("boom")
_install_fake_flask_migrate(monkeypatch, _upgrade)
exit_code = _invoke_upgrade_db()
captured = capsys.readouterr()
assert exit_code == 1
assert "Database migration failed: boom" in captured.out
system_commands.redis_client.lock.assert_called_once_with(name="db_upgrade_lock", timeout=321, thread_local=False)
lock.acquire.assert_called_once_with(blocking=False)
lock.release.assert_called_once()
def test_upgrade_db_success_ignores_lock_not_owned_on_release(monkeypatch, capsys):
monkeypatch.setattr(system_commands, "DB_UPGRADE_LOCK_TTL_SECONDS", 999)
lock = MagicMock()
lock.acquire.return_value = True
lock.release.side_effect = LockNotOwnedError("simulated")
system_commands.redis_client.lock.return_value = lock
_install_fake_flask_migrate(monkeypatch, lambda: None)
exit_code = _invoke_upgrade_db()
captured = capsys.readouterr()
assert exit_code == 0
assert "Database migration successful!" in captured.out
system_commands.redis_client.lock.assert_called_once_with(name="db_upgrade_lock", timeout=999, thread_local=False)
lock.acquire.assert_called_once_with(blocking=False)
lock.release.assert_called_once()
def test_upgrade_db_renews_lock_during_migration(monkeypatch, capsys):
"""
Ensure the lock is renewed while migrations are running, so the base TTL can stay short.
"""
# Use a small TTL so the heartbeat interval triggers quickly.
monkeypatch.setattr(system_commands, "DB_UPGRADE_LOCK_TTL_SECONDS", 0.3)
lock = MagicMock()
lock.acquire.return_value = True
system_commands.redis_client.lock.return_value = lock
renewed = threading.Event()
def _reacquire():
renewed.set()
return True
lock.reacquire.side_effect = _reacquire
def _upgrade():
assert renewed.wait(HEARTBEAT_WAIT_TIMEOUT_SECONDS)
_install_fake_flask_migrate(monkeypatch, _upgrade)
exit_code = _invoke_upgrade_db()
_ = capsys.readouterr()
assert exit_code == 0
assert lock.reacquire.call_count >= 1
def test_upgrade_db_ignores_reacquire_errors(monkeypatch, capsys):
# Use a small TTL so heartbeat runs during the upgrade call.
monkeypatch.setattr(system_commands, "DB_UPGRADE_LOCK_TTL_SECONDS", 0.3)
lock = MagicMock()
lock.acquire.return_value = True
system_commands.redis_client.lock.return_value = lock
attempted = threading.Event()
def _reacquire():
attempted.set()
raise RedisError("simulated")
lock.reacquire.side_effect = _reacquire
def _upgrade():
assert attempted.wait(HEARTBEAT_WAIT_TIMEOUT_SECONDS)
_install_fake_flask_migrate(monkeypatch, _upgrade)
exit_code = _invoke_upgrade_db()
_ = capsys.readouterr()
assert exit_code == 0
assert lock.reacquire.call_count >= 1
@@ -0,0 +1,39 @@
from __future__ import annotations
from pathlib import Path
import pytest
from pydantic import ValidationError
from configs.extra.agent_backend_config import AgentBackendConfig
_REPOSITORY_ROOT = Path(__file__).resolve().parents[5]
_API_TIMEOUT_ENV = "AGENT_BACKEND_BINDING_FILE_DOWNLOAD_TIMEOUT_SECONDS"
_AGENT_TIMEOUT_ENV = "DIFY_AGENT_BINDING_FILE_DOWNLOAD_COMMAND_TIMEOUT_SECONDS"
def test_binding_file_download_timeout_defaults_to_240_seconds(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.delenv(_API_TIMEOUT_ENV, raising=False)
assert AgentBackendConfig().AGENT_BACKEND_BINDING_FILE_DOWNLOAD_TIMEOUT_SECONDS == 240.0
def test_binding_file_download_timeout_rejects_non_positive_values() -> None:
with pytest.raises(ValidationError):
AgentBackendConfig(AGENT_BACKEND_BINDING_FILE_DOWNLOAD_TIMEOUT_SECONDS=0)
def test_binding_file_timeout_docker_settings_use_their_service_env_files() -> None:
root_env_example = (_REPOSITORY_ROOT / "docker/.env.example").read_text(encoding="utf-8")
api_env_example = (_REPOSITORY_ROOT / "docker/envs/core-services/api.defaults").read_text(encoding="utf-8")
agent_env_example = (_REPOSITORY_ROOT / "docker/envs/core-services/dify-agent.defaults").read_text(encoding="utf-8")
compose_template = (_REPOSITORY_ROOT / "docker/docker-compose-template.yaml").read_text(encoding="utf-8")
assert f"{_API_TIMEOUT_ENV}=" not in root_env_example
assert f"{_AGENT_TIMEOUT_ENV}=" not in root_env_example
assert f"{_API_TIMEOUT_ENV}=" in api_env_example
assert f"{_AGENT_TIMEOUT_ENV}=" not in api_env_example
assert f"{_API_TIMEOUT_ENV}=" not in agent_env_example
assert f"{_AGENT_TIMEOUT_ENV}=" in agent_env_example
assert f"{_API_TIMEOUT_ENV}:" not in compose_template
assert f"{_AGENT_TIMEOUT_ENV}:" not in compose_template
@@ -0,0 +1,202 @@
from __future__ import annotations
from pathlib import Path
import pytest
from pydantic import ValidationError
from configs.app_config import DifyConfig
from configs.extra.knowledge_fs_config import KnowledgeFSConfig as _KnowledgeFSConfig
from tests.helpers.unit.configs._isolated_settings import InitSettingsOnly
class KnowledgeFSConfig(InitSettingsOnly, _KnowledgeFSConfig):
"""KnowledgeFS settings isolated from the developer's local environment."""
class _DeployedKnowledgeFSConfig(InitSettingsOnly, DifyConfig):
DEPLOY_ENV: str = "PRODUCTION"
_REPOSITORY_ROOT = Path(__file__).resolve().parents[5]
_KNOWLEDGE_FS_DOCKER_VARIABLES = (
"KNOWLEDGE_FS_ENABLED",
"KNOWLEDGE_FS_COMMUNITY_DEV_ENABLED",
"KNOWLEDGE_FS_BASE_URL",
"KNOWLEDGE_FS_LIFECYCLE_WORKER_ENABLED",
"KNOWLEDGE_FS_INTEGRATED_PROVISION_READY",
"KNOWLEDGE_FS_LEGACY_ACL_FREEZE_READY",
"KNOWLEDGE_FS_LIFECYCLE_POLL_INTERVAL_SECONDS",
"KNOWLEDGE_FS_LIFECYCLE_LEASE_SECONDS",
"KNOWLEDGE_FS_LIFECYCLE_BATCH_SIZE",
"KNOWLEDGE_FS_CAPABILITY_V2_ENABLED",
"KNOWLEDGE_FS_CAPABILITY_V2_SIGNING_KID",
"KNOWLEDGE_FS_CAPABILITY_V2_PRIVATE_KEY_PEM",
"KNOWLEDGE_FS_CAPABILITY_V2_PREVIOUS_PUBLIC_JWKS",
"KNOWLEDGE_FS_CAPABILITY_V2_ISSUER",
"KNOWLEDGE_FS_CAPABILITY_V2_AUDIENCE",
"KNOWLEDGE_FS_CAPABILITY_V2_MAX_TTL_SECONDS",
"KNOWLEDGE_FS_JWKS_CACHE_MAX_AGE_SECONDS",
"KNOWLEDGE_FS_PRODUCT_MAX_RESPONSE_BYTES",
"KNOWLEDGE_FS_RETRIEVAL_TEST_TIMEOUT_SECONDS",
"KNOWLEDGE_FS_TIMEOUT_SECONDS",
)
def test_knowledge_fs_config_normalizes_complete_connection() -> None:
config = KnowledgeFSConfig(
KNOWLEDGE_FS_ENABLED=True,
KNOWLEDGE_FS_BASE_URL=" https://knowledge-fs.test/ ",
KNOWLEDGE_FS_CAPABILITY_V2_ENABLED=True,
KNOWLEDGE_FS_CAPABILITY_V2_SIGNING_KID=" current-key ",
KNOWLEDGE_FS_CAPABILITY_V2_PRIVATE_KEY_PEM=" test-only-private-key ",
)
assert config.KNOWLEDGE_FS_BASE_URL == "https://knowledge-fs.test"
assert config.KNOWLEDGE_FS_CAPABILITY_V2_SIGNING_KID == "current-key"
assert "test-only-private-key" not in repr(config)
assert "test-only-private-key" not in config.model_dump_json()
assert config.KNOWLEDGE_FS_TIMEOUT_SECONDS == 10.0
assert config.KNOWLEDGE_FS_RETRIEVAL_TEST_TIMEOUT_SECONDS == 75.0
def test_knowledge_fs_config_treats_blank_connection_as_disabled() -> None:
config = KnowledgeFSConfig(
KNOWLEDGE_FS_BASE_URL=" ",
)
assert config.KNOWLEDGE_FS_BASE_URL is None
assert config.KNOWLEDGE_FS_ENABLED is False
def test_knowledge_fs_lifecycle_worker_is_disabled_by_default() -> None:
config = KnowledgeFSConfig()
assert config.KNOWLEDGE_FS_COMMUNITY_DEV_ENABLED is False
assert config.KNOWLEDGE_FS_LIFECYCLE_WORKER_ENABLED is False
assert config.KNOWLEDGE_FS_INTEGRATED_PROVISION_READY is False
assert config.KNOWLEDGE_FS_LEGACY_ACL_FREEZE_READY is False
assert config.KNOWLEDGE_FS_CAPABILITY_V2_ENABLED is False
def test_capability_v2_requires_private_signing_configuration_when_enabled() -> None:
with pytest.raises(ValidationError, match="signing kid and private key"):
KnowledgeFSConfig(KNOWLEDGE_FS_CAPABILITY_V2_ENABLED=True)
def test_enabled_product_runtime_accepts_capability_v2_without_the_legacy_hmac_secret() -> None:
config = KnowledgeFSConfig(
KNOWLEDGE_FS_ENABLED=True,
KNOWLEDGE_FS_BASE_URL="https://knowledge-fs.test",
KNOWLEDGE_FS_CAPABILITY_V2_ENABLED=True,
KNOWLEDGE_FS_CAPABILITY_V2_SIGNING_KID="current-key",
KNOWLEDGE_FS_CAPABILITY_V2_PRIVATE_KEY_PEM="test-only-private-key",
)
assert config.KNOWLEDGE_FS_CAPABILITY_V2_ENABLED is True
def test_disabled_capability_v2_allows_unassembled_rotation_configuration() -> None:
config = KnowledgeFSConfig(
KNOWLEDGE_FS_CAPABILITY_V2_SIGNING_KID=" future-key ",
KNOWLEDGE_FS_CAPABILITY_V2_PRIVATE_KEY_PEM=" future-pem ",
)
assert config.KNOWLEDGE_FS_CAPABILITY_V2_SIGNING_KID == "future-key"
assert config.KNOWLEDGE_FS_CAPABILITY_V2_ENABLED is False
def test_knowledge_fs_config_requires_connection_when_enabled() -> None:
with pytest.raises(ValidationError, match="base URL"):
KnowledgeFSConfig(KNOWLEDGE_FS_ENABLED=True)
def test_disabled_knowledge_fs_config_allows_partial_connection() -> None:
config = KnowledgeFSConfig(
KNOWLEDGE_FS_ENABLED=False,
KNOWLEDGE_FS_BASE_URL="https://knowledge-fs.test",
)
assert config.KNOWLEDGE_FS_ENABLED is False
def test_knowledge_fs_docker_config_is_not_shadowed_by_root_env() -> None:
root_env_example = (_REPOSITORY_ROOT / "docker/.env.example").read_text(encoding="utf-8")
api_env_example = (_REPOSITORY_ROOT / "docker/envs/core-services/api.defaults").read_text(encoding="utf-8")
for variable in _KNOWLEDGE_FS_DOCKER_VARIABLES:
assert f"{variable}=" not in root_env_example
assert f"{variable}=" in api_env_example
def test_enabled_knowledge_fs_config_requires_capability_v2() -> None:
with pytest.raises(ValidationError, match="Capability v2"):
KnowledgeFSConfig(
KNOWLEDGE_FS_ENABLED=True,
KNOWLEDGE_FS_BASE_URL="https://knowledge-fs.test",
)
@pytest.mark.parametrize("base_url", ["knowledge-fs.test", "ftp://knowledge-fs.test", "http:///missing-host"])
def test_knowledge_fs_config_rejects_non_http_absolute_urls(base_url: str) -> None:
with pytest.raises(ValidationError, match="absolute HTTP\\(S\\) URL"):
KnowledgeFSConfig(
KNOWLEDGE_FS_BASE_URL=base_url,
)
@pytest.mark.parametrize(
"base_url",
[
"https://knowledge-fs.test:notaport",
"https://knowledge-fs.test:65536",
],
)
def test_knowledge_fs_config_rejects_invalid_ports(base_url: str) -> None:
with pytest.raises(ValidationError, match="valid port"):
KnowledgeFSConfig(
KNOWLEDGE_FS_BASE_URL=base_url,
)
@pytest.mark.parametrize(
"base_url",
[
"https://user:password@knowledge-fs.test",
"https://knowledge-fs.test?region=us",
"https://knowledge-fs.test#gateway",
],
)
def test_knowledge_fs_config_rejects_unsafe_base_url_components(base_url: str) -> None:
with pytest.raises(ValidationError, match="origin without credentials, path, query, or fragment"):
KnowledgeFSConfig(
KNOWLEDGE_FS_BASE_URL=base_url,
)
@pytest.mark.parametrize("timeout_seconds", [float("inf"), float("nan"), 60.0001])
def test_knowledge_fs_config_rejects_unbounded_timeouts(timeout_seconds: float) -> None:
with pytest.raises(ValidationError):
KnowledgeFSConfig(KNOWLEDGE_FS_TIMEOUT_SECONDS=timeout_seconds)
@pytest.mark.parametrize("timeout_seconds", [60.0, 120.0001, float("inf"), float("nan")])
def test_knowledge_fs_config_rejects_unsafe_retrieval_test_timeouts(timeout_seconds: float) -> None:
with pytest.raises(ValidationError):
KnowledgeFSConfig(KNOWLEDGE_FS_RETRIEVAL_TEST_TIMEOUT_SECONDS=timeout_seconds)
def test_production_knowledge_fs_transport_requires_https() -> None:
with pytest.raises(ValidationError, match="HTTPS in production"):
_DeployedKnowledgeFSConfig(KNOWLEDGE_FS_BASE_URL="http://knowledge-fs.test")
def test_nonproduction_or_loopback_knowledge_fs_transport_allows_http() -> None:
development = _DeployedKnowledgeFSConfig(
DEPLOY_ENV="DEVELOPMENT",
KNOWLEDGE_FS_BASE_URL="http://knowledge-fs.test",
)
loopback = _DeployedKnowledgeFSConfig(KNOWLEDGE_FS_BASE_URL="http://127.0.0.1:8788")
assert development.KNOWLEDGE_FS_BASE_URL == "http://knowledge-fs.test"
assert loopback.KNOWLEDGE_FS_BASE_URL == "http://127.0.0.1:8788"
@@ -0,0 +1,25 @@
import pytest
from configs.extra.logstore_config import LogStoreConfig
from tests.helpers.unit.configs._isolated_settings import InitSettingsOnly
class _IsolatedLogStoreConfig(InitSettingsOnly, LogStoreConfig):
pass
@pytest.mark.parametrize(
("raw_value", "expected"),
[
pytest.param("true", True, id="enabled"),
pytest.param("false", False, id="disabled"),
],
)
def test_logstore_migration_flags_parse_boolean_values(raw_value: str, expected: bool) -> None:
config = _IsolatedLogStoreConfig(
LOGSTORE_DUAL_WRITE_ENABLED=raw_value,
LOGSTORE_ENABLE_PUT_GRAPH_FIELD=raw_value,
)
assert config.LOGSTORE_DUAL_WRITE_ENABLED is expected
assert config.LOGSTORE_ENABLE_PUT_GRAPH_FIELD is expected
@@ -0,0 +1,45 @@
import pytest
from configs.feature import AuthConfig, FileUploadConfig
from tests.helpers.unit.configs._isolated_settings import InitSettingsOnly
class _IsolatedAuthConfig(InitSettingsOnly, AuthConfig):
pass
def test_oauth_ttl_days_defaults_to_fourteen() -> None:
config = _IsolatedAuthConfig()
assert config.OAUTH_TTL_DAYS == 14
@pytest.mark.parametrize(
("configured", "expected"),
[("30", 30), ("1", 1), ("365", 365), ("0", 1), ("-5", 1), ("500", 365), ("invalid", 14), ("", 14)],
)
def test_oauth_ttl_days_clamps_or_falls_back_instead_of_failing(configured: str, expected: int) -> None:
config = _IsolatedAuthConfig(OAUTH_TTL_DAYS=configured)
assert expected == config.OAUTH_TTL_DAYS
class _IsolatedFileUploadConfig(InitSettingsOnly, FileUploadConfig):
pass
def test_paid_plan_file_size_limit_uses_its_default() -> None:
config = _IsolatedFileUploadConfig(UPLOAD_FILE_SIZE_LIMIT="23")
assert config.UPLOAD_FILE_SIZE_LIMIT == 23
assert config.KNOWLEDGE_UPLOAD_FILE_SIZE_LIMIT_FOR_PAID_PLAN == 15
def test_paid_plan_file_size_limit_can_be_configured_separately() -> None:
config = _IsolatedFileUploadConfig(
UPLOAD_FILE_SIZE_LIMIT="23",
KNOWLEDGE_UPLOAD_FILE_SIZE_LIMIT_FOR_PAID_PLAN="50",
)
assert config.UPLOAD_FILE_SIZE_LIMIT == 23
assert config.KNOWLEDGE_UPLOAD_FILE_SIZE_LIMIT_FOR_PAID_PLAN == 50
@@ -0,0 +1,20 @@
from configs.middleware.vdb.tidb_on_qdrant_config import TidbOnQdrantConfig
from tests.helpers.unit.configs._isolated_settings import InitSettingsOnly
class _IsolatedTidbOnQdrantConfig(InitSettingsOnly, TidbOnQdrantConfig):
pass
def test_estimated_storage_limits_default() -> None:
config = _IsolatedTidbOnQdrantConfig()
assert config.TIDB_ON_QDRANT_ESTIMATED_STORAGE_LIMITS_MB == "sandbox:60,professional:6400,team:25600"
def test_estimated_storage_limits_custom() -> None:
config = _IsolatedTidbOnQdrantConfig(
TIDB_ON_QDRANT_ESTIMATED_STORAGE_LIMITS_MB="sandbox:61,professional:6500,team:26000"
)
assert config.TIDB_ON_QDRANT_ESTIMATED_STORAGE_LIMITS_MB == "sandbox:61,professional:6500,team:26000"
@@ -0,0 +1,39 @@
import pytest
from pydantic import AliasChoices
from pydantic.fields import FieldInfo
from configs.remote_settings_sources.apollo import ApolloSettingsSource
from configs.remote_settings_sources.nacos import NacosSettingsSource
@pytest.mark.parametrize("source_cls", [NacosSettingsSource, ApolloSettingsSource])
def test_get_field_value_prefers_field_name(
source_cls: type[NacosSettingsSource] | type[ApolloSettingsSource],
) -> None:
source = object.__new__(source_cls)
source.remote_configs = {"SETTING": "direct", "ALIAS": "aliased"}
field = FieldInfo(validation_alias="ALIAS")
assert source.get_field_value(field, "SETTING") == ("direct", "SETTING", False)
@pytest.mark.parametrize("source_cls", [NacosSettingsSource, ApolloSettingsSource])
def test_get_field_value_falls_back_to_single_validation_alias(
source_cls: type[NacosSettingsSource] | type[ApolloSettingsSource],
) -> None:
source = object.__new__(source_cls)
source.remote_configs = {"ALIAS": "aliased"}
field = FieldInfo(validation_alias="ALIAS")
assert source.get_field_value(field, "SETTING") == ("aliased", "ALIAS", False)
@pytest.mark.parametrize("source_cls", [NacosSettingsSource, ApolloSettingsSource])
def test_get_field_value_falls_back_to_alias_choices_in_order(
source_cls: type[NacosSettingsSource] | type[ApolloSettingsSource],
) -> None:
source = object.__new__(source_cls)
source.remote_configs = {"SECOND_ALIAS": "second"}
field = FieldInfo(validation_alias=AliasChoices("FIRST_ALIAS", "SECOND_ALIAS"))
assert source.get_field_value(field, "SETTING") == ("second", "SECOND_ALIAS", False)
@@ -0,0 +1,49 @@
from unittest.mock import patch
import httpx
from configs.remote_settings_sources.nacos.http_request import NacosHttpClient
def _ok_response(text: str = "ok", json_data: dict[str, object] | None = None) -> httpx.Response:
request = httpx.Request("GET", "http://nacos.test")
if json_data is not None:
return httpx.Response(200, json=json_data, request=request)
return httpx.Response(200, text=text, request=request)
def test_http_request_passes_bounded_timeout() -> None:
client = NacosHttpClient()
with patch("configs.remote_settings_sources.nacos.http_request.httpx.request") as mock_request:
mock_request.return_value = _ok_response()
client.http_request("/nacos/v1/cs/configs")
timeout = mock_request.call_args.kwargs["timeout"]
assert isinstance(timeout, httpx.Timeout)
assert timeout.read is not None
assert timeout.connect is not None
def test_http_request_returns_graceful_message_on_timeout() -> None:
client = NacosHttpClient()
with patch(
"configs.remote_settings_sources.nacos.http_request.httpx.request",
side_effect=httpx.ConnectTimeout("connection timed out"),
):
result = client.http_request("/nacos/v1/cs/configs")
assert "Nacos" in result
assert "timed out" in result.lower()
def test_get_access_token_passes_bounded_timeout() -> None:
client = NacosHttpClient()
client.username = "user"
client.password = "pass"
with patch("configs.remote_settings_sources.nacos.http_request.httpx.request") as mock_request:
mock_request.return_value = _ok_response(json_data={"accessToken": "tok", "tokenTtl": 100})
token = client.get_access_token(force_refresh=True)
assert token == "tok"
timeout = mock_request.call_args.kwargs["timeout"]
assert isinstance(timeout, httpx.Timeout)
@@ -0,0 +1,438 @@
from collections.abc import Callable
from pathlib import Path
from typing import cast, override
import pytest
from flask import Flask
from packaging.version import Version
from pydantic import SecretStr, ValidationError
from pydantic_settings import BaseSettings, PydanticBaseSettingsSource
from yarl import URL
from configs.app_config import DifyConfig
from configs.deploy import IMEventTransportMode
from configs.feature import OpsTraceConfig
from enums import DeploymentEdition
def test_ops_trace_export_attempts_must_be_positive() -> None:
with pytest.raises(ValidationError, match="OPS_TRACE_EXPORT_MAX_ATTEMPTS"):
OpsTraceConfig(OPS_TRACE_EXPORT_MAX_ATTEMPTS=0)
@pytest.mark.parametrize("queue", ["", " ", "ops_trace,ops_trace_v2", "ops trace", "ops_trace\n"])
def test_ops_trace_queue_requires_one_shell_safe_queue_name(queue: str) -> None:
with pytest.raises(ValidationError, match="OPS_TRACE_QUEUE"):
OpsTraceConfig(OPS_TRACE_QUEUE=queue)
@pytest.mark.parametrize(
("value", "expected"),
[
("WEBHOOK", IMEventTransportMode.WEBHOOK),
("STREAM", IMEventTransportMode.STREAM),
],
)
def test_im_event_transport_mode_loads_both_supported_values(
value: str,
expected: IMEventTransportMode,
) -> None:
config = _make_config(HUMAN_INPUT_IM_EVENT_TRANSPORT_MODE=value)
assert config.HUMAN_INPUT_IM_EVENT_TRANSPORT_MODE is expected
assert {mode.value for mode in IMEventTransportMode} == {"WEBHOOK", "STREAM"}
def test_im_event_transport_mode_defaults_to_webhook() -> None:
assert _IsolatedDifyConfig().HUMAN_INPUT_IM_EVENT_TRANSPORT_MODE == IMEventTransportMode.WEBHOOK
def test_im_event_transport_mode_rejects_invalid_values() -> None:
with pytest.raises(ValidationError, match="HUMAN_INPUT_IM_EVENT_TRANSPORT_MODE"):
_make_config(HUMAN_INPUT_IM_EVENT_TRANSPORT_MODE="SOCKET")
class _IsolatedDifyConfig(DifyConfig):
"""Load explicit test values and packaging metadata without consulting process state."""
@classmethod
@override
def settings_customise_sources(
cls,
settings_cls: type[BaseSettings],
init_settings: PydanticBaseSettingsSource,
env_settings: PydanticBaseSettingsSource,
dotenv_settings: PydanticBaseSettingsSource,
file_secret_settings: PydanticBaseSettingsSource,
) -> tuple[PydanticBaseSettingsSource, ...]:
production_sources = super().settings_customise_sources(
settings_cls,
init_settings,
env_settings,
dotenv_settings,
file_secret_settings,
)
return init_settings, production_sources[-1]
def _make_config(**values: object) -> DifyConfig:
values.setdefault("HUMAN_INPUT_IM_EVENT_TRANSPORT_MODE", "WEBHOOK")
# Pydantic exposes a generated field-wise signature, while this helper intentionally forwards heterogeneous input.
factory = cast(Callable[..., _IsolatedDifyConfig], _IsolatedDifyConfig)
return factory(**values)
def test_skill_package_default_limit_matches_documentation() -> None:
assert _make_config().UPLOAD_SKILL_FILE_SIZE_LIMIT == 50
def test_dify_config_keeps_secret_key_empty_when_missing(tmp_path: Path) -> None:
config = _make_config(OPENDAL_FS_ROOT=str(tmp_path))
assert config.SECRET_KEY == ""
assert not hasattr(config, "OPENDAL_FS_ROOT")
assert not (tmp_path / ".dify_secret_key").exists()
def test_dify_config_preserves_explicit_secret_key(tmp_path: Path) -> None:
config = _make_config(SECRET_KEY="explicit", OPENDAL_FS_ROOT=str(tmp_path))
assert config.SECRET_KEY == "explicit"
assert not (tmp_path / ".dify_secret_key").exists()
def test_dify_config() -> None:
config = _make_config(
HTTP_REQUEST_MAX_WRITE_TIMEOUT="30",
HTTP_REQUEST_MAX_READ_TIMEOUT="300",
)
# constant values
assert config.COMMIT_SHA == ""
# default values
assert config.DEPLOYMENT_EDITION is DeploymentEdition.COMMUNITY
assert config.API_COMPRESSION_ENABLED is False
assert config.AGENT_SHELL_ENABLED is True
assert config.SENTRY_TRACES_SAMPLE_RATE == 1.0
assert config.TEMPLATE_TRANSFORM_MAX_LENGTH == 400_000
assert config.APP_MAX_EXECUTION_TIME == 3600
assert config.WORKFLOW_MAX_EXECUTION_TIME == 3600
assert config.OPS_TRACE_EXPORT_MAX_ATTEMPTS == 6
assert config.OPS_TRACE_QUEUE == "ops_trace_v2"
assert config.ENABLE_TRACE_PAYLOAD_SWEEP_TASK is True
assert config.GRAPH_ENGINE_MAX_WORKERS == 10
# annotated field with custom configured value
assert config.HTTP_REQUEST_MAX_READ_TIMEOUT == 300
# annotated field with custom configured value
assert config.HTTP_REQUEST_MAX_WRITE_TIMEOUT == 30
# values from pyproject.toml
assert Version(config.project.version) >= Version("1.0.0")
def test_dify_config_ignores_removed_trace_dispatch_settings() -> None:
removed = {
"OPS_TRACE_UNIFIED_ENABLED": "true",
"OPS_TRACE_RETRYABLE_DISPATCH_MAX_RETRIES": "780",
"OPS_TRACE_RETRYABLE_DISPATCH_DELAY_SECONDS": "5",
# Shorter than the old retry window, which used to fail startup.
"OPS_TRACE_PARENT_CONTEXT_TTL_SECONDS": "19",
}
config = _make_config(**removed)
assert not any(hasattr(config, name) for name in removed)
assert config.OPS_TRACE_EXPORT_MAX_ATTEMPTS == 6
@pytest.mark.parametrize(
("environment_value", "expected"),
[
pytest.param(None, "", id="unset"),
pytest.param("", "", id="empty"),
pytest.param("expected", "expected", id="ascii"),
pytest.param("pässwörd-🔐", "pässwörd-🔐", id="unicode"),
],
)
def test_init_password_defaults_to_empty_and_preserves_explicit_value(
environment_value: str | None,
expected: str,
) -> None:
values = {} if environment_value is None else {"INIT_PASSWORD": environment_value}
config = _make_config(**values)
assert expected == config.INIT_PASSWORD
@pytest.mark.parametrize("edition", list(DeploymentEdition))
def test_deployment_edition_accepts_every_supported_value(edition: DeploymentEdition) -> None:
config = _make_config(DEPLOYMENT_EDITION=edition.value)
assert config.DEPLOYMENT_EDITION is edition
def test_new_user_default_plugin_ids_are_parsed() -> None:
config = _make_config(
NEW_USER_DEFAULT_PLUGIN_IDS="langgenius/openai, langgenius/gemini",
)
assert config.NEW_USER_DEFAULT_PLUGIN_ID_LIST == [
"langgenius/openai",
"langgenius/gemini",
]
def test_turnstile_config_is_parsed() -> None:
config = _make_config(
TURNSTILE_SECRET_KEY=" test-secret ",
TURNSTILE_ALLOWED_HOSTNAMES="dify.dev, Login.Example.COM. ",
TURNSTILE_EMAIL_CODE_VERIFY_REQUIRED="true",
)
assert isinstance(config.TURNSTILE_SECRET_KEY, SecretStr)
assert config.TURNSTILE_SECRET_KEY.get_secret_value() == "test-secret"
assert frozenset({"dify.dev", "login.example.com"}) == config.TURNSTILE_ALLOWED_HOSTNAME_SET
assert config.TURNSTILE_EMAIL_CODE_VERIFY_REQUIRED is True
def test_email_code_login_attempt_budget_is_parsed() -> None:
config = _make_config(EMAIL_CODE_LOGIN_MAX_ATTEMPTS="7")
assert config.EMAIL_CODE_LOGIN_MAX_ATTEMPTS == 7
def test_plugin_remote_install_port_rejects_host_port_spec() -> None:
"""A 'host:port' compose publish spec must produce an actionable error, not an opaque int_parsing traceback."""
with pytest.raises(ValueError, match="must be a bare port number"):
_make_config(PLUGIN_REMOTE_INSTALL_PORT="127.0.0.1:5003")
def test_plugin_remote_install_port_accepts_bare_port() -> None:
config = _make_config(PLUGIN_REMOTE_INSTALL_PORT="5003")
assert config.PLUGIN_REMOTE_INSTALL_PORT == 5003
def test_new_user_default_models_are_parsed() -> None:
config = _make_config(
NEW_USER_DEFAULT_MODELS=(
"llm:langgenius/openai/openai:gpt-4o-mini, "
"text-embedding:langgenius/openai/openai:text-embedding-3-small, "
"rerank:langgenius/ollama/ollama:reranker:latest"
),
)
assert config.NEW_USER_DEFAULT_MODEL_LIST == [
("llm", "langgenius/openai/openai", "gpt-4o-mini"),
("text-embedding", "langgenius/openai/openai", "text-embedding-3-small"),
("rerank", "langgenius/ollama/ollama", "reranker:latest"),
]
def test_new_user_default_models_reject_duplicate_model_types() -> None:
config = _make_config(
NEW_USER_DEFAULT_MODELS=(
"llm:langgenius/openai/openai:gpt-4o-mini,llm:langgenius/anthropic/anthropic:claude-sonnet-4"
),
)
with pytest.raises(ValueError, match="duplicate model type: llm"):
_ = config.NEW_USER_DEFAULT_MODEL_LIST
def test_http_timeout_defaults() -> None:
"""Test that HTTP timeout defaults are correctly set"""
config = _make_config()
# Verify default timeout values
assert config.HTTP_REQUEST_MAX_CONNECT_TIMEOUT == 10
assert config.HTTP_REQUEST_MAX_READ_TIMEOUT == 600
assert config.HTTP_REQUEST_MAX_WRITE_TIMEOUT == 600
def test_internal_files_url_falls_back_to_server_console_api_url() -> None:
config = _make_config(SERVER_CONSOLE_API_URL="http://api:5001")
assert config.INTERNAL_FILES_URL == "http://api:5001"
def test_internal_files_url_prefers_explicit_value() -> None:
config = _make_config(
INTERNAL_FILES_URL="http://files-internal:5001",
SERVER_CONSOLE_API_URL="http://api:5001",
)
assert config.INTERNAL_FILES_URL == "http://files-internal:5001"
def test_empty_files_url_overrides_console_api_url_for_relative_browser_uris() -> None:
config = _make_config(FILES_URL="", CONSOLE_API_URL="http://api:5001")
assert config.FILES_URL == ""
def test_flask_configs() -> None:
flask_app = Flask("app")
flask_app.config.from_mapping(
_make_config(
CONSOLE_API_URL="https://example.com",
CONSOLE_WEB_URL="https://example.com",
DB_TYPE="postgresql",
DB_USERNAME="postgres",
DB_PASSWORD="postgres",
DB_HOST="localhost",
DB_PORT="5432",
DB_DATABASE="dify",
WEB_API_CORS_ALLOW_ORIGINS="http://127.0.0.1:3000,*",
CODE_EXECUTION_ENDPOINT="http://127.0.0.1:8194/",
).model_dump()
)
config = flask_app.config
# configs read from pydantic-settings
assert config["LOG_LEVEL"] == "INFO"
assert config["COMMIT_SHA"] == ""
assert config["DEPLOYMENT_EDITION"] is DeploymentEdition.COMMUNITY
assert config["API_COMPRESSION_ENABLED"] is False
assert config["SENTRY_TRACES_SAMPLE_RATE"] == 1.0
# value from env file
assert config["CONSOLE_API_URL"] == "https://example.com"
# fallback to alias choices value as CONSOLE_API_URL
assert config["FILES_URL"] == "https://example.com"
assert config["SQLALCHEMY_DATABASE_URI"] == "postgresql://postgres:postgres@localhost:5432/dify"
assert config["SQLALCHEMY_ENGINE_OPTIONS"] == {
"connect_args": {
"options": "-c timezone=UTC",
},
"max_overflow": 10,
"pool_pre_ping": False,
"pool_recycle": 3600,
"pool_size": 30,
"pool_use_lifo": False,
"pool_timeout": 30,
"pool_reset_on_return": "rollback",
}
assert config["CONSOLE_WEB_URL"] == "https://example.com"
assert config["CONSOLE_CORS_ALLOW_ORIGINS"] == ["https://example.com"]
assert config["WEB_API_CORS_ALLOW_ORIGINS"] == ["http://127.0.0.1:3000", "*"]
assert str(config["CODE_EXECUTION_ENDPOINT"]) == "http://127.0.0.1:8194/"
assert str(URL(str(config["CODE_EXECUTION_ENDPOINT"])) / "v1") == "http://127.0.0.1:8194/v1"
def test_inner_api_config_exist() -> None:
config = _make_config(INNER_API_KEY="test-inner-api-key")
assert config.INNER_API is False
assert isinstance(config.INNER_API_KEY, str)
assert len(config.INNER_API_KEY) > 0
def test_db_extras_options_merging() -> None:
"""Test that DB_EXTRAS options are merged with the default timezone startup option."""
config = _make_config(DB_EXTRAS="options=-c search_path=myschema")
options = config.SQLALCHEMY_ENGINE_OPTIONS["connect_args"]["options"]
assert "search_path=myschema" in options
assert "timezone=UTC" in options
def test_db_session_timezone_override_can_disable_app_level_timezone_injection() -> None:
config = _make_config(
DB_EXTRAS="options=-c search_path=myschema",
DB_SESSION_TIMEZONE_OVERRIDE="",
)
assert config.SQLALCHEMY_ENGINE_OPTIONS["connect_args"] == {
"options": "-c search_path=myschema",
}
def test_pubsub_redis_url_default() -> None:
config = _make_config(
REDIS_HOST="redis.example.com",
REDIS_PORT="6380",
REDIS_USERNAME="user",
REDIS_PASSWORD="pass@word",
REDIS_DB="2",
REDIS_USE_SSL="true",
)
assert config.normalized_pubsub_redis_url == "rediss://user:pass%40word@redis.example.com:6380/2"
assert config.PUBSUB_REDIS_CHANNEL_TYPE == "pubsub"
def test_pubsub_redis_url_override() -> None:
config = _make_config(PUBSUB_REDIS_URL="redis://pubsub-host:6381/5")
assert config.normalized_pubsub_redis_url == "redis://pubsub-host:6381/5"
def test_pubsub_redis_url_required_when_default_unavailable() -> None:
config = _make_config(REDIS_HOST="")
with pytest.raises(ValueError, match="PUBSUB_REDIS_URL must be set"):
_ = config.normalized_pubsub_redis_url
def test_dify_config_exposes_redis_key_prefix_default() -> None:
config = _make_config()
assert config.REDIS_KEY_PREFIX == ""
def test_dify_config_accepts_redis_key_prefix() -> None:
config = _make_config(REDIS_KEY_PREFIX="enterprise-a")
assert config.REDIS_KEY_PREFIX == "enterprise-a"
@pytest.mark.parametrize(
("broker_url", "expected_host", "expected_port", "expected_username", "expected_password", "expected_db"),
[
("redis://localhost:6379/1", "localhost", 6379, None, None, "1"),
("redis://:password@localhost:6379/1", "localhost", 6379, None, "password", "1"),
("redis://:mypass%23123@localhost:6379/1", "localhost", 6379, None, "mypass#123", "1"),
("redis://user:pass%40word@redis-host:6380/2", "redis-host", 6380, "user", "pass@word", "2"),
("redis://admin:complex%23pass%40word@127.0.0.1:6379/0", "127.0.0.1", 6379, "admin", "complex#pass@word", "0"),
(
"redis://user%40domain:secret%23123@redis.example.com:6380/3",
"redis.example.com",
6380,
"user@domain",
"secret#123",
"3",
),
# Password containing %23 substring (double encoding scenario)
("redis://:mypass%2523@localhost:6379/1", "localhost", 6379, None, "mypass%23", "1"),
# Username and password both containing encoded characters
("redis://user%2525%40:pass%2523@localhost:6379/1", "localhost", 6379, "user%25@", "pass%23", "1"),
],
)
def test_celery_broker_url_with_special_chars_password(
broker_url: str,
expected_host: str,
expected_port: int,
expected_username: str | None,
expected_password: str | None,
expected_db: str,
) -> None:
"""Test that CELERY_BROKER_URL with various formats are handled correctly."""
from kombu.utils.url import parse_url
config = _make_config(CELERY_BROKER_URL=broker_url)
assert broker_url == config.CELERY_BROKER_URL
# Test actual parsing behavior using kombu's parse_url (same as production)
redis_config = parse_url(config.CELERY_BROKER_URL)
# Verify the parsing results match expectations (using kombu's field names)
assert redis_config["hostname"] == expected_host
assert redis_config["port"] == expected_port
assert redis_config["userid"] == expected_username # kombu uses 'userid' not 'username'
assert redis_config["password"] == expected_password
assert redis_config["virtual_host"] == expected_db # kombu uses 'virtual_host' not 'db'
@@ -0,0 +1,425 @@
from __future__ import annotations
import os
import shutil
from collections.abc import Callable, Iterator
from pathlib import Path
from tempfile import TemporaryDirectory
from threading import Lock
from typing import TYPE_CHECKING
from unittest.mock import MagicMock, create_autospec, patch
from weakref import WeakKeyDictionary
# Ensure OpenDAL fs writes to tmp to avoid polluting workspace
os.environ.setdefault("OPENDAL_SCHEME", "fs")
os.environ.setdefault("OPENDAL_FS_ROOT", "/tmp/dify-storage")
os.environ.setdefault("STORAGE_TYPE", "opendal")
import pytest
from dify_trace_sdk.testing import RecordingEgress
from flask import Flask
from redis import Redis
from sqlalchemy import create_engine, event
from sqlalchemy.engine import URL, Engine
from sqlalchemy.orm import Session, sessionmaker
import core.db.session_factory as session_factory_module
from extensions import ext_redis
from models.account import Account, Tenant, TenantAccountJoin, TenantAccountRole
from models.base import TypeBase
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.rbac_fakes import RBACDomain, build_rbac_domain
from tests.helpers.unit.services.tracing_ports import deployment_provider_configs
if TYPE_CHECKING:
from extensions.ext_application_services import ApplicationServices
from tests.helpers.unit.account_domain import AccountDomain
# Getting the absolute path of the current file's directory
ABS_PATH = os.path.dirname(os.path.abspath(__file__))
# Getting the absolute path of the project's root directory
PROJECT_DIR = os.path.abspath(os.path.join(ABS_PATH, os.pardir, os.pardir))
CACHED_APP = Flask(__name__)
pytest_plugins = (
"tests.helpers.unit.audio_runtime_fixtures",
"tests.helpers.unit.agent_runtime_fixtures",
"tests.helpers.unit.model_provider_fixtures",
)
# set global mock for Redis client
redis_mock = MagicMock()
redis_mock.get = MagicMock(return_value=None)
redis_mock.setex = MagicMock()
redis_mock.setnx = MagicMock()
redis_mock.delete = MagicMock()
redis_mock.lock = MagicMock()
redis_mock.exists = MagicMock(return_value=False)
redis_mock.set = MagicMock()
redis_mock.expire = MagicMock()
redis_mock.hgetall = MagicMock(return_value={})
redis_mock.hdel = MagicMock()
redis_mock.incr = MagicMock(return_value=1)
# pytest 9.2's monkeypatch undo deletes a mock child that isn't in the mock's __dict__. Keep every Redis
# method there, so a test that patches one leaves it in place for the tests after it.
for _name in {*dir(ext_redis.RedisClientWrapper), *dir(Redis)}:
if not _name.startswith("_"):
setattr(redis_mock, _name, getattr(redis_mock, _name)) # guard-ignore: no-new-getattr -- names come from dir()
if TYPE_CHECKING:
from extensions.application_services.app import AppServices
from services.tag_application_service import TagApplicationService
def _patch_redis_clients_on_loaded_modules() -> None:
"""Ensure any module-level redis_client references point to the shared redis_mock."""
import sys
for module in list(sys.modules.values()):
if module is None:
continue
for client_attribute in ("redis_client", "_pubsub_redis_client"):
if hasattr(module, client_attribute):
setattr(module, client_attribute, redis_mock)
@pytest.fixture
def redis_transport(monkeypatch: pytest.MonkeyPatch) -> Iterator[tuple[ext_redis.RedisClientWrapper, MagicMock]]:
"""Exercise the wrapper and Redis command builders with network dispatch replaced."""
apply_config_overrides(monkeypatch, REDIS_KEY_PREFIX="")
with Redis() as client, patch.object(client, "execute_command", return_value=None) as commands:
wrapper = ext_redis.RedisClientWrapper()
wrapper.initialize(client)
yield wrapper, commands
@pytest.fixture
def tenant_queue_commands(
redis_transport: tuple[ext_redis.RedisClientWrapper, MagicMock], monkeypatch: pytest.MonkeyPatch
) -> MagicMock:
"""Run tenant queue serialization and command building without Redis I/O."""
from core.rag.pipeline import queue
redis, commands = redis_transport
monkeypatch.setattr(queue, "redis_client", redis)
return commands
@pytest.fixture
def app() -> Flask:
return CACHED_APP
@pytest.fixture(autouse=True)
def _provide_app_context(app: Flask) -> Iterator[None]:
with app.app_context():
yield
@pytest.fixture(autouse=True)
def _patch_redis_clients() -> Iterator[None]:
"""Patch and rebind loaded Redis clients to the shared mock for each unit test."""
with (
patch.object(ext_redis, "redis_client", redis_mock),
patch.object(ext_redis, "_pubsub_redis_client", redis_mock),
):
_patch_redis_clients_on_loaded_modules()
yield
@pytest.fixture(autouse=True)
def reset_redis_mock(_patch_redis_clients: None) -> None:
"""Reset the shared Redis mock after per-test client rebinding."""
# ``mock_calls`` records calls on every attached child and return value, so when it is empty the
# recursive reset has nothing to clear. Most tests never touch Redis; skip walking ~370 child mocks.
if redis_mock.mock_calls:
redis_mock.reset_mock()
# Restoring a monkeypatched method can leave it detached from the parent's reset traversal.
redis_mock.delete.reset_mock()
redis_mock.get.reset_mock()
redis_mock.setex.reset_mock()
redis_mock.setnx.reset_mock()
redis_mock.lock.reset_mock(return_value=True, side_effect=True)
redis_mock.exists.reset_mock()
redis_mock.set.reset_mock()
redis_mock.expire.reset_mock()
redis_mock.hgetall.reset_mock()
redis_mock.hdel.reset_mock()
redis_mock.incr.reset_mock()
redis_mock.get.return_value = None
redis_mock.setex.return_value = None
redis_mock.setnx.return_value = None
redis_mock.delete.return_value = None
redis_mock.exists.return_value = False
redis_mock.set.return_value = None
redis_mock.expire.return_value = None
redis_mock.hgetall.return_value = dict[bytes, bytes]()
redis_mock.hdel.return_value = None
redis_mock.incr.return_value = 1
@pytest.fixture(autouse=True)
def reset_secret_key(monkeypatch: pytest.MonkeyPatch) -> None:
"""Ensure SECRET_KEY-dependent logic sees an empty config value by default."""
apply_config_overrides(monkeypatch, SECRET_KEY="")
@pytest.fixture
def config_overrides(monkeypatch: pytest.MonkeyPatch) -> Callable[..., None]:
"""Temporarily override fields on the shared typed application config.
Application modules import the same config instance, so mutating known
field names keeps tests scoped without replacing that instance with an
unconstrained mock. ``monkeypatch`` restores every value after the test.
"""
def apply(**values: object) -> None:
apply_config_overrides(monkeypatch, **values)
return apply
# The callable that materializes each live ``_sqlite_engine``'s database file.
_sqlite_copiers: WeakKeyDictionary[Engine, Callable[[], None]] = WeakKeyDictionary()
def _copy_sqlite_template(template: Path, database_path: Path, lock: Lock) -> None:
"""Create ``database_path`` as a copy of ``template`` unless it already exists.
Idempotent and safe across threads sharing ``lock``: the copy happens at most once, so an
open connection never sees its file overwritten.
"""
with lock:
if not database_path.exists():
shutil.copyfile(template, database_path)
@pytest.fixture
def _sqlite_engine(_sqlite_database_template: Path) -> Iterator[Engine]:
"""Copy the schema into an isolated directory without pytest's numbered scan.
``tmp_path`` searches all preceding test directories for a free number. This
autouse dependency needs only a unique, disposable directory, including any
SQLite journal files, so keep it separate from test-owned ``tmp_path`` data.
Most tests never connect, so the schema is copied on the engine's first connection
rather than for every test. Code that opens the file without this engine must go
through ``sqlite_engine``, which copies it up front.
"""
with TemporaryDirectory(prefix="case-", dir=_sqlite_database_template.parent) as directory:
database_path = Path(directory) / "unit-tests.sqlite3"
engine = create_engine(URL.create("sqlite", database=str(database_path)))
lock = Lock()
def copy() -> None:
_copy_sqlite_template(_sqlite_database_template, database_path, lock)
event.listen(engine, "do_connect", lambda *_args: copy())
_sqlite_copiers[engine] = copy
try:
yield engine
finally:
engine.dispose()
@pytest.fixture(scope="session")
def _sqlite_database_template(tmp_path_factory: pytest.TempPathFactory) -> Path:
"""Create one empty full-schema SQLite database per pytest worker."""
database_path = tmp_path_factory.mktemp("sqlite-template") / "unit-tests.sqlite3"
engine = create_engine(URL.create("sqlite", database=str(database_path)))
try:
TypeBase.metadata.create_all(engine)
finally:
engine.dispose()
return database_path
@pytest.fixture(autouse=True)
def _sqlite_session_factory(
_sqlite_engine: Engine,
monkeypatch: pytest.MonkeyPatch,
) -> sessionmaker[Session]:
"""Bind all unit-test Sessions to the pristine full-schema SQLite database."""
factory = sessionmaker(bind=_sqlite_engine, expire_on_commit=False)
monkeypatch.setattr(session_factory_module, "_session_maker", factory)
return factory
@pytest.fixture
def _unbound_session_factory(
_sqlite_session_factory: sessionmaker[Session],
monkeypatch: pytest.MonkeyPatch,
) -> sessionmaker[Session]:
"""Create one unbound factory and install it as the global test factory."""
factory = sessionmaker()
monkeypatch.setattr(session_factory_module, "_session_maker", factory)
return factory
@pytest.fixture
def sqlite_engine(_sqlite_engine: Engine) -> Engine:
"""Expose the pristine full-schema SQLite engine to tests.
The database file exists on return, so tests may hand ``sqlite_engine.url`` to code
that opens it with an engine of its own.
"""
_sqlite_copiers[_sqlite_engine]()
return _sqlite_engine
@pytest.fixture
def sqlite_session_factory(_sqlite_session_factory: sessionmaker[Session]) -> sessionmaker[Session]:
"""Expose the shared SQLite session factory to tests."""
return _sqlite_session_factory
@pytest.fixture
def sqlite_session(_sqlite_session_factory: sessionmaker[Session]) -> Iterator[Session]:
"""Yield a session over the pristine full-schema SQLite database.
Legacy indirect model parameters remain accepted by pytest but are ignored.
Remove those decorators as their test files receive individual review.
"""
with _sqlite_session_factory() as session:
yield session
@pytest.fixture
def unbound_session_factory(_unbound_session_factory: sessionmaker[Session]) -> sessionmaker[Session]:
"""Expose an unbound factory for paths that must not require persistence."""
return _unbound_session_factory
@pytest.fixture
def unbound_session(_unbound_session_factory: sessionmaker[Session]) -> Iterator[Session]:
"""Yield an unbound Session for paths that must not require persistence.
Bind-requiring database access fails, while bind-free Session operations can
still succeed.
"""
with _unbound_session_factory() as session:
yield session
def persist_service_api_tenant_owner(session: Session, tenant: Tenant, owner: Account) -> TenantAccountJoin:
"""Persist the owner identity resolved by service-API app authentication.
The legacy name is retained temporarily for consumers on independent
conversion branches, but this helper no longer fabricates an execute result.
"""
membership = TenantAccountJoin(
tenant_id=tenant.id,
account_id=owner.id,
role=TenantAccountRole.OWNER,
)
owner._current_tenant = tenant
session.add_all([tenant, owner, membership])
session.commit()
return membership
def persist_service_api_dataset_owner(
session: Session,
tenant: Tenant,
tenant_account_join: TenantAccountJoin,
) -> None:
"""Persist the tenant-owner mapping resolved by dataset-token authentication."""
session.add_all([tenant, tenant_account_join])
session.commit()
@pytest.fixture
def account_domain(
sqlite_session_factory: sessionmaker[Session],
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
) -> AccountDomain:
from blinker import Signal
from enums import DeploymentEdition
from services.workspace import gateways
from tests.helpers.unit.account_domain import build_account_domain
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY, RBAC_ENABLED=False)
monkeypatch.setattr(gateways, "generate_key_pair", lambda _workspace_id: "public-key")
monkeypatch.setattr(gateways, "tenant_was_created", Signal())
return build_account_domain(sqlite_session_factory)
@pytest.fixture
def account_application_services(
sqlite_session_factory: sessionmaker[Session], account_domain: AccountDomain
) -> ApplicationServices:
from dataclasses import replace
from enums import DeploymentEdition
from extensions.ext_application_services import build_application_services
from extensions.ext_redis import RedisClientWrapper
services = build_application_services(
database_client=sqlite_session_factory,
deployment_edition=DeploymentEdition.COMMUNITY,
initialization_password="",
redis=create_autospec(RedisClientWrapper, instance=True),
)
return replace(
services,
accounts=replace(services.accounts, lifecycle=account_domain.accounts),
workspaces=replace(
services.workspaces,
members=account_domain.members,
provisioning=account_domain.provisioning,
invitations=account_domain.invitations,
),
)
@pytest.fixture
def rbac_domain(sqlite_session_factory: sessionmaker[Session], monkeypatch: pytest.MonkeyPatch) -> RBACDomain:
return build_rbac_domain(sqlite_session_factory, monkeypatch)
@pytest.fixture
def app_services(sqlite_session_factory: sessionmaker[Session], rbac_domain: RBACDomain) -> AppServices:
from unittest.mock import Mock
from extensions.application_services.app import build_app_services
from extensions.ext_application_services import _build_oauth_server_service
from extensions.ext_redis import redis_client
from repositories.app.console_repository import ConsoleAppRepository
from repositories.app.tracing_config_repository import SQLAlchemyAppTracingConfigRepository
from services.app_tracing_config_service import AppTracingConfigService
from services.recommended_app_package_service import RecommendedAppPackageService
return build_app_services(
database_client=sqlite_session_factory,
repository=ConsoleAppRepository(session_factory=sqlite_session_factory),
rbac_members=rbac_domain.rbac.members,
tracing_configs=AppTracingConfigService(
configs=SQLAlchemyAppTracingConfigRepository(session_factory=sqlite_session_factory),
# Unit tests never reach a tracing vendor; an unexpected request fails the test.
provider=deployment_provider_configs(RecordingEgress([], grpc_target=None)),
),
oauth=_build_oauth_server_service(database_client=sqlite_session_factory, redis=redis_client),
recommended_packages=RecommendedAppPackageService(sources=Mock(), exporter=Mock()),
)
@pytest.fixture
def application_tags(sqlite_session_factory: sessionmaker[Session]) -> TagApplicationService:
from repositories.tag_repository import TagRepository
from services.tag_application_service import TagApplicationService
return TagApplicationService(tags=TagRepository(sqlite_session_factory))
@@ -0,0 +1,28 @@
import importlib
import pytest
import constants
from configs import dify_config
from tests.helpers.unit.config_override import apply_config_overrides
@pytest.mark.parametrize("etl_type", ["SelfHosted", "Unstructured"])
def test_document_extensions_include_odt_for_document_etl_modes(monkeypatch: pytest.MonkeyPatch, etl_type: str) -> None:
original_etl_type = dify_config.ETL_TYPE
original_unstructured_api_url = dify_config.UNSTRUCTURED_API_URL
try:
apply_config_overrides(monkeypatch, ETL_TYPE=etl_type, UNSTRUCTURED_API_URL=None)
reloaded_constants = importlib.reload(constants)
assert "odt" in reloaded_constants.DOCUMENT_EXTENSIONS
assert "ODT" in reloaded_constants.DOCUMENT_EXTENSIONS
finally:
apply_config_overrides(
monkeypatch,
ETL_TYPE=original_etl_type,
UNSTRUCTURED_API_URL=original_unstructured_api_url,
)
importlib.reload(constants)
@@ -0,0 +1,348 @@
"""Tests for execution context module."""
import contextvars
import threading
from contextlib import contextmanager, nullcontext, suppress
from typing import Any
from unittest.mock import MagicMock
import pytest
from pydantic import BaseModel
from context.execution_context import (
AppContext,
ExecutionContext,
ExecutionContextBuilder,
IExecutionContext,
NullAppContext,
read_context,
register_context,
)
class TestNullAppContext:
"""Test NullAppContext implementation."""
def test_null_app_context_get_config(self):
"""Test get_config returns value from config dict."""
config = {"key1": "value1", "key2": "value2"}
ctx = NullAppContext(config=config)
assert ctx.get_config("key1") == "value1"
assert ctx.get_config("key2") == "value2"
def test_null_app_context_get_config_default(self):
"""Test get_config returns default when key not found."""
ctx = NullAppContext()
assert ctx.get_config("nonexistent", "default") == "default"
assert ctx.get_config("nonexistent") is None
def test_null_app_context_get_extension(self):
"""Test get_extension returns stored extension."""
ctx = NullAppContext()
extension = MagicMock()
ctx.set_extension("db", extension)
assert ctx.get_extension("db") == extension
def test_null_app_context_get_extension_not_found(self):
"""Test get_extension returns None when extension not found."""
ctx = NullAppContext()
assert ctx.get_extension("nonexistent") is None
def test_null_app_context_enter_yield(self):
"""Test enter method yields without any side effects."""
ctx = NullAppContext()
with ctx.enter():
# Should not raise any exception
pass
class TestExecutionContext:
"""Test ExecutionContext class."""
def test_initialization_with_all_params(self):
"""Test ExecutionContext initialization with all parameters."""
app_ctx = NullAppContext()
context_vars = contextvars.copy_context()
user = MagicMock()
ctx = ExecutionContext(
app_context=app_ctx,
context_vars=context_vars,
user=user,
)
assert ctx.app_context == app_ctx
assert ctx.context_vars == context_vars
assert ctx.user == user
def test_initialization_with_minimal_params(self):
"""Test ExecutionContext initialization with minimal parameters."""
ctx = ExecutionContext()
assert ctx.app_context is None
assert ctx.context_vars is None
assert ctx.user is None
@pytest.mark.parametrize("use_enter", [False, True])
@pytest.mark.parametrize("caller_value", [None, "caller"])
@pytest.mark.parametrize("raise_error", [False, True])
def test_enter_with_context_vars(self, use_enter, caller_value, raise_error):
"""Restore the caller's binding, including an unset variable, on every exit."""
test_var = contextvars.ContextVar("test_var")
context_vars = contextvars.Context()
context_vars.run(test_var.set, "captured")
ctx = ExecutionContext(context_vars=context_vars)
token = test_var.set(caller_value) if caller_value is not None else None
try:
with pytest.raises(ValueError, match="body failed") if raise_error else nullcontext():
with ctx.enter() if use_enter else ctx:
assert test_var.get() == "captured"
test_var.set("body")
if raise_error:
raise ValueError("body failed")
assert test_var.get(None) == caller_value
assert (test_var in contextvars.copy_context()) == (caller_value is not None)
finally:
if token is not None:
test_var.reset(token)
@pytest.mark.parametrize(("outer_enter", "inner_enter"), [(False, False), (False, True), (True, False)])
def test_nested_context_restores_each_scope(self, outer_enter, inner_enter):
test_var = contextvars.ContextVar("nested_var")
captured = contextvars.Context()
captured.run(test_var.set, "captured")
ctx = ExecutionContext(context_vars=captured)
with ctx.enter() if outer_enter else ctx:
assert test_var.get() == "captured"
test_var.set("outer")
with ctx.enter() if inner_enter else ctx:
assert test_var.get() == "captured"
test_var.set("inner")
assert test_var.get() == "outer"
assert test_var not in contextvars.copy_context()
def test_enter_with_app_context(self):
"""Test enter enters app context if available."""
app_ctx = NullAppContext()
ctx = ExecutionContext(app_context=app_ctx)
# Should not raise any exception
with ctx.enter():
pass
def test_enter_without_app_context(self):
"""Test enter works without app context."""
ctx = ExecutionContext(app_context=None)
# Should not raise any exception
with ctx.enter():
pass
def test_context_manager_protocol(self):
"""Test ExecutionContext supports context manager protocol."""
ctx = ExecutionContext()
with ctx:
# Should not raise any exception
pass
def test_user_property(self):
"""Test user property returns set user."""
user = MagicMock()
ctx = ExecutionContext(user=user)
assert ctx.user == user
def test_thread_safe_context_manager(self):
"""Test shared ExecutionContext works across threads without token mismatch."""
test_var = contextvars.ContextVar("thread_safe_test_var")
class TrackingAppContext(AppContext):
def get_config(self, key: str, default: Any = None) -> Any:
return default
def get_extension(self, name: str) -> Any:
return None
@contextmanager
def enter(self):
token = test_var.set(threading.get_ident())
try:
yield
finally:
test_var.reset(token)
ctx = ExecutionContext(app_context=TrackingAppContext())
errors: list[Exception] = []
barrier = threading.Barrier(2)
def worker():
try:
for _ in range(20):
with ctx:
try:
barrier.wait()
barrier.wait()
except threading.BrokenBarrierError:
return
except Exception as exc:
errors.append(exc)
with suppress(Exception):
barrier.abort()
t1 = threading.Thread(target=worker)
t2 = threading.Thread(target=worker)
t1.start()
t2.start()
t1.join(timeout=5)
t2.join(timeout=5)
assert not errors
class TestIExecutionContextProtocol:
"""Test IExecutionContext protocol."""
def test_execution_context_implements_protocol(self):
"""Test that ExecutionContext implements IExecutionContext protocol."""
ctx = ExecutionContext()
# Should have __enter__ and __exit__ methods
assert hasattr(ctx, "__enter__")
assert hasattr(ctx, "__exit__")
assert hasattr(ctx, "user")
def test_protocol_compatibility(self):
"""Test that ExecutionContext can be used where IExecutionContext is expected."""
def accept_context(context: IExecutionContext) -> Any:
"""Function that accepts IExecutionContext protocol."""
# Just verify it has the required protocol attributes
assert hasattr(context, "__enter__")
assert hasattr(context, "__exit__")
assert hasattr(context, "user")
return context.user
ctx = ExecutionContext(user="test_user")
result = accept_context(ctx)
assert result == "test_user"
def test_protocol_with_flask_execution_context(self):
"""Test that IExecutionContext protocol is compatible with different implementations."""
# Verify the protocol works with ExecutionContext
ctx = ExecutionContext(user="test_user")
# Should have the required protocol attributes
assert hasattr(ctx, "__enter__")
assert hasattr(ctx, "__exit__")
assert hasattr(ctx, "user")
assert ctx.user == "test_user"
# Should work as context manager
with ctx:
assert ctx.user == "test_user"
class TestExecutionContextBuilder:
"""Test ExecutionContextBuilder class."""
def test_builder_with_all_params(self):
"""Test builder with all parameters set."""
app_ctx = NullAppContext()
context_vars = contextvars.copy_context()
user = MagicMock()
ctx = (
ExecutionContextBuilder().with_app_context(app_ctx).with_context_vars(context_vars).with_user(user).build()
)
assert ctx.app_context == app_ctx
assert ctx.context_vars == context_vars
assert ctx.user == user
def test_builder_with_partial_params(self):
"""Test builder with only some parameters set."""
app_ctx = NullAppContext()
ctx = ExecutionContextBuilder().with_app_context(app_ctx).build()
assert ctx.app_context == app_ctx
assert ctx.context_vars is None
assert ctx.user is None
def test_builder_fluent_interface(self):
"""Test builder provides fluent interface."""
builder = ExecutionContextBuilder()
# Each method should return the builder
assert isinstance(builder.with_app_context(NullAppContext()), ExecutionContextBuilder)
assert isinstance(builder.with_context_vars(contextvars.copy_context()), ExecutionContextBuilder)
assert isinstance(builder.with_user(None), ExecutionContextBuilder)
class TestCaptureCurrentContext:
"""Test capture_current_context function."""
def test_capture_current_context_returns_context(self):
"""Test that capture_current_context returns a valid context."""
from context.execution_context import capture_current_context
result = capture_current_context()
# Should return an object that implements IExecutionContext
assert hasattr(result, "__enter__")
assert hasattr(result, "__exit__")
assert hasattr(result, "user")
def test_capture_current_context_captures_contextvars(self):
"""Test that capture_current_context captures context variables."""
# Set a context variable before capturing
import contextvars
test_var = contextvars.ContextVar("capture_test_var")
test_var.set("test_value_123")
from context.execution_context import capture_current_context
result = capture_current_context()
# Context variables should be captured
assert result.context_vars is not None
class TestTenantScopedContextRegistry:
def setup_method(self):
from context import reset_context_provider
reset_context_provider()
def teardown_method(self):
from context import reset_context_provider
reset_context_provider()
def test_tenant_provider_read_ok(self):
class SandboxContext(BaseModel):
base_url: str | None = None
register_context("workflow.sandbox", "t1", lambda: SandboxContext(base_url="http://t1"))
register_context("workflow.sandbox", "t2", lambda: SandboxContext(base_url="http://t2"))
assert read_context("workflow.sandbox", tenant_id="t1").base_url == "http://t1"
assert read_context("workflow.sandbox", tenant_id="t2").base_url == "http://t2"
def test_missing_provider_raises_keyerror(self):
from context import ContextProviderNotFoundError
with pytest.raises(ContextProviderNotFoundError):
read_context("missing", tenant_id="unknown")
@@ -0,0 +1,295 @@
"""Tests for Flask app context module."""
import contextvars
from contextlib import nullcontext
import pytest
from flask import Flask, current_app, g
from flask_sqlalchemy import SQLAlchemy
from models.account import Account
@pytest.fixture
def flask_app() -> Flask:
app = Flask(__name__)
app.config.update(TEST_KEY="test_value", TEST="value", SQLALCHEMY_DATABASE_URI="sqlite://")
SQLAlchemy(app)
return app
class TestFlaskAppContext:
"""Test FlaskAppContext implementation."""
def test_flask_app_context_initialization(self, flask_app):
"""Test FlaskAppContext initialization."""
# Import here to avoid Flask dependency in test environment
from context.flask_app_context import FlaskAppContext
ctx = FlaskAppContext(flask_app)
assert ctx.flask_app == flask_app
def test_flask_app_context_get_config(self, flask_app):
"""Test get_config returns Flask app config value."""
from context.flask_app_context import FlaskAppContext
ctx = FlaskAppContext(flask_app)
assert ctx.get_config("TEST_KEY") == "test_value"
def test_flask_app_context_get_config_default(self, flask_app):
"""Test get_config returns default when key not found."""
from context.flask_app_context import FlaskAppContext
ctx = FlaskAppContext(flask_app)
assert ctx.get_config("NONEXISTENT", "default") == "default"
def test_flask_app_context_get_extension(self, flask_app):
"""Test get_extension returns Flask extension."""
from context.flask_app_context import FlaskAppContext
ctx = FlaskAppContext(flask_app)
db_ext = flask_app.extensions["sqlalchemy"]
assert ctx.get_extension("sqlalchemy") == db_ext
def test_flask_app_context_get_extension_not_found(self, flask_app):
"""Test get_extension returns None when extension not found."""
from context.flask_app_context import FlaskAppContext
ctx = FlaskAppContext(flask_app)
assert ctx.get_extension("nonexistent") is None
def test_flask_app_context_enter(self, flask_app):
"""Test enter method enters Flask app context."""
from context.flask_app_context import FlaskAppContext
ctx = FlaskAppContext(flask_app)
with ctx.enter():
assert current_app._get_current_object() is flask_app
class TestFlaskExecutionContext:
"""Test FlaskExecutionContext class."""
def test_initialization(self, flask_app):
"""Test FlaskExecutionContext initialization."""
from context.flask_app_context import FlaskExecutionContext
context_vars = contextvars.copy_context()
user = Account(name="user-123", email="user-123@example.com")
ctx = FlaskExecutionContext(
flask_app=flask_app,
context_vars=context_vars,
user=user,
)
assert ctx.context_vars == context_vars
assert ctx.user == user
def test_app_context_property(self, flask_app):
"""Test app_context property returns FlaskAppContext."""
from context.flask_app_context import FlaskAppContext, FlaskExecutionContext
ctx = FlaskExecutionContext(
flask_app=flask_app,
context_vars=contextvars.copy_context(),
)
assert isinstance(ctx.app_context, FlaskAppContext)
assert ctx.app_context.flask_app == flask_app
def test_context_manager_protocol(self, flask_app):
"""Test FlaskExecutionContext supports context manager protocol."""
from context.flask_app_context import FlaskExecutionContext
ctx = FlaskExecutionContext(
flask_app=flask_app,
context_vars=contextvars.copy_context(),
)
# Should have __enter__ and __exit__ methods
assert hasattr(ctx, "__enter__")
assert hasattr(ctx, "__exit__")
# Should work as context manager
with ctx:
pass
class TestCaptureFlaskContext:
"""Test capture_flask_context against real Flask proxies."""
def test_capture_flask_context_captures_app(self, flask_app):
from context.flask_app_context import capture_flask_context
with flask_app.app_context():
ctx = capture_flask_context()
with ctx:
assert current_app._get_current_object() is flask_app
def test_capture_flask_context_captures_user_from_g(self, flask_app):
from context.flask_app_context import capture_flask_context
user = Account(name="user_123", email="user_123@example.com")
with flask_app.app_context():
g._login_user = user
ctx = capture_flask_context()
assert ctx.user is user
def test_capture_flask_context_with_explicit_user(self, flask_app):
from context.flask_app_context import capture_flask_context
explicit_user = Account(name="user_456", email="user_456@example.com")
with flask_app.app_context():
g._login_user = Account(name="other_user", email="other_user@example.com")
ctx = capture_flask_context(user=explicit_user)
assert ctx.user is explicit_user
def test_capture_flask_context_captures_contextvars(self, flask_app):
from context.flask_app_context import capture_flask_context
test_var = contextvars.ContextVar("test_var")
token = test_var.set("test_value")
try:
with flask_app.app_context():
ctx = capture_flask_context()
assert ctx.context_vars[test_var] == "test_value"
finally:
test_var.reset(token)
class TestFlaskExecutionContextIntegration:
"""Integration tests for FlaskExecutionContext."""
@pytest.mark.parametrize("use_enter", [False, True])
@pytest.mark.parametrize("caller_value", [None, "caller"])
@pytest.mark.parametrize("raise_error", [False, True])
def test_enter_restores_context_vars(self, flask_app, use_enter, caller_value, raise_error):
"""Restore the caller's binding on normal and exceptional exits."""
test_var = contextvars.ContextVar("integration_test_var")
context_vars = contextvars.Context()
context_vars.run(test_var.set, "captured")
from context.flask_app_context import FlaskExecutionContext
ctx = FlaskExecutionContext(
flask_app=flask_app,
context_vars=context_vars,
)
token = test_var.set(caller_value) if caller_value is not None else None
try:
with pytest.raises(ValueError, match="body failed") if raise_error else nullcontext():
with ctx.enter() if use_enter else ctx:
assert test_var.get() == "captured"
test_var.set("body")
if raise_error:
raise ValueError("body failed")
assert test_var.get(None) == caller_value
assert (test_var in contextvars.copy_context()) == (caller_value is not None)
finally:
if token is not None:
test_var.reset(token)
@pytest.mark.parametrize(("outer_enter", "inner_enter"), [(False, False), (False, True), (True, False)])
def test_nested_context_restores_each_scope(self, outer_enter, inner_enter):
from context.flask_app_context import FlaskExecutionContext
flask_app = Flask(__name__)
caller_app = current_app._get_current_object()
caller_g = g._get_current_object()
test_var = contextvars.ContextVar("nested_var")
captured = contextvars.copy_context()
captured.run(test_var.set, "captured")
ctx = FlaskExecutionContext(flask_app=flask_app, context_vars=captured)
with ctx.enter() if outer_enter else ctx:
assert current_app == flask_app
test_var.set("outer")
outer_g = g._get_current_object()
with ctx.enter() if inner_enter else ctx:
assert current_app == flask_app
assert g._get_current_object() is not outer_g
assert test_var.get() == "captured"
test_var.set("inner")
assert g._get_current_object() is outer_g
assert test_var.get() == "outer"
assert test_var not in contextvars.copy_context()
assert current_app == caller_app
assert g._get_current_object() is caller_g
@pytest.mark.parametrize("use_enter", [False, True])
@pytest.mark.parametrize("failure_stage", ["enter", "teardown"])
def test_context_vars_restored_when_flask_context_fails(self, flask_app, monkeypatch, use_enter, failure_stage):
from context.flask_app_context import FlaskExecutionContext
test_var = contextvars.ContextVar("failure_var")
captured = contextvars.Context()
captured.run(test_var.set, "captured")
ctx = FlaskExecutionContext(flask_app=flask_app, context_vars=captured)
def fail_context(_exception=None):
raise ValueError("context failed")
with monkeypatch.context() as patch:
method = "app_context" if failure_stage == "enter" else "do_teardown_appcontext"
patch.setattr(flask_app, method, fail_context)
with pytest.raises(ValueError, match="context failed"), ctx.enter() if use_enter else ctx:
assert test_var.get() == "captured"
assert test_var not in contextvars.copy_context()
with ctx:
assert test_var.get() == "captured"
assert test_var not in contextvars.copy_context()
def test_enter_enters_flask_app_context(self, flask_app):
"""Test that enter enters Flask app context."""
from context.flask_app_context import FlaskExecutionContext
ctx = FlaskExecutionContext(
flask_app=flask_app,
context_vars=contextvars.copy_context(),
)
with ctx:
# Verify app context was entered
assert current_app._get_current_object() is flask_app
def test_enter_restores_user_in_g(self, flask_app):
"""The explicit user is restored into the new Flask app context."""
from context.flask_app_context import FlaskExecutionContext
user = Account(name="test_user", email="test_user@example.com")
ctx = FlaskExecutionContext(
flask_app=flask_app,
context_vars=contextvars.copy_context(),
user=user,
)
with ctx:
assert g._login_user is user
assert ctx.user is user
def test_enter_method_as_context_manager(self, flask_app):
"""Test enter method returns a proper context manager."""
from context.flask_app_context import FlaskExecutionContext
ctx = FlaskExecutionContext(
flask_app=flask_app,
context_vars=contextvars.copy_context(),
)
# enter() should return a generator/context manager
with ctx.enter():
assert current_app._get_current_object() is flask_app
Whitespace-only changes.
@@ -0,0 +1,144 @@
"""Guard against resource-scoped RBAC gates mounted on routes their locator can't read.
Every RBAC gate is declared as one or more explicit ``RBACCheck(scene, Locator(...))``
bundles, via ``rbac_permission_required(RBACCheck(...), ...)`` or
``console_account_admission(rbac_checks=[RBACCheck(...), ...])``. Each locator reads a
path parameter — its explicit ``param`` argument, or its class default (``PlainApp`` reads
``app_id``, ``DatasetId`` reads ``dataset_id``, etc.; ``Workspace`` reads none). A route
whose URL doesn't carry that parameter can never resolve the check.
This check runs against the registered namespaces rather than the source text: both
decorators record their checks on the view function under ``RBAC_CHECKS_ATTR``, and reading
them back at runtime also covers resources built by a factory (the RBAC access-permission
endpoints in ``controllers/console/workspace/rbac.py``), which no AST scan can see.
"""
from __future__ import annotations
from collections.abc import Iterator
import pytest
import controllers.console # noqa: F401 -- importing the package registers every console route
import controllers.openapi # noqa: F401 -- same for the user-scoped OpenAPI routes
from controllers.common.rbac import RBAC_CHECKS_ATTR, DatasetId, RBACCheck, RBACPermission
from controllers.common.rbac.checks import InvalidRBACCheckError
from controllers.console import console_ns
from controllers.openapi import openapi_ns
NAMESPACES = (console_ns, openapi_ns)
HTTP_METHODS = ("delete", "get", "head", "options", "patch", "post", "put")
KNOWN_VIOLATIONS: set[tuple[str, str]] = set()
def test_mismatched_permission_scope_is_a_configuration_error() -> None:
with pytest.raises(InvalidRBACCheckError, match="locates dataset"):
RBACCheck(RBACPermission.APP_DELETE, DatasetId())
# The generated access-permission endpoints, spelled out here so this guard fails loudly if
# the factory stops registering them (or renames a URL) rather than silently checking less.
RBAC_ACCESS_RESOURCE_PARTS = (("apps", "app_id"), ("datasets", "dataset_id"), ("agents", "agent_id"))
def _rbac_access_urls() -> set[str]:
urls: set[str] = set()
for segment, id_param in RBAC_ACCESS_RESOURCE_PARTS:
resource = f"/workspaces/current/rbac/{segment}/<uuid:{id_param}>"
workspace = f"/workspaces/current/rbac/workspace/{segment}"
urls.update(
{
f"{resource}/access-policy",
f"{resource}/whitelist",
f"{resource}/whitelist_config",
f"{resource}/user-access-policies",
f"{resource}/users/<uuid:target_account_id>/access-policies",
f"{resource}/access-policies/<uuid:policy_id>/role-bindings",
f"{resource}/access-policies/<string:policy_id>/member-bindings",
f"{workspace}/access-policy",
f"{workspace}/access-policies/<uuid:policy_id>/role-bindings",
f"{workspace}/access-policies/<uuid:policy_id>/bindings",
f"{workspace}/access-policies/<uuid:policy_id>/member-bindings",
}
)
return urls
def _class_attribute(resource: type, name: str) -> object | None:
"""Look up ``name`` on ``resource`` through the MRO without ``getattr``."""
for klass in resource.__mro__:
attributes = vars(klass)
if name in attributes:
return attributes[name]
return None
def _declared_checks(view: object) -> list[RBACCheck]:
"""Collect the RBAC checks a decorator recorded anywhere in this view's wrapper chain.
``functools.wraps`` copies the recorded tuple onto every outer wrapper, so the same
bundle shows up at several levels; identity tells the copies apart from a second gate.
"""
checks: list[RBACCheck] = []
seen: set[int] = set()
current = view
while current is not None:
attributes = vars(current)
recorded = attributes.get(RBAC_CHECKS_ATTR)
if recorded and id(recorded) not in seen:
seen.add(id(recorded))
checks.extend(recorded)
current = attributes.get("__wrapped__")
return checks
def _path_args(route: str) -> set[str]:
return {segment.split(">")[0].split(":")[-1] for segment in route.split("<")[1:]}
def _registered_methods() -> Iterator[tuple[type, str, object, tuple[str, ...]]]:
"""Yield ``(resource class, method name, view function, urls)`` for every routed method."""
for namespace in NAMESPACES:
for route in namespace.resources:
for method_name in HTTP_METHODS:
view = _class_attribute(route.resource, method_name)
if view is None:
continue
yield route.resource, method_name, view, tuple(route.urls)
def test_resource_scoped_rbac_gates_have_a_resource_id_in_the_route() -> None:
violations = []
for resource, method_name, view, urls in _registered_methods():
if (resource.__name__, method_name) in KNOWN_VIOLATIONS:
continue
for check in _declared_checks(view):
# Only ``_ParamLocator`` subclasses store a path parameter; ``Workspace`` reads none.
required_param = vars(check.locator).get("param")
if not isinstance(required_param, str):
continue
unscoped = [url for url in urls if required_param not in _path_args(url)]
if unscoped:
violations.append(
f"{resource.__name__}.{method_name} "
f"locator={type(check.locator).__name__}({required_param!r}) "
f"scene={check.scene} routes={unscoped}"
)
assert not violations, "RBACCheck locator on a route that doesn't carry its required path parameter:\n" + "\n".join(
violations
)
def test_guard_reaches_the_generated_rbac_access_endpoints() -> None:
"""The factory-built endpoints are the reason this guard is runtime-based; prove it sees them."""
scanned_urls = {url for _, _, _, urls in _registered_methods() for url in urls}
missing = sorted(_rbac_access_urls() - scanned_urls)
assert not missing, "generated RBAC access routes are not reachable by this guard:\n" + "\n".join(missing)
@@ -0,0 +1,220 @@
"""HTTP resource resolution uses composed queries and request-local snapshots."""
import pytest
from flask import Flask
from sqlalchemy import Engine, event, text
from werkzeug.exceptions import Forbidden, NotFound
from configs import dify_config
from controllers.common.errors import InvalidArgumentError
from controllers.common.rbac import locators
from controllers.common.rbac.checks import RBACCheck, enforce_rbac_checks
from core.rbac import RBACPermission, RBACResourceScope
from models.agent import Agent, AgentScope, AgentSource, AgentStatus
from models.model import AppMode
from tests.helpers.unit.model_factories import make_app, make_dataset, make_document
from tests.helpers.unit.rbac_fakes import RBACDomain
@pytest.fixture(autouse=True)
def services(monkeypatch: pytest.MonkeyPatch, rbac_domain: RBACDomain) -> None:
monkeypatch.setattr(locators, "application_services", lambda: rbac_domain)
@pytest.mark.parametrize(
"locator",
[
locators.PlainApp(),
locators.AgentBehindApp(),
locators.AgentId(),
locators.DatasetId(),
locators.DatasetByDocument(),
locators.DatasetByPipeline(),
],
)
def test_missing_resource_parameter_is_an_explicit_input_error(locator: locators.ResourceLocator) -> None:
with pytest.raises(InvalidArgumentError, match="Missing .* in request path") as raised:
locator.locate("workspace", {})
assert raised.value.code == 400
assert raised.value.error_code == "invalid_param"
@pytest.mark.parametrize("scope", [AgentScope.ROSTER, AgentScope.WORKFLOW_ONLY])
@pytest.mark.parametrize("status", [AgentStatus.ACTIVE, AgentStatus.ARCHIVED])
def test_agent_app_resolution_preserves_scope_and_archived_bindings(
app: Flask, rbac_domain: RBACDomain, scope: AgentScope, status: AgentStatus
) -> None:
with rbac_domain.sessions.begin() as session:
session.add(make_app(app_id="app", tenant_id="workspace", mode=AppMode.AGENT))
session.add(
Agent(
id="agent",
tenant_id="workspace",
name="Agent",
scope=scope,
source=AgentSource.AGENT_APP if scope == AgentScope.ROSTER else AgentSource.WORKFLOW,
app_id="app" if scope == AgentScope.ROSTER else "workflow",
backing_app_id="app" if scope == AgentScope.WORKFLOW_ONLY else None,
status=status,
)
)
with app.test_request_context():
assert locators.PlainApp().locate("workspace", {"app_id": "app"}) is None
assert locators.AgentBehindApp().locate("workspace", {"app_id": "app"}) == (
locators.ResourceIdentity(RBACResourceScope.AGENT, "agent") if scope == AgentScope.ROSTER else None
)
def test_binding_cache_is_tenant_scoped_and_expires_with_request(
app: Flask, rbac_domain: RBACDomain, sqlite_engine: Engine
) -> None:
with rbac_domain.sessions.begin() as session:
session.add(make_app(app_id="app", tenant_id="workspace", mode=AppMode.AGENT))
queries: list[str] = []
def record_query(
_connection: object, _cursor: object, statement: str, _parameters: object, _context: object, _executemany: bool
) -> None:
queries.append(statement)
event.listen(sqlite_engine, "before_cursor_execute", record_query)
try:
with app.app_context(), app.test_request_context():
assert locators.agent_binding("workspace", "app") is None
reads = len(queries)
assert reads > 0
assert locators.agent_binding("workspace", "app") is None
assert len(queries) == reads
assert locators.agent_binding("other-workspace", "app") is None
assert len(queries) > reads
with rbac_domain.sessions.begin() as session:
session.add(
Agent(
id="agent",
tenant_id="workspace",
name="Agent",
scope=AgentScope.ROSTER,
source=AgentSource.AGENT_APP,
app_id="app",
status=AgentStatus.ACTIVE,
)
)
with app.app_context(), app.test_request_context():
binding = locators.agent_binding("workspace", "app")
assert binding is not None
assert binding.id == "agent"
assert locators.agent_binding("other-workspace", "app") is None
finally:
event.remove(sqlite_engine, "before_cursor_execute", record_query)
@pytest.mark.parametrize("normal", [True, False])
def test_app_owner_resolution_preserves_normal_app_requirement(
app: Flask, rbac_domain: RBACDomain, normal: bool
) -> None:
with rbac_domain.sessions.begin() as session:
session.add(make_app(app_id="app", tenant_id="workspace", maintainer="owner"))
if not normal:
session.flush()
session.execute(text("UPDATE apps SET status = 'disabled' WHERE id = 'app'"))
with app.test_request_context():
locator = locators.PlainApp()
identity = locators.ResourceIdentity(RBACResourceScope.APP, "app")
assert locator.owner_id("workspace", identity) == ("owner" if normal else None)
assert locator.owner_id("other-workspace", identity) is None
@pytest.mark.parametrize("status", [AgentStatus.ACTIVE, AgentStatus.ARCHIVED])
def test_agent_owner_resolution_is_workspace_scoped(rbac_domain: RBACDomain, status: AgentStatus) -> None:
with rbac_domain.sessions.begin() as session:
session.add(
Agent(
id="agent",
tenant_id="workspace",
name="Agent",
scope=AgentScope.ROSTER,
source=AgentSource.AGENT_APP,
created_by="owner",
status=status,
)
)
locator = locators.AgentId()
identity = locators.ResourceIdentity(RBACResourceScope.AGENT, "agent")
assert locator.owner_id("workspace", identity) == ("owner" if status == AgentStatus.ACTIVE else None)
assert locator.owner_id("other-workspace", identity) is None
assert locator.owner_id("workspace", locators.ResourceIdentity(RBACResourceScope.AGENT, "missing")) is None
@pytest.mark.parametrize(
("workspace_id", "account_id", "is_owner"),
[("workspace", "owner", True), ("workspace", "other", False), ("other-workspace", "owner", False)],
)
def test_agent_creator_bypasses_rbac_only_in_own_workspace(
app: Flask,
rbac_domain: RBACDomain,
monkeypatch: pytest.MonkeyPatch,
workspace_id: str,
account_id: str,
is_owner: bool,
) -> None:
monkeypatch.setattr(dify_config, "RBAC_ENABLED", True)
rbac_domain.transport.response = {"allowed": False}
with rbac_domain.sessions.begin() as session:
session.add(
Agent(
id="agent",
tenant_id="workspace",
name="Agent",
scope=AgentScope.ROSTER,
source=AgentSource.AGENT_APP,
created_by="owner",
)
)
with app.test_request_context():
if is_owner:
enforce_rbac_checks(
tenant_id=workspace_id,
account_id=account_id,
checks=[RBACCheck(RBACPermission.AGENT_PREVIEW, locators.AgentId())],
path_args={"agent_id": "agent"},
)
assert not rbac_domain.transport.requests
else:
with pytest.raises(Forbidden):
enforce_rbac_checks(
tenant_id=workspace_id,
account_id=account_id,
checks=[RBACCheck(RBACPermission.AGENT_PREVIEW, locators.AgentId())],
path_args={"agent_id": "agent"},
)
assert rbac_domain.transport.only_request.json == {
"tenant_id": workspace_id,
"account_id": account_id,
"scene": "agent_preview",
"resource_type": "agent",
"resource_id": "agent",
}
@pytest.mark.parametrize("locator", [locators.DatasetByDocument(), locators.DatasetByPipeline()])
def test_nested_dataset_resolution_checks_ownership_and_maps_missing_resources(
app: Flask, rbac_domain: RBACDomain, locator: locators.DatasetByDocument | locators.DatasetByPipeline
) -> None:
with rbac_domain.sessions.begin() as session:
dataset = make_dataset(dataset_id="dataset", tenant_id="workspace", maintainer="owner")
dataset.pipeline_id = "pipeline"
session.add(dataset)
session.add(make_document(document_id="document", dataset_id="dataset", tenant_id="workspace"))
args = {"document_id": "document", "pipeline_id": "pipeline"}
with app.test_request_context():
identity = locator.locate("workspace", args)
assert identity is not None
assert identity == locators.ResourceIdentity(RBACResourceScope.DATASET, "dataset")
assert locator.owner_id("workspace", identity) == "owner"
assert locator.owner_id("other-workspace", identity) is None
with pytest.raises(NotFound):
locator.locate("other-workspace", args)
with pytest.raises(NotFound):
locator.locate("workspace", {"document_id": "missing", "pipeline_id": "missing"})
@@ -0,0 +1,627 @@
"""Final Flask response contracts; token/execution boundaries are isolated, MCP identities are SQLite rows."""
import io
import json
import logging
from collections.abc import Buffer, Generator, Iterator
from contextlib import contextmanager
from typing import Literal, Never, override
from unittest.mock import MagicMock
import pytest
from flask import Blueprint, Flask, Response, jsonify, request
from flask.testing import FlaskClient
from flask_restx import Namespace, Resource
from pytest_mock import MockerFixture
from sqlalchemy import event
from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session, object_session, sessionmaker
from werkzeug.exceptions import NotFound, Unauthorized
import controllers.service_api.wraps as token_wraps
import controllers.trigger.trigger as plugin_trigger
import services.api_token_service as token_service
from controllers.common.access_response import (
MCP_ERROR_BODY_LIMIT,
MISSING_BEARER_MESSAGE,
mcp_server_not_found_response,
register_auth_error_response,
)
from controllers.mcp import mcp
from controllers.trigger import webhook
from extensions import ext_request_logging
from extensions.ext_redis import RedisClientWrapper
from libs.external_api import ExternalApi
from models.engine import db
from models.model import ApiToken, App, AppMCPServer, AppMode
from services.app.mcp_server_service import AppMCPServerStatus
from tests.helpers.unit.config_override import apply_config_overrides
type TokenClient = tuple[FlaskClient, MagicMock, MagicMock, MagicMock]
def _mcp_server(app_id: str, server_code: str) -> AppMCPServer:
server = AppMCPServer(
app_id=app_id,
tenant_id="tenant",
status=AppMCPServerStatus.ACTIVE,
name="Fixture",
description="",
server_code=server_code,
parameters="{}",
)
server.id = "server"
return server
def _app(app_id: str, tenant_id: str) -> App:
return App(id=app_id, tenant_id=tenant_id, name="Fixture", mode=AppMode.CHAT, enable_site=False, enable_api=True)
def _persist(session: Session, *rows: App | AppMCPServer) -> None:
session.add_all(rows)
session.commit()
@contextmanager
def _sqlite_writes(engine: Engine) -> Generator[list[str]]:
"""Collect the INSERT/UPDATE/DELETE statements issued while the block runs."""
writes: list[str] = []
def record_write(
_connection: object,
_cursor: object,
statement: str,
_parameters: object,
_context: object,
_executemany: bool,
) -> None:
if statement.lstrip().upper().startswith(("INSERT", "UPDATE", "DELETE")):
writes.append(statement)
event.listen(engine, "before_cursor_execute", record_write)
try:
yield writes
finally:
event.remove(engine, "before_cursor_execute", record_write)
type MCPClient = tuple[FlaskClient, MagicMock, MagicMock]
@pytest.fixture
def http_app(sqlite_engine: Engine) -> Flask:
app = Flask(__name__)
app.config.update(TESTING=True, RESTX_ERROR_404_HELP=False, SQLALCHEMY_DATABASE_URI=sqlite_engine.url)
db.init_app(app)
return app
@pytest.fixture
def token_client(http_app: Flask, mocker: MockerFixture) -> TokenClient:
bp = Blueprint("service_test", __name__, url_prefix="/v1")
register_auth_error_response(bp, www_authenticate='Bearer realm="api"')
api = ExternalApi(bp)
class TokenResource(Resource):
def get(self) -> dict[str, bool]:
token_wraps.validate_and_get_api_token("app")
return {"ok": True}
api.add_resource(TokenResource, "/info")
http_app.register_blueprint(bp)
other = Blueprint("other_test", __name__, url_prefix="/other")
other_api = ExternalApi(other)
class OtherResource(Resource):
def get(self) -> Never:
raise Unauthorized("Other API authentication")
other_api.add_resource(OtherResource, "/info")
http_app.register_blueprint(other)
cache_get = mocker.patch.object(token_wraps.ApiTokenCache, "get", return_value=None)
fetch = mocker.patch.object(
token_wraps,
"fetch_token_with_single_flight",
side_effect=token_service.ApiTokenInvalidError("Access token is invalid"),
)
usage = mocker.patch.object(token_wraps, "record_token_usage")
return http_app.test_client(), cache_get, fetch, usage
@pytest.mark.parametrize(
"header",
[
None,
"",
"Bearer",
"Bearer ",
"Bearer\t",
" ",
"Basic abc",
"Bearer a b",
"Bearer\xa0valid-token",
"Bearer\x1cvalid-token",
"Bearer\vvalid-token",
"Bearer\u2003valid-token",
],
)
def test_bad_bearer_final_response_never_looks_up_or_records_token(
token_client: TokenClient, header: str | None
) -> None:
client, cache_get, fetch, usage = token_client
response = client.get("/v1/info", headers={} if header is None else {"Authorization": header})
assert response.status_code == 401
expected = {"code": "unauthorized", "message": MISSING_BEARER_MESSAGE, "status": 401}
assert response.data == json.dumps(expected, separators=(",", ":"), sort_keys=True).encode()
assert response.headers["Content-Type"] == "application/json"
assert response.headers["Cache-Control"] == "no-store"
assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'
cache_get.assert_not_called()
fetch.assert_not_called()
usage.assert_not_called()
def test_invalid_token_final_response_and_no_usage(token_client: TokenClient) -> None:
client, _cache_get, fetch, usage = token_client
response = client.get("/v1/info", headers={"Authorization": "Bearer missing-token"})
assert response.status_code == 401
assert response.data == b'{"code":"unauthorized","message":"Access token is invalid","status":401}'
assert response.headers["Content-Type"] == "application/json"
assert response.headers["Cache-Control"] == "no-store"
assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'
fetch.assert_called_once_with("missing-token", "app")
usage.assert_not_called()
def test_invalid_token_database_path_does_not_record_usage(http_app: Flask, mocker: MockerFixture) -> None:
usage = mocker.patch.object(token_service, "record_token_usage")
mocker.patch.object(token_service.ApiTokenCache, "set")
with http_app.app_context():
with pytest.raises(token_service.ApiTokenInvalidError, match="Access token is invalid"):
token_service.query_token_from_db("missing-token", "app")
usage.assert_not_called()
@pytest.fixture
def uncached_token_client(
http_app: Flask, redis_transport: tuple[RedisClientWrapper, MagicMock]
) -> Iterator[tuple[FlaskClient, MagicMock]]:
"""Run real token lookup and error translation, replacing only Redis network dispatch."""
redis, commands = redis_transport
def execute(command: str, *_args: object, **_kwargs: object) -> bool | None:
return True if command in {"SET", "EVALSHA"} else None
commands.side_effect = execute
previous_redis = token_service.redis_client
token_service.redis_client = redis
bp = Blueprint("uncached_service_test", __name__, url_prefix="/v1")
register_auth_error_response(bp, www_authenticate='Bearer realm="api"')
api = ExternalApi(bp)
class AppTokenResource(Resource):
@token_wraps.validate_app_token
def get(self, app_model: App) -> Never:
pytest.fail(f"Invalid credentials reached the handler for app {app_model.id}")
class DatasetTokenResource(Resource):
@token_wraps.validate_dataset_token
def get(self, tenant_id: str) -> Never:
pytest.fail(f"Invalid credentials reached the dataset handler for tenant {tenant_id}")
api.add_resource(AppTokenResource, "/app")
api.add_resource(DatasetTokenResource, "/dataset")
http_app.register_blueprint(bp)
try:
yield http_app.test_client(), commands
finally:
token_service.redis_client = previous_redis
with http_app.app_context():
db.session.remove()
db.engine.dispose()
@pytest.mark.parametrize("scope", ["app", "dataset"])
@pytest.mark.parametrize("authorization", [None, "Bearer missing-token"])
def test_real_token_errors_preserve_http_response_contract(
uncached_token_client: tuple[FlaskClient, MagicMock], scope: str, authorization: str | None
) -> None:
client, commands = uncached_token_client
response = client.get(f"/v1/{scope}", headers={} if authorization is None else {"Authorization": authorization})
message = MISSING_BEARER_MESSAGE if authorization is None else "Access token is invalid"
expected = {"code": "unauthorized", "message": message, "status": 401}
assert response.status_code == 401
assert response.data == json.dumps(expected, separators=(",", ":"), sort_keys=True).encode()
assert response.headers["Content-Type"] == "application/json"
assert response.headers["Cache-Control"] == "no-store"
assert response.headers["WWW-Authenticate"] == 'Bearer realm="api"'
if authorization is None:
commands.assert_not_called()
else:
calls = [call.args for call in commands.call_args_list]
assert calls.count(("GET", f"api_token:{scope}:missing-token")) == 2
assert ("SETEX", f"api_token:{scope}:missing-token", 60, b"null") in calls
assert not any(str(call[1]).startswith(token_service.ACTIVE_TOKEN_KEY_PREFIX) for call in calls)
def test_success_token_and_other_surface_are_not_rewritten(token_client: TokenClient) -> None:
client, cache_get, _fetch, usage = token_client
cache_get.return_value = ApiToken(id="existing")
response = client.get("/v1/info", headers={"Authorization": "bEaReR\tvalid-token"})
assert response.status_code == 200
assert response.get_json() == {"ok": True}
assert "Cache-Control" not in response.headers
usage.assert_called_once_with("valid-token", "app")
other = client.get("/other/info")
assert other.status_code == 401
assert other.get_json()["message"] == "Other API authentication"
assert "Cache-Control" not in other.headers
@pytest.fixture
def mcp_client(http_app: Flask, monkeypatch: pytest.MonkeyPatch, mocker: MockerFixture) -> MCPClient:
bp = Blueprint("mcp_test", __name__, url_prefix="/mcp")
api = ExternalApi(bp)
namespace = Namespace("mcp_test", path="/")
namespace.models.update(mcp.mcp_ns.models)
namespace.add_resource(mcp.MCPAppApi, "/server/<string:server_code>/mcp")
api.add_namespace(namespace)
http_app.register_blueprint(bp)
monkeypatch.setattr(mcp, "mcp_ns", namespace)
# Identity lookups run through the autouse per-test SQLite session factory.
execute = mocker.patch.object(mcp, "handle_mcp_request")
end_user = mocker.patch.object(mcp.MCPAppApi, "_retrieve_end_user")
return http_app.test_client(), execute, end_user
@pytest.mark.parametrize("cached", [False, True])
@pytest.mark.parametrize("identity", ["missing-server", "missing-app", "foreign-tenant-app", "inactive"])
@pytest.mark.parametrize(
("body", "expected_id"),
[
(b'{"id":17}', b"17"),
(b'{"id":-0}', b"-0"),
(b'{"id":1.2500}', b"1.2500"),
(b'{"id":1e+90}', b"1e+90"),
(b'{"id":900719925474099312345678901234567890}', b"900719925474099312345678901234567890"),
(b'{"id":"request-1"}', b'"request-1"'),
('{"id":"<>&雪\u2028\u2029"}'.encode(), '"<>&雪\\u2028\\u2029"'.encode()),
(b'{"id":true}', b"null"),
(b'{"id":[]}', b"null"),
(b'{"id":{}}', b"null"),
(b'{"id":null}', b"null"),
(b"{}", b"null"),
(b'[{"id":1}]', b"null"),
(b'{"id":NaN}', b"null"),
(b'{"id":Infinity}', b"null"),
(b'{"id":', b"null"),
(b'{"id":1}{}', b"null"),
(b'\xef\xbb\xbf{"id":1}', b"null"),
('{"id":1}'.encode("utf-16"), b"null"),
(b'{"id":"\xff"}', b"null"),
(b'{"id":"\\ud800"}', b"null"),
(b'{"id":"\\udfff"}', b"null"),
(b'{"id":"\\ud83d\\ude00"}', '"😀"'.encode()),
(b'{"id":"\\\\ud800"}', b'"\\\\ud800"'),
(b'{"id":1,"params":' + b"[" * 63 + b"0" + b"]" * 63 + b"}", b"1"),
(b'{"id":1,"params":' + b"[" * 64 + b"0" + b"]" * 64 + b"}", b"null"),
(b'{"id":1,"params":"' + b"[" * 100 + b'\\"}"}', b"1"),
(b'{"id":1}' + b" " * (MCP_ERROR_BODY_LIMIT - len(b'{"id":1}')), b"1"),
(b'{"id":1}' + b" " * MCP_ERROR_BODY_LIMIT, b"null"),
],
)
def test_mcp_missing_identity_final_response_is_bounded_and_opaque(
mcp_client: MCPClient,
sqlite_engine: Engine,
sqlite_session: Session,
identity: Literal["missing-server", "missing-app", "foreign-tenant-app", "inactive"],
cached: bool,
body: bytes,
expected_id: bytes,
) -> None:
client, execute, end_user = mcp_client
server = _mcp_server("private-app", "missing-fixture")
if cached:
@client.application.before_request
def cache_body() -> None:
request.get_data()
if identity == "missing-app":
_persist(sqlite_session, server)
elif identity == "foreign-tenant-app":
# The App exists, but outside the server's tenant.
_persist(sqlite_session, server, _app("private-app", "other-tenant"))
elif identity == "inactive":
server.status = "inactive"
_persist(sqlite_session, server, _app("private-app", "tenant"))
with _sqlite_writes(sqlite_engine) as writes:
response = client.post("/mcp/server/missing-fixture/mcp", data=body, content_type="application/json")
assert response.status_code == 404
assert (
response.data
== b'{"error":{"code":-32600,"message":"Server Not Found"},"id":' + expected_id + b',"jsonrpc":"2.0"}'
)
assert response.headers["Content-Type"] == "application/json"
assert response.headers["Cache-Control"] == "no-store"
execute.assert_not_called()
end_user.assert_not_called()
assert writes == []
@pytest.mark.parametrize("cached", [False, True])
@pytest.mark.parametrize("oversized", [False, True])
def test_mcp_unknown_length_stream_read_is_capped(http_app: Flask, cached: bool, oversized: bool) -> None:
class RecordingStream(io.BytesIO):
requested: list[int | None] = []
@override
def read(self, size: int | None = -1) -> bytes:
self.requested.append(size)
return super().read(size)
stream = RecordingStream(b'{"id":1}' + (b" " * MCP_ERROR_BODY_LIMIT if oversized else b""))
with http_app.test_request_context(
"/", method="POST", environ_overrides={"wsgi.input": stream, "wsgi.input_terminated": True}
):
if cached:
request.get_data()
stream.requested.clear()
response = mcp_server_not_found_response()
assert stream.requested == ([] if cached else [MCP_ERROR_BODY_LIMIT + 1])
assert response.get_json()["id"] == (None if oversized else 1)
def test_mcp_debug_request_logging_preserves_raw_error_id(
mcp_client: MCPClient, caplog: pytest.LogCaptureFixture, monkeypatch: pytest.MonkeyPatch
) -> None:
client, execute, end_user = mcp_client
caplog.set_level(logging.DEBUG, logger=ext_request_logging.__name__)
# Exercise the real existing request-started logger, including request.data caching.
apply_config_overrides(monkeypatch, ENABLE_REQUEST_LOGGING=True)
ext_request_logging.init_app(client.application)
response = client.post("/mcp/server/missing-fixture/mcp", data=b'{"id":1.2500}', content_type="application/json")
assert response.status_code == 404
assert b'"id":1.2500,' in response.data
assert "Received Request" in caplog.text
execute.assert_not_called()
end_user.assert_not_called()
def test_existing_mcp_keeps_normal_large_payload_and_response(
mcp_client: MCPClient, sqlite_session: Session, mocker: MockerFixture
) -> None:
client, _execute, _end_user = mcp_client
_persist(sqlite_session, _mcp_server("existing-app", "existing-fixture"), _app("existing-app", "tenant"))
mocker.patch.object(mcp.MCPAppApi, "_get_user_input_form", return_value=[])
expected_body = b'{"id":2,"jsonrpc":"2.0","result":{}}'
process = mocker.patch.object(
mcp.MCPAppApi,
"_process_mcp_message",
return_value=Response(expected_body, status=200, content_type="application/json"),
)
payload = {
"jsonrpc": "2.0",
"method": "initialize",
"id": 2,
"params": {
"protocolVersion": "2024-11-05",
"capabilities": {"experimental": {"fixture": {"padding": "x" * (MCP_ERROR_BODY_LIMIT + 1)}}},
"clientInfo": {"name": "fixture", "version": "1"},
},
}
response = client.post("/mcp/server/existing-fixture/mcp", json=payload)
assert response.status_code == 200
assert response.data == expected_body
assert "Cache-Control" not in response.headers
process.assert_called_once()
def test_existing_mcp_still_validates_malformed_payload(mcp_client: MCPClient, sqlite_session: Session) -> None:
client, execute, end_user = mcp_client
_persist(sqlite_session, _mcp_server("existing-app", "existing-fixture"), _app("existing-app", "tenant"))
response = client.post("/mcp/server/existing-fixture/mcp", data=b"{", content_type="application/json")
assert response.status_code == 400
execute.assert_not_called()
end_user.assert_not_called()
@pytest.mark.parametrize(
"change",
[
"initial-missing",
"missing-server",
"missing-app",
"inactive",
"server-replaced",
"app-rebound",
"tenant-changed",
"unchanged",
],
)
def test_mcp_reads_body_outside_sessions_and_rechecks_identity_before_execution(
mcp_client: MCPClient,
sqlite_engine: Engine,
sqlite_session: Session,
sqlite_session_factory: sessionmaker[Session],
monkeypatch: pytest.MonkeyPatch,
mocker: MockerFixture,
change: str,
) -> None:
client, execute, end_user = mcp_client
active_sessions: list[Session] = []
opened: list[Session] = []
read_sessions: list[bool] = []
server = _mcp_server("app", "fixture")
app = _app("app", "tenant")
if change != "initial-missing":
_persist(sqlite_session, server, app)
def change_identity() -> None:
"""Commit the change the execution session must observe after the body read."""
if change == "missing-server":
sqlite_session.delete(server)
elif change == "missing-app":
sqlite_session.delete(app)
elif change == "inactive":
server.status = "inactive"
elif change == "server-replaced":
server.id = "other-server"
elif change == "app-rebound":
sqlite_session.add(_app("other-app", "tenant"))
server.app_id = "other-app"
elif change == "tenant-changed":
server.tenant_id = app.tenant_id = "other-tenant"
sqlite_session.commit()
def create_session(**_kwargs: object) -> Session:
if opened:
# The identity change is the test's own write, not the request's.
request_writes = len(writes)
change_identity()
del writes[request_writes:]
session = sqlite_session_factory()
opened.append(session)
active_sessions.append(session)
close = session.close
def close_session() -> None:
try:
close()
finally:
active_sessions.pop()
mocker.patch.object(session, "close", side_effect=close_session)
return session
maker = sessionmaker()
mocker.patch.object(maker, "class_", side_effect=create_session)
monkeypatch.setattr(mcp.session_factory, "get_session_maker", lambda: maker)
form = mocker.patch.object(mcp.MCPAppApi, "_get_user_input_form", return_value=[])
attached_to: list[Session | None] = []
def process_message(*args: object) -> Response:
attached_to.extend(object_session(record) for record in args[2:4])
return Response("ok", status=200)
process = mocker.patch.object(mcp.MCPAppApi, "_process_mcp_message", side_effect=process_message)
original_error = mcp.mcp_server_not_found_response
def error_response() -> Response:
assert not active_sessions, "404 response must be constructed after releasing sessions"
return original_error()
monkeypatch.setattr(mcp, "mcp_server_not_found_response", error_response)
class RecordingStream(io.BytesIO):
@override
def read(self, size: int | None = -1) -> bytes:
read_sessions.append(bool(active_sessions))
return super().read(size)
@override
def readinto(self, buffer: Buffer) -> int:
read_sessions.append(bool(active_sessions))
return super().readinto(buffer)
payload = b'{"jsonrpc":"2.0","method":"ping","id":900719925474099312345678901234567890}'
with _sqlite_writes(sqlite_engine) as writes:
response = client.post(
"/mcp/server/fixture/mcp", input_stream=RecordingStream(payload), content_type="application/json"
)
assert read_sessions
assert not any(read_sessions)
assert not active_sessions
assert len(opened) == (1 if change == "initial-missing" else 2)
if change == "unchanged":
assert response.status_code == 200
execution = opened[1]
fresh_app = process.call_args.args[2]
form.assert_called_once_with(fresh_app, session=execution)
assert (fresh_app.id, process.call_args.args[3].id) == ("app", "server")
assert process.call_args.args[5] is execution
assert attached_to == [execution, execution]
else:
assert response.status_code == 404
assert b'"id":900719925474099312345678901234567890,' in response.data
form.assert_not_called()
process.assert_not_called()
execute.assert_not_called()
end_user.assert_not_called()
assert writes == []
@pytest.mark.parametrize("route", ["webhook", "webhook-debug"])
def test_webhook_missing_identity_uses_native_html_without_disclosing_id(
http_app: Flask, monkeypatch: pytest.MonkeyPatch, mocker: MockerFixture, route: Literal["webhook", "webhook-debug"]
) -> None:
monkeypatch.setattr(webhook, "request", request)
monkeypatch.setattr(webhook, "jsonify", jsonify)
mocker.patch.object(
webhook.WebhookService,
"get_webhook_trigger_and_workflow",
side_effect=ValueError("Webhook not found: private-fixture"),
)
execute = mocker.patch.object(webhook.WebhookService, "trigger_workflow_execution")
handler = webhook.handle_webhook if route == "webhook" else webhook.handle_webhook_debug
http_app.add_url_rule(f"/triggers/{route}/<string:webhook_id>", view_func=handler, methods=["POST"])
response = http_app.test_client().post(f"/triggers/{route}/private-fixture", json={})
assert response.status_code == 404
assert response.data == NotFound().get_body().encode()
assert response.headers["Content-Type"] == "text/html; charset=utf-8"
assert response.headers["Cache-Control"] == "no-store"
assert b"private-fixture" not in response.data
execute.assert_not_called()
@pytest.mark.parametrize("endpoint", ["123e4567-e89b-42d3-a456-426614174000", "invalid-id"])
def test_plugin_callback_retains_its_json_error_contract(
http_app: Flask, monkeypatch: pytest.MonkeyPatch, mocker: MockerFixture, endpoint: str
) -> None:
monkeypatch.setattr(plugin_trigger, "request", request)
monkeypatch.setattr(plugin_trigger, "jsonify", jsonify)
mocker.patch.object(plugin_trigger.TriggerService, "process_endpoint", return_value=None)
mocker.patch.object(
plugin_trigger.TriggerSubscriptionBuilderService,
"process_builder_validation_endpoint",
return_value=None,
)
http_app.add_url_rule(
"/triggers/plugin/<string:endpoint_id>", view_func=plugin_trigger.trigger_endpoint, methods=["POST"]
)
response = http_app.test_client().post(f"/triggers/plugin/{endpoint}", json={})
assert response.status_code == 404
assert response.data == b'{"error":"Endpoint not found"}'
assert response.mimetype == "application/json"
assert response.headers["Cache-Control"] == "no-store"
@pytest.mark.parametrize("status", [401, 403, 429])
def test_openapi_local_hook_preserves_native_details_and_oauth_challenge(http_app: Flask, status: int) -> None:
payload = {
"code": "unauthorized",
"message": "invalid_token",
"status": status,
"hint": "native hint",
"details": [{"type": "native", "loc": ["header"], "msg": "detail"}],
}
bp = Blueprint("openapi_test", __name__, url_prefix="/openapi/v1")
register_auth_error_response(bp)
@bp.route("/fixture")
def fixture() -> tuple[Response, int, dict[str, str]]:
return jsonify(payload), status, {"WWW-Authenticate": 'Bearer realm="native-openapi", error="invalid_token"'}
http_app.register_blueprint(bp)
response = http_app.test_client().get("/openapi/v1/fixture")
assert response.status_code == status
assert response.get_json() == payload
assert response.headers["WWW-Authenticate"] == 'Bearer realm="native-openapi", error="invalid_token"'
if status == 401:
assert response.data == json.dumps(payload, separators=(",", ":"), sort_keys=True).encode()
assert response.headers["Cache-Control"] == "no-store"
else:
assert "Cache-Control" not in response.headers
@@ -0,0 +1,175 @@
"""Unit tests for Agent resource-list RBAC filtering."""
from __future__ import annotations
import pytest
from sqlalchemy.orm import Session
from controllers.common.agent_access import (
AGENT_LIST_PERMISSION_KEYS,
AgentAccessFilter,
has_agent_list_permission,
resolve_agent_access_filter,
)
from models.agent import Agent, AgentKind, AgentScope, AgentSource, AgentStatus
from services.app_service import AppListParams
from services.rbac.contracts import (
MyPermissionsResponse,
ResourcePermissionKeys,
ResourcePermissionSnapshot,
ResourceWhitelistResources,
WorkspacePermissionSnapshot,
)
_RBAC_MODULE = "controllers.common.agent_access.enterprise_rbac_service"
def _permissions(
*,
workspace_keys: list[str] | None = None,
agent_default_keys: list[str] | None = None,
agent_overrides: list[ResourcePermissionKeys] | None = None,
) -> MyPermissionsResponse:
return MyPermissionsResponse(
workspace=WorkspacePermissionSnapshot(permission_keys=workspace_keys or []),
agent=ResourcePermissionSnapshot(
default_permission_keys=agent_default_keys or [],
overrides=agent_overrides or [],
),
)
def _agent(
*,
agent_id: str,
app_id: str | None,
source: AgentSource = AgentSource.AGENT_APP,
status: AgentStatus = AgentStatus.ACTIVE,
) -> Agent:
return Agent(
id=agent_id,
tenant_id="tenant-1",
name=agent_id,
description="",
role="",
agent_kind=AgentKind.DIFY_AGENT,
scope=AgentScope.ROSTER,
source=source,
app_id=app_id,
status=status,
created_by="account-1",
updated_by="account-1",
)
class TestHasAgentListPermission:
def test_matches_preview_permission(self) -> None:
for key in AGENT_LIST_PERMISSION_KEYS:
assert has_agent_list_permission([key])
def test_rejects_non_preview_permissions(self) -> None:
assert not has_agent_list_permission(["agent.acl.edit", "agent.acl.delete"])
assert not has_agent_list_permission([])
class TestAgentAccessFilter:
def test_unrestricted_leaves_app_params_untouched(self, unbound_session: Session) -> None:
params = AppListParams(mode="agent")
AgentAccessFilter.unrestricted().apply_to_app_params(
params,
tenant_id="tenant-1",
session=unbound_session,
)
assert params.accessible_app_ids is None
def test_maps_visible_agent_ids_to_active_agent_apps(self, sqlite_session: Session) -> None:
sqlite_session.add_all(
[
_agent(agent_id="agent-1", app_id="app-2"),
_agent(agent_id="agent-2", app_id="app-1"),
_agent(agent_id="agent-3", app_id="workflow-app", source=AgentSource.ROSTER),
_agent(agent_id="agent-4", app_id="archived-app", status=AgentStatus.ARCHIVED),
]
)
sqlite_session.flush()
params = AppListParams(mode="agent")
AgentAccessFilter(accessible_agent_ids={"agent-1", "agent-2", "agent-3", "agent-4"}).apply_to_app_params(
params, tenant_id="tenant-1", session=sqlite_session
)
assert params.accessible_app_ids == ["app-1", "app-2"]
def test_empty_visible_set_filters_every_agent_app(self, unbound_session: Session) -> None:
params = AppListParams(mode="agent")
AgentAccessFilter(accessible_agent_ids=set()).apply_to_app_params(
params,
tenant_id="tenant-1",
session=unbound_session,
)
assert params.accessible_app_ids == []
class TestResolveAgentAccessFilter:
def _patch_whitelist(self, monkeypatch: pytest.MonkeyPatch, whitelist: ResourceWhitelistResources) -> None:
monkeypatch.setattr(
f"{_RBAC_MODULE}.RBACService.AgentAccess.whitelist_resources",
lambda _tenant_id, _account_id: whitelist,
)
def test_default_preview_is_unrestricted(self, monkeypatch: pytest.MonkeyPatch) -> None:
self._patch_whitelist(monkeypatch, ResourceWhitelistResources(unrestricted=True))
access_filter = resolve_agent_access_filter(
"tenant-1",
"account-1",
permissions=_permissions(agent_default_keys=["agent.acl.preview"]),
)
assert access_filter.accessible_agent_ids is None
def test_collects_preview_overrides_without_default_preview(
self,
monkeypatch: pytest.MonkeyPatch,
) -> None:
self._patch_whitelist(monkeypatch, ResourceWhitelistResources(unrestricted=True))
access_filter = resolve_agent_access_filter(
"tenant-1",
"account-1",
permissions=_permissions(
agent_overrides=[
ResourcePermissionKeys(
resource_id="agent-1",
permission_keys=["agent.acl.preview"],
),
ResourcePermissionKeys(
resource_id="agent-2",
permission_keys=["agent.acl.edit"],
),
]
),
)
assert access_filter.accessible_agent_ids == {"agent-1"}
def test_restricted_whitelist_is_the_visibility_boundary(
self,
monkeypatch: pytest.MonkeyPatch,
) -> None:
self._patch_whitelist(
monkeypatch,
ResourceWhitelistResources(unrestricted=False, resource_ids=["agent-9"]),
)
access_filter = resolve_agent_access_filter(
"tenant-1",
"account-1",
permissions=_permissions(workspace_keys=["agent.acl.preview"]),
)
assert access_filter.accessible_agent_ids == {"agent-9"}
@@ -0,0 +1,500 @@
import json
from collections.abc import Callable, Iterator
from typing import Literal
from uuid import UUID
import pytest
from flask import Blueprint, Flask, Response
from flask.typing import ResponseReturnValue
from flask_restx import Resource
from pytest_mock import MockerFixture
from werkzeug.exceptions import NotFound
from werkzeug.middleware.proxy_fix import ProxyFix
from controllers.common.app_access_error import register_app_access_error_metadata
from libs.exception import BaseHTTPException
from libs.external_api import ExternalApi
from tests.helpers.unit.config_override import apply_config_overrides
APP_ID = "9d6e3fb3-94ce-48f9-a958-58ca80b1c02e"
TRUSTED = "172.18.0.0/16,10.0.0.0/8,2400:cb00::/32"
WEB_IDENTITIES = ("/site", "/parameters", "/meta", "/passport", "/login/status", "/webapp/access-mode")
CONSOLE_IDENTITIES = (
"/apps/<uuid:app_id>",
"/agent/<uuid:agent_id>",
"/installed-apps/<uuid:installed_app_id>",
"/installed-apps/<uuid:installed_app_id>/parameters",
"/installed-apps/<uuid:installed_app_id>/meta",
"/trial-apps/<uuid:app_id>",
"/trial-apps/<uuid:app_id>/parameters",
)
OTHER_ROUTES = (
"/chat-messages",
"/form/human_input/<string:form_token>",
"/form/human_input/<string:form_token>/upload-token",
"/human-input-forms/files",
"/conversations/<uuid:conversation_id>",
"/apps/<uuid:app_id>/workflows/<uuid:workflow_id>",
"/agent/<uuid:agent_id>/versions/<uuid:version_id>",
"/installed-apps/<uuid:installed_app_id>/conversations",
"/trial-apps/<uuid:app_id>/workflows",
)
class AppNotFoundError(BaseHTTPException):
error_code = "app_not_found"
code = 404
description = "App not found."
class AgentNotFoundError(NotFound):
description = "Agent not found."
def _missing_app() -> ResponseReturnValue:
raise NotFound("App not found.")
def _create_app(responder: Callable[[], ResponseReturnValue] = _missing_app, *, use_proxy_fix: bool = False) -> Flask:
app = Flask(__name__)
app.config.update(TESTING=True, RESTX_ERROR_404_HELP=False)
if use_proxy_fix:
app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1) # type: ignore[method-assign]
for surface, prefix in (("web", "/api"), ("console", "/console/api"), ("service", "/v1")):
bp = Blueprint(surface, __name__, url_prefix=prefix)
if surface == "web":
register_app_access_error_metadata(bp, surface="web")
elif surface == "console":
register_app_access_error_metadata(bp, surface="console")
api = ExternalApi(bp)
class AppResource(Resource):
def get(self, **_kwargs: str | UUID) -> ResponseReturnValue:
return responder()
def post(self, **_kwargs: str | UUID) -> ResponseReturnValue:
return responder()
# Include the opposite surface's identity paths to prove the allowlists
# are independent, not broad suffix/path matches.
api.add_resource(AppResource, *WEB_IDENTITIES, *CONSOLE_IDENTITIES, *OTHER_ROUTES)
app.register_blueprint(bp)
return app
def _path(rule: str) -> str:
for name in ("app_id", "agent_id", "installed_app_id", "workflow_id", "conversation_id", "version_id"):
rule = rule.replace(f"<uuid:{name}>", APP_ID)
return rule.replace("<string:form_token>", "missing-form-token")
@pytest.fixture(autouse=True)
def _trusted_proxies(monkeypatch: pytest.MonkeyPatch) -> None:
apply_config_overrides(monkeypatch, NETWORK_ACCESS_TRUSTED_PROXY_CIDRS=TRUSTED)
@pytest.mark.parametrize("rule", WEB_IDENTITIES)
def test_web_app_identity_404s_receive_metadata(rule: str) -> None:
response = _create_app().test_client().get("/api" + rule, environ_overrides={"REMOTE_ADDR": "203.0.113.42"})
assert response.status_code == 404
assert response.get_json() == {
"code": "app_not_found",
"message": "App not found.",
"status": 404,
"client_ip": "203.0.113.42",
}
assert response.headers["Cache-Control"] == "no-store"
@pytest.mark.parametrize("rule", CONSOLE_IDENTITIES)
def test_console_app_identity_404s_receive_metadata(rule: str) -> None:
response = (
_create_app().test_client().get("/console/api" + _path(rule), environ_overrides={"REMOTE_ADDR": "203.0.113.42"})
)
assert response.status_code == 404
assert response.get_json()["client_ip"] == "203.0.113.42"
assert response.get_json()["code"] == "not_found"
@pytest.mark.parametrize("prefix", ["/api", "/console/api"])
@pytest.mark.parametrize("method", ["GET", "POST"])
def test_typed_app_not_found_keeps_exception_payload_after_restx_formatting(prefix: str, method: str) -> None:
def missing() -> ResponseReturnValue:
error = AppNotFoundError()
assert error.data is not None
error.data["detail"] = {"reason": "unavailable"}
raise error
response = (
_create_app(missing)
.test_client()
.open(prefix + "/chat-messages", method=method, environ_overrides={"REMOTE_ADDR": "203.0.113.42"})
)
assert response.status_code == 404
expected: dict[str, object] = {
"code": "app_not_found",
"message": "App not found.",
"status": 404,
"client_ip": "203.0.113.42",
}
if prefix == "/console/api":
expected["detail"] = {"reason": "unavailable"}
assert response.get_json() == expected
def test_agent_error_code_is_not_reclassified() -> None:
def missing() -> ResponseReturnValue:
raise AgentNotFoundError()
response = (
_create_app(missing)
.test_client()
.get(f"/console/api/agent/{APP_ID}", environ_overrides={"REMOTE_ADDR": "203.0.113.42"})
)
assert response.status_code == 404
assert response.get_json()["code"] == "agent_not_found_error"
assert response.get_json()["message"] == "Agent not found."
assert response.get_json()["client_ip"] == "203.0.113.42"
@pytest.mark.parametrize(
("peer", "forwarded", "expected"),
[
("203.0.113.42", "192.0.2.1, invalid", "203.0.113.42"),
("2001:db8::42", "192.0.2.1", "2001:db8::42"),
("::ffff:203.0.113.42", "192.0.2.1", "203.0.113.42"),
("172.18.0.2", "192.0.2.1, 203.0.113.42, 10.2.3.4", "203.0.113.42"),
("172.18.0.2", "2001:0db8::42, 2400:cb00::1, 10.2.3.4", "2001:db8::42"),
("::ffff:172.18.0.2", "::ffff:203.0.113.42, ::ffff:10.2.3.4", "203.0.113.42"),
],
)
@pytest.mark.parametrize("use_proxy_fix", [False, True])
def test_trust_boundary_ignores_spoofed_arguments_and_headers(
peer: str, forwarded: str, expected: str, use_proxy_fix: bool
) -> None:
response = (
_create_app(use_proxy_fix=use_proxy_fix)
.test_client()
.get(
"/api/site?client_ip=192.0.2.123&app_code=does-not-exist",
json={"client_ip": "192.0.2.124"},
headers={"X-Forwarded-For": forwarded, "X-Real-IP": "192.0.2.125", "CF-Connecting-IP": "192.0.2.126"},
environ_overrides={"REMOTE_ADDR": peer},
)
)
assert response.status_code == 404
assert response.get_json()["client_ip"] == expected
@pytest.mark.parametrize("config", ["", " ", "not-a-cidr", "172.18.0.1/16", "172.18.0.0/16,"])
def test_missing_or_invalid_trust_configuration_preserves_original_404(
monkeypatch: pytest.MonkeyPatch, config: str
) -> None:
apply_config_overrides(monkeypatch, NETWORK_ACCESS_TRUSTED_PROXY_CIDRS=config)
response = (
_create_app()
.test_client()
.get("/api/site", environ_overrides={"REMOTE_ADDR": "172.18.0.2", "HTTP_X_FORWARDED_FOR": "203.0.113.42"})
)
assert response.status_code == 404
assert response.get_json() == {"code": "app_not_found", "message": "App not found.", "status": 404}
assert response.headers["Cache-Control"] == "no-store"
@pytest.mark.parametrize("forwarded", [None, "", "unknown", "192.0.2.1, invalid", "10.2.3.4", "192.0.2.1," * 33])
def test_unavailable_client_ip_never_exposes_internal_peer_or_changes_status(forwarded: str | None) -> None:
environ = {"REMOTE_ADDR": "172.18.0.2"}
if forwarded is not None:
environ["HTTP_X_FORWARDED_FOR"] = forwarded
response = _create_app().test_client().get("/api/site", environ_overrides=environ)
assert response.status_code == 404
assert "client_ip" not in response.get_json()
assert response.headers["Cache-Control"] == "no-store"
@pytest.mark.parametrize("config", ["", "not-a-cidr", TRUSTED])
def test_unavailable_client_ip_removes_existing_unverified_metadata(
monkeypatch: pytest.MonkeyPatch, config: str
) -> None:
apply_config_overrides(monkeypatch, NETWORK_ACCESS_TRUSTED_PROXY_CIDRS=config)
payload = {
"code": "app_not_found",
"message": "missing",
"status": 404,
"client_ip": "192.0.2.123",
"extra": "kept",
}
response = (
_create_app(lambda: (payload, 404))
.test_client()
.get("/api/site", environ_overrides={"REMOTE_ADDR": "172.18.0.2"})
)
assert response.status_code == 404
assert response.get_json() == {"code": "app_not_found", "message": "App not found.", "status": 404}
assert response.headers["Cache-Control"] == "no-store"
@pytest.mark.parametrize("prefix", ["/api", "/console/api"])
@pytest.mark.parametrize("rule", [rule for rule in OTHER_ROUTES if "human_input" in rule or "human-input" in rule])
def test_typed_app_not_found_on_human_input_forms_is_unchanged(prefix: str, rule: str) -> None:
def missing() -> ResponseReturnValue:
raise AppNotFoundError()
response = _create_app(missing).test_client().get(prefix + _path(rule))
assert response.status_code == 404
assert response.get_json() == {"code": "app_not_found", "message": "App not found.", "status": 404}
assert "Cache-Control" not in response.headers
def test_response_metadata_is_request_local_and_disables_shared_caching() -> None:
payload = {"code": "app_not_found", "message": "missing", "status": 404, "extra": ["kept"]}
client = _create_app(
lambda: (payload, 404, {"Cache-Control": "public, max-age=600", "X-Custom": "kept"})
).test_client()
for peer in ("203.0.113.42", "2001:db8::43", "172.18.0.2"):
response = client.get("/api/site", environ_overrides={"REMOTE_ADDR": peer})
assert response.get_json().get("client_ip") == (None if peer == "172.18.0.2" else peer)
assert "extra" not in response.get_json()
assert response.headers["Cache-Control"] == "no-store"
assert response.headers["X-Custom"] == "kept"
assert "client_ip" not in payload
@pytest.mark.parametrize("prefix", ["/api", "/console/api"])
@pytest.mark.parametrize("rule", OTHER_ROUTES)
def test_unrelated_resource_and_human_input_form_404s_are_unchanged(prefix: str, rule: str) -> None:
response = _create_app().test_client().get(prefix + _path(rule))
assert response.status_code == 404
if prefix == "/api" and rule.startswith("/form/human_input/"):
assert response.get_json() == {"code": "not_found", "message": "Form not found", "status": 404}
assert response.headers["Cache-Control"] == "no-store"
else:
assert response.get_json() == {"code": "not_found", "message": "App not found.", "status": 404}
assert "Cache-Control" not in response.headers
@pytest.mark.parametrize("code", ["app_unavailable", "agent_not_published"])
@pytest.mark.parametrize("route", WEB_IDENTITIES)
def test_web_unavailable_and_unpublished_identity_uses_same_404(code: str, route: str) -> None:
payload = {"code": code, "message": "private configuration details", "status": 400, "app_name": "private"}
response = (
_create_app(lambda: (payload, 400))
.test_client()
.get("/api" + route, environ_overrides={"REMOTE_ADDR": "203.0.113.42"})
)
assert response.status_code == 404
assert response.headers["Content-Type"] == "application/json"
assert response.headers["Cache-Control"] == "no-store"
assert response.data == (
b'{"client_ip":"203.0.113.42","code":"app_not_found","message":"App not found.","status":404}'
)
@pytest.mark.parametrize("code", ["not_found", "app_not_found", "agent_not_found_error"])
def test_web_missing_identity_has_one_minimal_canonical_wire_contract(code: str) -> None:
payload = {"code": code, "message": "private cause", "status": 404, "policy_id": "private", "app_name": "private"}
response = (
_create_app(lambda: (payload, 404))
.test_client()
.get("/api/passport", environ_overrides={"REMOTE_ADDR": "203.0.113.42"})
)
assert response.data == (
b'{"client_ip":"203.0.113.42","code":"app_not_found","message":"App not found.","status":404}'
)
assert response.headers["Content-Type"] == "application/json"
def test_hitl_upload_invalid_token_keeps_native_contract_without_ip() -> None:
payload = {"code": "invalid_upload_token", "message": "private cause", "status": 403, "client_ip": "192.0.2.1"}
response = _create_app(lambda: (payload, 403)).test_client().post("/api/human-input-forms/files")
assert response.status_code == 403
assert response.data == (
b'{"code":"invalid_upload_token","message":"Upload token is invalid or expired.","status":403}'
)
assert response.headers["Cache-Control"] == "no-store"
assert response.headers["Content-Type"] == "application/json"
@pytest.mark.parametrize("prefix", ["/api", "/console/api"])
@pytest.mark.parametrize("status", [200, 400, 401, 403, 503])
def test_success_and_non_404_errors_are_unchanged(prefix: str, status: int) -> None:
# Even an inconsistent error code cannot override the HTTP status contract.
payload = {"code": "app_not_found", "message": "unchanged", "status": status}
response = _create_app(lambda: (payload, status)).test_client().get(prefix + "/site")
assert response.status_code == status
assert response.get_json() == payload
assert "Cache-Control" not in response.headers
# These sentinel responses intentionally omit contract fields and forbid JSON
# reads; the global schema checker would itself violate the behavior under test.
@pytest.mark.allow_error_contract_violations
@pytest.mark.parametrize("path", ["/api/site", f"/console/api/apps/{APP_ID}"])
@pytest.mark.parametrize("status", [200, 201, 204, 301, 302, 303, 304, 307, 308, 401, 500, 503])
def test_non_candidate_statuses_do_not_parse_json(mocker: MockerFixture, path: str, status: int) -> None:
body = b'{"code":"app_not_found","message":"unchanged","data":[1,2,3]}'
original = Response(body, status=status, mimetype="application/json")
parse = mocker.patch.object(
original, "get_json", side_effect=AssertionError("Non-candidate response must not be parsed")
)
app = _create_app(lambda: original)
with app.test_request_context(path):
response = app.full_dispatch_request()
assert response is original
assert response.status_code == status
assert response.data == body
assert "Cache-Control" not in response.headers
parse.assert_not_called()
@pytest.mark.parametrize(
("path", "method", "status"),
[
(f"/console/api/apps/{APP_ID}", "GET", 400),
(f"/console/api/apps/{APP_ID}", "GET", 403),
("/console/api/human-input-forms/files", "POST", 403),
("/console/api/form/human_input/token", "GET", 404),
("/api/chat-messages", "GET", 400),
("/api/site", "POST", 400),
("/api/form/human_input/token", "GET", 400),
("/api/site", "GET", 403),
("/api/chat-messages", "POST", 403),
("/api/form/human_input/token", "GET", 403),
("/api/human-input-forms/files", "POST", 404),
],
)
@pytest.mark.allow_error_contract_violations
def test_route_and_surface_ineligible_errors_do_not_parse_json(
mocker: MockerFixture, path: str, method: str, status: int
) -> None:
body = b'{"code":"app_not_found","message":"unchanged"}'
original = Response(body, status=status, mimetype="application/json")
parse = mocker.patch.object(original, "get_json", side_effect=AssertionError("Ineligible error must not be parsed"))
app = _create_app(lambda: original)
with app.test_request_context(path, method=method):
response = app.full_dispatch_request()
assert response is original
assert response.status_code == status
assert response.data == body
assert "Cache-Control" not in response.headers
parse.assert_not_called()
@pytest.mark.parametrize("status", [200, 400, 403, 404])
@pytest.mark.parametrize("direct_passthrough", [False, True])
@pytest.mark.allow_error_contract_violations
def test_candidate_and_success_streams_never_parse_or_consume_response(
mocker: MockerFixture, status: int, direct_passthrough: bool
) -> None:
consumed: list[bool] = []
def stream() -> Iterator[str]:
consumed.append(True)
yield '{"code":"app_not_found"}'
original = Response(stream(), status, mimetype="application/json", direct_passthrough=direct_passthrough)
parse = mocker.patch.object(original, "get_json", side_effect=AssertionError("Stream must not be parsed"))
app = _create_app(lambda: original)
with app.test_request_context("/api/site"):
response = app.full_dispatch_request()
assert response is original
assert response.status_code == status
assert "Cache-Control" not in response.headers
assert not consumed
parse.assert_not_called()
def test_trial_forbidden_is_not_reclassified_as_missing_app() -> None:
payload = {"code": "forbidden", "message": "App unavailable", "status": 403}
response = _create_app(lambda: (payload, 403)).test_client().get(f"/console/api/trial-apps/{APP_ID}")
assert response.status_code == 403
assert response.get_json() == payload
assert "Cache-Control" not in response.headers
@pytest.mark.parametrize("prefix", ["/api", "/console/api"])
def test_non_get_untyped_identity_404_is_unchanged(prefix: str) -> None:
response = _create_app().test_client().post(prefix + "/site")
assert response.status_code == 404
assert "client_ip" not in response.get_json()
assert "Cache-Control" not in response.headers
@pytest.mark.parametrize(
"path", ["/api/unknown", "/console/api/unknown", "/api/site/unknown", "/console/api/apps/not-a-uuid", "/elsewhere"]
)
def test_unknown_routes_preserve_default_html_not_found(path: str) -> None:
response = _create_app().test_client().get(path)
assert response.status_code == 404
assert response.mimetype == "text/html"
assert "Cache-Control" not in response.headers
@pytest.mark.parametrize("path", [f"/api/apps/{APP_ID}", "/console/api/site", "/v1/site", f"/v1/apps/{APP_ID}"])
def test_identity_allowlist_does_not_leak_between_surfaces(path: str) -> None:
response = _create_app().test_client().get(path)
assert response.status_code == 404
assert "client_ip" not in response.get_json()
assert "Cache-Control" not in response.headers
def test_typed_service_api_error_is_unchanged() -> None:
def missing() -> ResponseReturnValue:
raise AppNotFoundError()
response = _create_app(missing).test_client().get("/v1/chat-messages")
assert response.status_code == 404
assert response.get_json()["code"] == "app_not_found"
assert "client_ip" not in response.get_json()
assert "Cache-Control" not in response.headers
@pytest.mark.parametrize("kind", ["stream", "passthrough", "html", "list", "null", "invalid-json"])
@pytest.mark.allow_error_contract_violations
def test_non_json_object_and_streamed_responses_are_not_consumed(kind: str) -> None:
consumed: list[bool] = []
def respond() -> Response:
if kind in {"stream", "passthrough"}:
def stream() -> Iterator[str]:
consumed.append(True)
yield '{"code":"app_not_found"}'
return Response(stream(), 404, mimetype="application/json", direct_passthrough=kind == "passthrough")
if kind == "html":
return Response("<h1>Missing</h1>", 404, mimetype="text/html")
data = {"list": json.dumps([{"code": "app_not_found"}]), "null": "null", "invalid-json": "{"}[kind]
return Response(data, 404, mimetype="application/json")
app = _create_app(respond)
with app.test_request_context("/api/site", environ_overrides={"REMOTE_ADDR": "203.0.113.42"}):
response = app.full_dispatch_request()
assert response.status_code == 404
assert "Cache-Control" not in response.headers
assert not consumed
@pytest.mark.parametrize("surface", ["web", "console"])
def test_production_blueprints_register_metadata_hook_and_all_identity_rules(
surface: Literal["web", "console"],
) -> None:
if surface == "web":
from controllers.web import bp
routes = WEB_IDENTITIES
else:
from controllers.console import bp
routes = CONSOLE_IDENTITIES
assert any(hook.__name__ == "add_app_access_error_metadata" for hook in bp.after_request_funcs[None])
app = Flask(__name__)
app.register_blueprint(bp)
actual_rules = {rule.rule for rule in app.url_map.iter_rules()}
assert bp.url_prefix is not None
assert {bp.url_prefix + route for route in routes} <= actual_rules
@@ -0,0 +1,183 @@
"""HTTP audio response ownership without changing MIME or request context."""
from collections.abc import Callable, Generator, Iterator
from dataclasses import dataclass, field
from typing import override
import pytest
from flask import Flask, Response, g, has_request_context, request
import controllers.common.audio_response as response_module
from controllers.common.audio_response import audio_binary_response
from graphon.model_runtime.errors.invoke import InvokeBadRequestError
from services.audio_types import AudioOutput
_WAV = b"RIFF\x24\x00\x00\x00WAVE" + b"\x00" * 32
@dataclass
class _Stream(Iterator[bytes]):
chunks: Iterator[bytes] = field(default_factory=lambda: iter([_WAV, b"remaining"]))
close_calls: int = 0
close_error: Exception | None = None
@override
def __next__(self) -> bytes:
return next(self.chunks)
def close(self) -> None:
self.close_calls += 1
if self.close_error is not None:
raise self.close_error
def test_missing_output_preserves_null_response() -> None:
assert audio_binary_response(None) is None
@pytest.mark.parametrize("convert", [bytes, bytearray, memoryview])
def test_binary_response_preserves_content_and_detected_mime(
convert: Callable[[bytes], bytes | bytearray | memoryview],
) -> None:
response = audio_binary_response(AudioOutput(data=convert(_WAV), mime_type="audio/x-wav"))
assert response is not None
assert response.status_code == 200
assert response.data == _WAV
assert dict(response.headers) == {"Content-Type": "audio/wav", "Content-Length": str(len(_WAV))}
@pytest.mark.parametrize("consumed_chunks", [0, 1, 2, None])
def test_response_owns_stream_before_consumption_and_after_partial_or_complete_reads(
consumed_chunks: int | None,
) -> None:
source = _Stream()
app = Flask(__name__)
with app.test_request_context("/audio"):
response = audio_binary_response(AudioOutput(data=source, mime_type="audio/x-wav"))
assert response is not None
assert response.status_code == 200
assert dict(response.headers) == {"Content-Type": "audio/wav"}
assert source.close_calls == 0
try:
iterator = iter(response.response)
if consumed_chunks is None:
assert list(iterator) == [_WAV, b"remaining"]
assert source.close_calls == 1
else:
assert [next(iterator) for _ in range(consumed_chunks)] == [_WAV, b"remaining"][:consumed_chunks]
assert source.close_calls == 0
finally:
response.close()
response.close()
assert source.close_calls == 1
assert not has_request_context()
def test_http_partial_consumption_preserves_and_releases_request_context() -> None:
closed: list[tuple[str, str]] = []
def audio() -> Generator[bytes]:
try:
assert request.path == "/audio"
assert g.audio_marker == "request marker"
yield _WAV
assert request.path == "/audio"
assert g.audio_marker == "request marker"
yield b"unconsumed"
finally:
closed.append((request.path, g.audio_marker))
source = audio()
app = Flask(__name__)
@app.get("/audio")
def get_audio() -> Response:
g.audio_marker = "request marker"
response = audio_binary_response(AudioOutput(data=source, mime_type=None))
assert response is not None
return response
response = app.test_client().get("/audio")
assert response.status_code == 200
assert response.headers["Content-Type"] == "audio/wav"
assert "Content-Length" not in response.headers
assert next(iter(response.response)) == _WAV
assert closed == []
response.close()
assert closed == [("/audio", "request marker")]
assert not has_request_context()
@pytest.mark.parametrize("failure", ["mime", "first-chunk"])
@pytest.mark.parametrize("cleanup_fails", [False, True])
def test_inspection_failure_closes_input_exactly_once_and_preserves_error(
failure: str,
cleanup_fails: bool,
) -> None:
error = InvokeBadRequestError("provider disconnected while reading first chunk")
def broken_chunks() -> Generator[bytes]:
raise error
yield b"unreachable"
source = _Stream(
chunks=iter([_WAV]) if failure == "mime" else broken_chunks(),
close_error=RuntimeError("cleanup failed") if cleanup_fails else None,
)
with pytest.raises(InvokeBadRequestError) as caught:
audio_binary_response(AudioOutput(data=source, mime_type="audio/mpeg"))
if failure == "first-chunk":
assert caught.value is error
else:
assert "MIME does not match" in str(caught.value)
assert source.close_calls == 1
def test_missing_request_context_closes_owned_stream() -> None:
source = _Stream()
assert not has_request_context()
with pytest.raises(RuntimeError, match="request context is active"):
audio_binary_response(AudioOutput(data=source, mime_type=None))
assert source.close_calls == 1
def test_response_construction_failure_closes_owned_stream(monkeypatch: pytest.MonkeyPatch) -> None:
source = _Stream()
error = RuntimeError("HTTP response construction failed")
def fail_response(*_args: object, **_kwargs: object) -> Response:
raise error
monkeypatch.setattr(response_module, "Response", fail_response)
app = Flask(__name__)
with app.test_request_context("/audio"):
with pytest.raises(RuntimeError) as caught:
audio_binary_response(AudioOutput(data=source, mime_type=None))
assert caught.value is error
assert source.close_calls == 1
assert not has_request_context()
def test_late_provider_error_closes_stream_and_releases_context() -> None:
error = RuntimeError("provider disconnected after first chunk")
def broken_chunks() -> Generator[bytes]:
yield _WAV
raise error
source = _Stream(chunks=broken_chunks())
app = Flask(__name__)
with app.test_request_context("/audio"):
response = audio_binary_response(AudioOutput(data=source, mime_type=None))
assert response is not None
iterator = iter(response.response)
assert next(iterator) == _WAV
with pytest.raises(RuntimeError) as caught:
next(iterator)
response.close()
assert caught.value is error
assert source.close_calls == 1
assert not has_request_context()
@@ -0,0 +1,204 @@
import pytest
from flask import Flask
from flask.typing import ResponseReturnValue
from flask_restx import Api, Resource
from werkzeug.exceptions import Forbidden
from controllers.common.errors import (
BlockedFileExtensionError,
FilenameNotExistsError,
FileTooLargeError,
NoFileUploadedError,
RemoteFileAccessDeniedError,
RemoteFileInvalidResponseError,
RemoteFileInvalidUrlError,
RemoteFileNotFoundError,
RemoteFileUnavailableError,
RemoteFileUploadError,
RemoteFileUrlBlockedError,
TooManyFilesError,
UnsupportedFileTypeError,
)
from controllers.console import api as console_api
from controllers.inner_api import api as inner_api
from controllers.service_api import api as service_api
from libs.exception import BaseHTTPException
from libs.external_api import ExternalApi
from services.credentials.refresh import CredentialRefreshUnavailableError
from services.errors.base import NoPermissionError
from services.errors.workspace import WorkspaceApplicationError
@pytest.mark.parametrize("source_api", [console_api, service_api], ids=["console", "service_api"])
@pytest.mark.parametrize(
("error", "status", "code", "message"),
[
(NoPermissionError("Access denied"), 400, "invalid_param", "Access denied"),
(ValueError("Invalid input"), 400, "invalid_param", "Invalid input"),
(Forbidden("Access denied"), 403, "forbidden", "Access denied"),
(WorkspaceApplicationError("unmapped workspace failure"), 500, "unknown", "Internal Server Error"),
(RuntimeError("backend detail"), 500, "unknown", "Internal Server Error"),
],
)
def test_surface_permission_error_mapping_preserves_other_responses(
source_api: Api, error: Exception, status: int, code: str, message: str
) -> None:
app = Flask(__name__)
api = Api(app, doc=False)
# Use production registration and ordering; do not mutate the shared API instance.
api.error_handlers = source_api.error_handlers.copy()
class Endpoint(Resource):
def get(self) -> ResponseReturnValue:
raise error
api.add_resource(Endpoint, "/error")
response = app.test_client().get("/error")
assert response.status_code == status
assert response.json == {"code": code, "message": message, "status": status}
def test_permission_error_mapping_is_not_registered_on_generic_apis() -> None:
app = Flask(__name__)
api = ExternalApi(app)
class Endpoint(Resource):
def get(self) -> ResponseReturnValue:
raise NoPermissionError("internal permission detail")
api.add_resource(Endpoint, "/error")
response = app.test_client().get("/error")
assert response.status_code == 500
assert response.json == {"code": "unknown", "message": "Internal Server Error", "status": 500}
@pytest.mark.parametrize("source_api", [console_api, inner_api], ids=["console", "inner_api"])
def test_refresh_unavailability_has_one_documented_response(source_api: ExternalApi) -> None:
error = CredentialRefreshUnavailableError()
app = Flask(__name__)
api = Api(app, doc=False)
api.error_handlers = source_api.error_handlers.copy()
class Endpoint(Resource):
def get(self) -> ResponseReturnValue:
raise error
api.add_resource(Endpoint, "/error")
response = app.test_client().get("/error")
assert response.status_code == 503
assert response.json == {"code": "service_unavailable", "message": str(error), "status": 503}
assert source_api.resolve_error(CredentialRefreshUnavailableError) == (503, "service_unavailable")
class TestFilenameNotExistsError:
def test_defaults(self) -> None:
error = FilenameNotExistsError()
assert error.code == 400
assert error.error_code == "filename_not_exists_error"
assert error.description == "The specified filename does not exist."
assert error.data == {
"code": "filename_not_exists_error",
"message": "The specified filename does not exist.",
"status": 400,
}
class TestRemoteFileUploadError:
def test_defaults(self) -> None:
error = RemoteFileUploadError()
assert error.code == 400
assert error.error_code == "remote_file_upload_error"
assert error.description == "Error uploading remote file."
assert error.data == {
"code": "remote_file_upload_error",
"message": "Error uploading remote file.",
"status": 400,
}
@pytest.mark.parametrize(
("error_type", "error_code", "description", "status"),
[
(RemoteFileInvalidUrlError, "remote_file_invalid_url", "The remote file URL is invalid.", 400),
(RemoteFileUrlBlockedError, "remote_file_url_blocked", "The remote file URL is not allowed.", 400),
(RemoteFileNotFoundError, "remote_file_not_found", "The remote file could not be found.", 404),
(
RemoteFileAccessDeniedError,
"remote_file_access_denied",
"The remote file cannot be accessed without authorization.",
400,
),
(
RemoteFileUnavailableError,
"remote_file_unavailable",
"The remote file is temporarily unavailable.",
502,
),
(
RemoteFileInvalidResponseError,
"remote_file_invalid_response",
"The remote file server returned an invalid response.",
502,
),
],
)
def test_remote_file_errors(
error_type: type[BaseHTTPException],
error_code: str,
description: str,
status: int,
) -> None:
error = error_type()
assert error.code == status
assert error.error_code == error_code
assert error.description == description
assert error.data == {"code": error_code, "message": description, "status": status}
class TestFileTooLargeError:
def test_defaults(self) -> None:
error = FileTooLargeError()
assert error.code == 413
assert error.error_code == "file_too_large"
assert error.description == "File size exceeded. {message}"
class TestUnsupportedFileTypeError:
def test_defaults(self) -> None:
error = UnsupportedFileTypeError()
assert error.code == 415
assert error.error_code == "unsupported_file_type"
assert error.description == "File type not allowed."
class TestBlockedFileExtensionError:
def test_defaults(self) -> None:
error = BlockedFileExtensionError()
assert error.code == 400
assert error.error_code == "file_extension_blocked"
assert error.description == "The file extension is blocked for security reasons."
class TestTooManyFilesError:
def test_defaults(self) -> None:
error = TooManyFilesError()
assert error.code == 400
assert error.error_code == "too_many_files"
assert error.description == "Only one file is allowed."
class TestNoFileUploadedError:
def test_defaults(self) -> None:
error = NoFileUploadedError()
assert error.code == 400
assert error.error_code == "no_file_uploaded"
assert error.description == "Please upload your file."
@@ -0,0 +1,79 @@
from unittest.mock import patch
import pytest
from controllers.common.fields import Parameters, Site
from core.app.app_config.common.parameters_mapping import get_parameters_from_feature_dict
from models.model import IconType
def test_parameters_model_round_trip() -> None:
parameters = get_parameters_from_feature_dict(features_dict={}, user_input_form=[])
model = Parameters.model_validate(parameters)
assert model.model_dump(mode="json") == parameters
@pytest.mark.parametrize("enabled", [False, True])
def test_parameters_serializes_show_thoughts(enabled: bool) -> None:
parameters = get_parameters_from_feature_dict(
features_dict={"show_thoughts": {"enabled": enabled}}, user_input_form=[]
)
assert Parameters.model_validate(parameters).model_dump(mode="json")["show_thoughts"] == {"enabled": enabled}
def test_parameters_defaults_show_thoughts_for_legacy_payload() -> None:
parameters = dict(get_parameters_from_feature_dict(features_dict={}, user_input_form=[]))
parameters.pop("show_thoughts")
assert Parameters.model_validate(parameters).model_dump(mode="json")["show_thoughts"] == {"enabled": False}
def test_site_icon_url_uses_signed_url_for_image_icon() -> None:
site = Site(
title="Example",
chat_color_theme=None,
chat_color_theme_inverted=False,
icon_type=IconType.IMAGE,
icon="file-id",
icon_background=None,
description=None,
copyright=None,
privacy_policy=None,
custom_disclaimer=None,
default_language="en-US",
show_workflow_steps=True,
use_icon_as_answer_icon=False,
)
with patch("controllers.common.fields.file_helpers.get_signed_file_url", return_value="signed") as mock_helper:
model = Site.model_validate(site)
assert model.icon_url == "signed"
mock_helper.assert_called_once_with("file-id")
def test_site_icon_url_is_none_for_non_image_icon() -> None:
site = Site(
title="Example",
chat_color_theme=None,
chat_color_theme_inverted=False,
icon_type=IconType.EMOJI,
icon="file-id",
icon_background=None,
description=None,
copyright=None,
privacy_policy=None,
custom_disclaimer=None,
default_language="en-US",
show_workflow_steps=True,
use_icon_as_answer_icon=False,
)
with patch("controllers.common.fields.file_helpers.get_signed_file_url") as mock_helper:
model = Site.model_validate(site)
assert model.icon_url is None
mock_helper.assert_not_called()
@@ -0,0 +1,120 @@
from flask import Response
from controllers.common.file_response import (
_normalize_mime_type,
enforce_download_for_html,
is_html_content,
)
class TestNormalizeMimeType:
def test_returns_empty_string_for_none(self) -> None:
assert _normalize_mime_type(None) == ""
def test_returns_empty_string_for_empty_string(self) -> None:
assert _normalize_mime_type("") == ""
def test_normalizes_mime_type(self) -> None:
assert _normalize_mime_type("Text/HTML; Charset=UTF-8") == "text/html"
class TestIsHtmlContent:
def test_detects_html_via_mime_type(self) -> None:
mime_type = "text/html; charset=UTF-8"
result = is_html_content(
mime_type=mime_type,
filename="file.txt",
extension="txt",
)
assert result is True
def test_detects_html_via_extension_argument(self) -> None:
result = is_html_content(
mime_type="text/plain",
filename=None,
extension="html",
)
assert result is True
def test_detects_html_via_filename_extension(self) -> None:
result = is_html_content(
mime_type="text/plain",
filename="report.html",
extension=None,
)
assert result is True
def test_returns_false_when_no_html_detected_anywhere(self) -> None:
"""
Missing negative test:
- MIME type is not HTML
- filename has no HTML extension
- extension argument is not HTML
"""
result = is_html_content(
mime_type="application/json",
filename="data.json",
extension="json",
)
assert result is False
def test_returns_false_when_all_inputs_are_none(self) -> None:
result = is_html_content(
mime_type=None,
filename=None,
extension=None,
)
assert result is False
class TestEnforceDownloadForHtml:
def test_sets_attachment_when_filename_missing(self) -> None:
response = Response("payload", mimetype="text/html")
updated = enforce_download_for_html(
response,
mime_type="text/html",
filename=None,
extension="html",
)
assert updated is True
assert response.headers["Content-Disposition"] == "attachment"
assert response.headers["Content-Type"] == "application/octet-stream"
assert response.headers["X-Content-Type-Options"] == "nosniff"
def test_sets_headers_when_filename_present(self) -> None:
response = Response("payload", mimetype="text/html")
updated = enforce_download_for_html(
response,
mime_type="text/html",
filename="unsafe.html",
extension="html",
)
assert updated is True
assert response.headers["Content-Disposition"].startswith("attachment")
assert "unsafe.html" in response.headers["Content-Disposition"]
assert response.headers["Content-Type"] == "application/octet-stream"
assert response.headers["X-Content-Type-Options"] == "nosniff"
def test_does_not_modify_response_for_non_html_content(self) -> None:
response = Response("payload", mimetype="text/plain")
updated = enforce_download_for_html(
response,
mime_type="text/plain",
filename="notes.txt",
extension="txt",
)
assert updated is False
assert "Content-Disposition" not in response.headers
assert "X-Content-Type-Options" not in response.headers
@@ -0,0 +1,30 @@
import urllib.parse
import pytest
from controllers.common.helpers import decode_remote_url
@pytest.mark.parametrize(
("url", "query_string", "expected"),
[
(
urllib.parse.quote("https://example.com/report.txt", safe=""),
b"download=1",
"https://example.com/report.txt?download=1",
),
(
urllib.parse.quote("https://example.com/report.txt?version=1", safe=""),
"download=1",
"https://example.com/report.txt?version=1&download=1",
),
("https://example.com/report.txt?", "download=1", "https://example.com/report.txt?download=1"),
("https://example.com/report.txt", b"", "https://example.com/report.txt"),
],
)
def test_decode_remote_url(url: str, query_string: bytes | str, expected: str) -> None:
assert decode_remote_url(url, query_string) == expected
def test_decode_remote_url_defers_invalid_url_validation() -> None:
assert decode_remote_url("http://[invalid", "download=1") == "http://[invalid?download=1"
@@ -0,0 +1,400 @@
from __future__ import annotations
import pytest
from pydantic import TypeAdapter, ValidationError
from controllers.common import human_input_v2_contracts as contracts
from controllers.common.human_input import HumanInputFormSubmitPayload
from controllers.common.human_input_v2_contracts import (
BatchGetContactsQuery,
ExternalContactCreateRequest,
FormAccessRequestResponse,
IMSyncResultItem,
IMSyncRun,
ListIMIdentitiesQuery,
MessageTemplateTestRequest,
NodeDataMigrationFailureResponse,
NodeDataMigrationPayload,
NodeDataMigrationResponse,
)
from controllers.common.human_input_v2_migration import preflight_legacy_human_input_node_data
from core.workflow.nodes.human_input_v2.entities import RecipientConfig
def test_request_dto_coerces_enum_values_and_forbids_extra_fields() -> None:
request_body = MessageTemplateTestRequest.model_validate({"channel": "email", "inputs": {}})
assert request_body.channel.value == "email"
with pytest.raises(ValidationError):
MessageTemplateTestRequest.model_validate({"channel": "email", "inputs": {}, "unexpected": True})
def test_sync_run_exposes_captured_revision() -> None:
sync_run = IMSyncRun.model_validate(
{
"id": "run-id",
"status": "queued",
"result_counts": {"added": 0, "not_matched": 0, "failed": 0, "removed": 0, "skipped": 0},
"provider": "feishu",
"channel_id": "channel-id",
"channel_config_version": 4,
}
)
assert sync_run.channel_id == "channel-id"
assert sync_run.model_dump(mode="json")["channel_config_version"] == 4
def test_external_contact_avatar_is_optional() -> None:
request_body = ExternalContactCreateRequest.model_validate(
{
"name": "External Approver",
"email": "approver@example.com",
}
)
assert request_body.avatar is None
def test_node_data_migration_contract_matches_frontend_adapter_boundary() -> None:
request_body = NodeDataMigrationPayload.model_validate(
{
"nodes": [
{
"node_id": "node-1",
"node_data": {
"title": "Approval",
"version": "1",
"future_legacy_field": "ignored",
},
"future_envelope_field": "ignored",
}
],
"future_request_field": "ignored",
}
)
node_data = preflight_legacy_human_input_node_data(request_body.nodes[0].node_data).node_data
assert node_data.version == "1"
assert node_data.model_extra == {"future_legacy_field": "ignored"}
assert set(NodeDataMigrationResponse.model_json_schema()["properties"]) == {"data"}
assert contracts.LegacyHITLv1NodeData.model_json_schema()["properties"]["version"]["default"] == "1"
failure = NodeDataMigrationFailureResponse.model_validate(
{
"message": "Migration failed",
"status": 400,
"blockers": [
{
"node_id": "node-1",
"node_title": "Approval",
"code": "unresolved-member",
"method_id": "email-1",
"value": "member-1",
}
],
}
)
assert failure.blockers[0].code == "unresolved-member"
with pytest.raises(ValidationError):
NodeDataMigrationPayload.model_validate(
{
"nodes": [
{
"node_id": "node-1",
"node_data": {"title": "Approval", "version": "2"},
}
]
}
)
with pytest.raises(ValidationError):
NodeDataMigrationPayload.model_validate(
{
"nodes": [
{"node_id": "node-1", "node_data": {"title": "Approval", "version": "1"}},
{"node_id": "node-1", "node_data": {"title": "Approval", "version": "1"}},
]
}
)
def test_node_data_migration_transport_refines_invalid_delivery_methods_into_preflight_issues() -> None:
request_body = NodeDataMigrationPayload.model_validate(
{
"nodes": [
{
"node_id": "node-1",
"node_data": {
"title": "Approval",
"delivery_methods": [
{"id": "33333333-3333-4333-8333-333333333333", "type": "sms", "config": {}},
{
"id": "11111111-1111-4111-8111-111111111111",
"type": "email",
"config": {
"subject": "Subject",
"body": 7,
"recipients": {"items": [{"type": "external", "email": "invalid-email"}]},
},
},
],
},
}
]
}
)
preflight = preflight_legacy_human_input_node_data(request_body.nodes[0].node_data)
assert [(issue.code, issue.value) for issue in preflight.issues] == [
("unsupported-delivery-method", "sms"),
("invalid-email-configuration", "body"),
]
assert preflight.node_data.delivery_methods == []
def test_node_data_migration_transport_normalizes_real_and_compatibility_member_ids() -> None:
request_body = NodeDataMigrationPayload.model_validate(
{
"nodes": [
{
"node_id": "node-1",
"node_data": {
"title": "Approval",
"delivery_methods": [
{
"id": "11111111-1111-4111-8111-111111111111",
"type": "email",
"config": {
"subject": "Review",
"body": "Please review",
"recipients": {
"items": [
{"type": "member", "user_id": "member-real"},
{"type": "member", "reference_id": "member-compat"},
]
},
},
}
],
},
}
]
}
)
preflight = preflight_legacy_human_input_node_data(request_body.nodes[0].node_data)
assert preflight.issues == ()
method = preflight.node_data.delivery_methods[0]
assert method.type == "email"
assert [source.reference_id for source in method.config.recipients.items] == ["member-real", "member-compat"]
def test_node_data_migration_transport_reports_configured_unsupported_delivery_methods() -> None:
request_body = NodeDataMigrationPayload.model_validate(
{
"nodes": [
{
"node_id": "node-1",
"node_data": {
"title": "Approval",
"delivery_methods": [
{
"id": "im-1",
"type": "im",
"enabled": True,
"config": {
"provider": "slack",
"message": "Please review",
"recipients": {
"items": [
{"type": "channel", "channel_id": "channel-1"},
{"type": "user", "user_id": "user-1"},
]
},
},
},
{
"id": "future-1",
"type": "future-channel",
"enabled": False,
"config": {"message": "Configured"},
},
],
},
}
]
}
)
preflight = preflight_legacy_human_input_node_data(request_body.nodes[0].node_data)
assert [(issue.code, issue.value) for issue in preflight.issues] == [
("unsupported-delivery-method", "im"),
("unsupported-delivery-method", "future-channel"),
]
@pytest.mark.parametrize("version", ["2", "v1", 1, None])
def test_node_data_migration_rejects_every_explicit_non_v1_version(version: object) -> None:
with pytest.raises(ValidationError):
NodeDataMigrationPayload.model_validate(
{"nodes": [{"node_id": "node-1", "node_data": {"title": "Approval", "version": version}}]}
)
def test_node_data_migration_defaults_missing_version_and_requires_non_empty_batch() -> None:
request_body = NodeDataMigrationPayload.model_validate(
{"nodes": [{"node_id": "node-1", "node_data": {"title": "Approval"}}]}
)
assert preflight_legacy_human_input_node_data(request_body.nodes[0].node_data).node_data.version == "1"
with pytest.raises(ValidationError):
NodeDataMigrationPayload.model_validate({"nodes": []})
def test_node_data_migration_failure_envelope_never_serializes_partial_data() -> None:
failure = NodeDataMigrationFailureResponse.model_validate(
{
"message": "Migration failed",
"status": 400,
"blockers": [
{
"node_id": "node-1",
"node_title": "Approval",
"code": "missing-recipients",
}
],
"data": [{"node_id": "node-valid", "node_data": {}}],
}
)
assert set(failure.model_dump(mode="json")) == {"code", "message", "status", "blockers"}
def test_node_data_migration_failure_contract_exposes_invalid_default_value_blocker() -> None:
failure = NodeDataMigrationFailureResponse.model_validate(
{
"message": "Migration failed",
"status": 400,
"blockers": [
{
"node_id": "node-1",
"node_title": "Approval",
"code": "invalid-default-value",
"value": "default_value",
}
],
}
)
assert failure.blockers[0].code == "invalid-default-value"
def test_node_data_migration_marker_has_exact_typed_wire_shape() -> None:
recipient_adapter = TypeAdapter(RecipientConfig)
marker = recipient_adapter.validate_python({"type": "all_workspace_contacts"})
assert marker.model_dump(mode="json") == {"type": "all_workspace_contacts"}
with pytest.raises(ValidationError):
recipient_adapter.validate_python({"type": "all_workspace_contacts", "contact_ids": []})
response_schema = NodeDataMigrationResponse.model_json_schema()
marker_schema = response_schema["$defs"]["AllWorkspaceContacts"]
assert marker_schema["additionalProperties"] is False
assert marker_schema["properties"]["type"]["const"] == "all_workspace_contacts"
def test_node_data_migration_success_schema_forces_human_input_node_type() -> None:
request_body = NodeDataMigrationPayload.model_validate(
{
"nodes": [
{
"node_id": "node-1",
"node_data": {
"title": "Approval",
"type": "code",
"delivery_methods": [
{"id": "22222222-2222-4222-8222-222222222222", "type": "webapp", "config": {}}
],
},
}
]
}
)
response_schema = NodeDataMigrationResponse.model_json_schema()
assert not hasattr(request_body.nodes[0].node_data, "type")
assert response_schema["$defs"]["HumanInputNodeData"]["properties"]["type"]["const"] == "human-input"
@pytest.mark.parametrize(
"recipient_value",
[
{"type": "contact", "contact_id": "contact-1"},
{"type": "dynamic_email", "selector": ["node-1", "email"]},
{"type": "onetime_email", "email": "approver@example.com"},
{"type": "initiator"},
{"type": "all_workspace_contacts"},
],
)
def test_recipient_union_preserves_existing_and_migration_variants(recipient_value: dict[str, object]) -> None:
recipient = TypeAdapter(RecipientConfig).validate_python(recipient_value)
assert recipient.model_dump(mode="json") == recipient_value
def test_v1_and_v2_submit_payloads_are_independent() -> None:
v1_schema = HumanInputFormSubmitPayload.model_json_schema()
v2_schema = contracts.HumanInputV2FormSubmitRequest.model_json_schema()
assert "challenge_token" not in v1_schema["properties"]
assert "otp_code" not in v1_schema["properties"]
assert "challenge_token" in v2_schema["properties"]
assert "otp_code" in v2_schema["properties"]
def test_public_v2_submit_requires_complete_email_proof() -> None:
submit_model = contracts.HumanInputV2FormSubmitRequest
base_payload: dict[str, object] = {"inputs": {}, "action": "approve"}
submit_model.model_validate(base_payload)
submit_model.model_validate(
{
**base_payload,
"challenge_token": "challenge-token",
"otp_code": "123456",
}
)
with pytest.raises(ValidationError):
submit_model.model_validate({**base_payload, "otp_code": "123456"})
with pytest.raises(ValidationError):
submit_model.model_validate({**base_payload, "challenge_token": "challenge-token"})
def test_access_request_response_exposes_resend_cooldown() -> None:
schema = FormAccessRequestResponse.model_json_schema()
assert "resend_after_seconds" in schema["properties"]
def test_batch_get_contacts_query_forbids_extra_fields() -> None:
with pytest.raises(ValidationError):
BatchGetContactsQuery.model_validate({"contact_ids": ["contact-1"], "unexpected": True})
def test_sync_result_item_has_no_contact_type() -> None:
schema = IMSyncResultItem.model_json_schema()
assert "type" not in schema["properties"]
def test_im_identity_search_includes_provider_user_id() -> None:
keyword_description = ListIMIdentitiesQuery.model_json_schema()["properties"]["keyword"]["description"]
assert "provider user ID" in keyword_description
@@ -0,0 +1,347 @@
from importlib.util import find_spec
from uuid import UUID
import pytest
from controllers.common import human_input_v2_migration as migration_boundary
from core.workflow.human_input_adapter import EmailDeliveryMethod, MemberRecipient, WebAppDeliveryMethod
_EMAIL_METHOD_ID = "11111111-1111-4111-8111-111111111111"
_WEBAPP_METHOD_ID = "22222222-2222-4222-8222-222222222222"
def test_migration_compatibility_preflight_has_an_explicit_transport_module() -> None:
assert find_spec("controllers.common.human_input_v2_migration") is not None
def test_migration_transport_exposes_typed_preflight_api() -> None:
assert {"LegacyHITLv1NodeData", "preflight_legacy_human_input_node_data"} <= set(dir(migration_boundary))
def test_migration_transport_accepts_formal_v1_title_default() -> None:
transport = migration_boundary.LegacyHITLv1NodeData.model_validate({"delivery_methods": []})
assert migration_boundary.preflight_legacy_human_input_node_data(transport).node_data.title == ""
def test_preflight_preserves_valid_persisted_delivery_method_id() -> None:
transport_node_data = migration_boundary.LegacyHITLv1NodeData.model_validate(
{
"title": "Approval",
"delivery_methods": [{"id": _WEBAPP_METHOD_ID, "type": "webapp", "config": {}}],
}
)
preflight = migration_boundary.preflight_legacy_human_input_node_data(transport_node_data)
assert preflight.issues == ()
assert preflight.method_positions == (0,)
assert preflight.recipient_positions == ((),)
method = preflight.node_data.delivery_methods[0]
assert isinstance(method, WebAppDeliveryMethod)
assert method.id == UUID(_WEBAPP_METHOD_ID)
def test_preflight_applies_omitted_ids_and_rejects_null_or_invalid_delivery_ids() -> None:
transport_node_data = migration_boundary.LegacyHITLv1NodeData.model_validate(
{
"title": "Approval",
"delivery_methods": [
{"type": "webapp", "config": {}},
{"id": None, "type": "webapp", "config": {}},
{"id": "invalid-webapp-id", "type": "webapp", "config": {}},
{"type": "email", "enabled": False, "config": {}},
{"id": None, "type": "email", "enabled": False, "config": {}},
{"id": "invalid-email-id", "type": "email", "enabled": False, "config": {}},
{"id": _WEBAPP_METHOD_ID, "type": "webapp", "config": {}},
],
}
)
preflight = migration_boundary.preflight_legacy_human_input_node_data(transport_node_data)
assert preflight.method_positions == (0, 6)
assert len(preflight.node_data.delivery_methods) == 2
assert isinstance(preflight.node_data.delivery_methods[0].id, UUID)
assert [(issue.code, issue.method_position, issue.method_id, issue.value) for issue in preflight.issues] == [
("unsupported-delivery-method", 1, None, "webapp"),
("unsupported-delivery-method", 2, "invalid-webapp-id", "webapp"),
("unsupported-delivery-method", 4, None, "email"),
("unsupported-delivery-method", 5, "invalid-email-id", "email"),
]
@pytest.mark.parametrize(
"empty_config",
[
{},
{
"recipients": {"whole_workspace": False, "items": []},
"subject": "",
"body": "",
"debug_mode": False,
},
],
)
def test_preflight_ignores_disabled_email_with_only_default_empty_configuration(
empty_config: dict[str, object],
) -> None:
transport_node_data = migration_boundary.LegacyHITLv1NodeData.model_validate(
{
"title": "Approval",
"delivery_methods": [
{"id": _EMAIL_METHOD_ID, "type": "email", "enabled": False, "config": empty_config},
{"id": _WEBAPP_METHOD_ID, "type": "webapp", "config": {}},
],
}
)
preflight = migration_boundary.preflight_legacy_human_input_node_data(transport_node_data)
assert preflight.issues == ()
assert preflight.method_positions == (1,)
assert len(preflight.node_data.delivery_methods) == 1
assert isinstance(preflight.node_data.delivery_methods[0], WebAppDeliveryMethod)
@pytest.mark.parametrize(
("method_type", "malformed_config"),
[
("email", None),
("email", False),
("email", ""),
("email", []),
("email", 0),
("email", {"recipients": False}),
("email", {"subject": None}),
("email", {"debug_mode": None}),
("email", {"unknown": False}),
("email", {"recipients": {"items": False}}),
("email", {"recipients": {"whole_workspace": None}}),
("webapp", None),
("webapp", False),
("webapp", ""),
("webapp", []),
("webapp", 0),
],
)
def test_preflight_blocks_explicit_malformed_falsy_disabled_delivery_config(
method_type: str,
malformed_config: object,
) -> None:
transport_node_data = migration_boundary.LegacyHITLv1NodeData.model_validate(
{
"title": "Approval",
"delivery_methods": [
{
"id": _EMAIL_METHOD_ID if method_type == "email" else _WEBAPP_METHOD_ID,
"type": method_type,
"enabled": False,
"config": malformed_config,
},
{"id": _WEBAPP_METHOD_ID, "type": "webapp", "config": {}},
],
}
)
preflight = migration_boundary.preflight_legacy_human_input_node_data(transport_node_data)
assert preflight.method_positions == (1,)
assert [(issue.code, issue.method_position, issue.value) for issue in preflight.issues] == [
("configured-disabled-method", 0, method_type)
]
@pytest.mark.parametrize("include_config", [False, True], ids=["omitted-config", "empty-config"])
def test_preflight_rejects_disabled_unknown_method_before_empty_config_exemption(include_config: bool) -> None:
unknown_method: dict[str, object] = {
"id": "33333333-3333-4333-8333-333333333333",
"type": "future-channel",
"enabled": False,
}
if include_config:
unknown_method["config"] = dict[str, object]()
transport_node_data = migration_boundary.LegacyHITLv1NodeData.model_validate(
{
"title": "Approval",
"delivery_methods": [
unknown_method,
{"id": _WEBAPP_METHOD_ID, "type": "webapp", "config": {}},
],
}
)
preflight = migration_boundary.preflight_legacy_human_input_node_data(transport_node_data)
assert preflight.method_positions == (1,)
assert [(issue.code, issue.method_position, issue.method_id, issue.value) for issue in preflight.issues] == [
(
"unsupported-delivery-method",
0,
"33333333-3333-4333-8333-333333333333",
"future-channel",
)
]
@pytest.mark.parametrize(
"invalid_default",
[
{"key": "fallback", "type": "object", "value": False},
{"key": "fallback", "type": "array[number]", "value": 7},
],
)
def test_preflight_types_invalid_historical_default_values_without_constructing_invalid_canonical_state(
invalid_default: dict[str, object],
) -> None:
transport_node_data = migration_boundary.LegacyHITLv1NodeData.model_validate(
{
"title": "Approval",
"default_value": [invalid_default],
"delivery_methods": [{"id": _WEBAPP_METHOD_ID, "type": "webapp", "config": {}}],
}
)
preflight = migration_boundary.preflight_legacy_human_input_node_data(transport_node_data)
assert preflight.node_data.default_value is None
assert [(issue.code, issue.method_position, issue.method_id, issue.value) for issue in preflight.issues] == [
("invalid-default-value", None, None, "default_value")
]
def test_preflight_normalizes_compatibility_aliases_before_constructing_canonical_v1() -> None:
transport_node_data = migration_boundary.LegacyHITLv1NodeData.model_validate(
{
"title": "Approval",
"delivery_methods": [
{
"id": _EMAIL_METHOD_ID,
"type": "email",
"config": {
"subject": "Review",
"body": "Please review",
"recipients": {
"include_bound_group": True,
"items": [{"type": "member", "reference_id": "member-1"}],
},
},
}
],
}
)
preflight = migration_boundary.preflight_legacy_human_input_node_data(transport_node_data)
assert preflight.issues == ()
assert preflight.method_positions == (0,)
method = preflight.node_data.delivery_methods[0]
assert isinstance(method, EmailDeliveryMethod)
assert isinstance(method.id, UUID)
assert method.config.recipients.include_bound_group is True
assert isinstance(method.config.recipients.items[0], MemberRecipient)
assert method.config.recipients.items[0].reference_id == "member-1"
assert "user_id" not in method.model_dump_json()
assert "whole_workspace" not in method.model_dump_json()
def test_preflight_returns_ordered_typed_issues_without_constructing_invalid_methods() -> None:
transport_node_data = migration_boundary.LegacyHITLv1NodeData.model_validate(
{
"title": "Approval",
"delivery_methods": [
{
"id": "33333333-3333-4333-8333-333333333333",
"type": "im",
"config": {"provider": "slack", "message": "Review"},
},
{
"id": "44444444-4444-4444-8444-444444444444",
"type": "future-channel",
"enabled": False,
"config": {"message": "Configured"},
},
{
"id": _EMAIL_METHOD_ID,
"type": "email",
"config": {
"subject": "Review",
"body": "Please review",
"recipients": [{"type": "user", "user_id": "user-1"}],
},
},
{"id": _WEBAPP_METHOD_ID, "type": "webapp", "config": {}},
],
}
)
preflight = migration_boundary.preflight_legacy_human_input_node_data(transport_node_data)
assert preflight.method_positions == (3,)
assert len(preflight.node_data.delivery_methods) == 1
assert isinstance(preflight.node_data.delivery_methods[0], WebAppDeliveryMethod)
assert [(issue.code, issue.method_position, issue.method_id, issue.value) for issue in preflight.issues] == [
("unsupported-delivery-method", 0, "33333333-3333-4333-8333-333333333333", "im"),
("unsupported-delivery-method", 1, "44444444-4444-4444-8444-444444444444", "future-channel"),
("invalid-email-configuration", 2, _EMAIL_METHOD_ID, "recipients"),
]
assert all(type(issue).__name__ == "LegacyDeliveryParseIssue" for issue in preflight.issues)
def test_preflight_types_malformed_recipients_without_discarding_valid_recipient_state() -> None:
transport_node_data = migration_boundary.LegacyHITLv1NodeData.model_validate(
{
"title": "Approval",
"delivery_methods": [
{
"id": _EMAIL_METHOD_ID,
"type": "email",
"config": {
"subject": "Review",
"body": "Please review",
"recipients": {
"items": [
{"type": "external", "email": 7},
{"type": "member"},
{"type": "external", "email": "approver@example.com"},
]
},
},
}
],
}
)
preflight = migration_boundary.preflight_legacy_human_input_node_data(transport_node_data)
assert [(issue.code, issue.method_id, issue.value) for issue in preflight.issues] == [
("invalid-email", _EMAIL_METHOD_ID, None),
("unresolved-member", _EMAIL_METHOD_ID, None),
]
assert [issue.recipient_position for issue in preflight.issues] == [0, 1]
assert preflight.recipient_positions == ((2,),)
method = preflight.node_data.delivery_methods[0]
assert isinstance(method, EmailDeliveryMethod)
assert [recipient.model_dump(mode="json") for recipient in method.config.recipients.items] == [
{"type": "external", "email": "approver@example.com"}
]
@pytest.mark.parametrize("input_type", ["text_input", "paragraph"])
@pytest.mark.parametrize("default_type", ["constant", "variable"])
def test_historical_paragraph_alias_preserves_both_default_sources(input_type: str, default_type: str) -> None:
from core.workflow.nodes.human_input_v2.migration import MemberEmailSnapshot, convert_legacy_human_input_node_data
default = {"type": default_type, "selector": ["start", "reason"], "value": " Previous value "}
transport = migration_boundary.LegacyHITLv1NodeData.model_validate(
{
"title": "Historical paragraph",
"delivery_methods": [{"id": _WEBAPP_METHOD_ID, "type": "webapp", "config": {}}],
"inputs": [{"type": input_type, "output_variable_name": "reason", "default": default}],
}
)
preflight = migration_boundary.preflight_legacy_human_input_node_data(transport)
converted = convert_legacy_human_input_node_data(preflight.node_data, MemberEmailSnapshot())
assert converted.node_data is not None
assert converted.node_data.model_dump(mode="json")["inputs"] == [
{"type": "paragraph", "output_variable_name": "reason", "default": default}
]
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,144 @@
from __future__ import annotations
from collections.abc import Generator
from contextlib import contextmanager
from typing import NoReturn
from unittest.mock import patch
import pytest
from sqlalchemy import event, literal, select
from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session, sessionmaker
from controllers.common import session as session_module
from models import Tenant
@contextmanager
def _bind_session_factory(session: Session) -> Generator[None]:
database_session_factory = sessionmaker(
bind=session.get_bind(),
expire_on_commit=False,
)
with patch("core.db.session_factory._session_maker", database_session_factory):
yield
def _tenant_names(session: Session) -> list[str]:
session.expire_all()
return list(session.scalars(select(Tenant.name).order_by(Tenant.name)).all())
@pytest.mark.parametrize("sqlite_session", [(Tenant,)], indirect=True)
def test_with_session_write_commits_on_success(sqlite_session: Session) -> None:
commit_observed = False
injected_session: Session | None = None
class Handler:
@session_module.with_session(write=True)
def post(self, session: Session) -> str:
nonlocal commit_observed, injected_session
injected_session = session
def observe_commit(_session: Session) -> None:
nonlocal commit_observed
commit_observed = True
event.listen(session, "after_commit", observe_commit)
session.add(Tenant(name="committed tenant"))
return "ok"
with _bind_session_factory(sqlite_session):
assert Handler().post() == "ok"
assert commit_observed
assert injected_session is not None
assert not injected_session.in_transaction()
assert _tenant_names(sqlite_session) == ["committed tenant"]
@pytest.mark.parametrize("sqlite_session", [(Tenant,)], indirect=True)
def test_with_session_default_write_commits_on_success(sqlite_session: Session) -> None:
class Handler:
@session_module.with_session
def post(self, session: Session) -> str:
session.add(Tenant(name="default write tenant"))
return "ok"
with _bind_session_factory(sqlite_session):
assert Handler().post() == "ok"
assert _tenant_names(sqlite_session) == ["default write tenant"]
@pytest.mark.parametrize("sqlite_session", [(Tenant,)], indirect=True)
def test_with_session_write_rolls_back_on_error(sqlite_session: Session) -> None:
rollback_observed = False
injected_session: Session | None = None
class Handler:
@session_module.with_session(write=True)
def get(self, session: Session) -> NoReturn:
nonlocal rollback_observed, injected_session
injected_session = session
def observe_rollback(_session: Session) -> None:
nonlocal rollback_observed
rollback_observed = True
event.listen(session, "after_rollback", observe_rollback)
session.add(Tenant(name="rolled back tenant"))
session.flush()
raise RuntimeError("boom")
with _bind_session_factory(sqlite_session), pytest.raises(RuntimeError, match="boom"):
Handler().get()
assert rollback_observed
assert injected_session is not None
assert not injected_session.in_transaction()
assert _tenant_names(sqlite_session) == []
def test_with_session_write_allows_commit_then_more_database_work(sqlite_engine: Engine) -> None:
with Session(sqlite_engine) as sqlite_session, _bind_session_factory(sqlite_session):
class Handler:
@session_module.with_session
def post(self, session: Session) -> int | None:
session.commit()
return session.scalar(select(literal(1)))
assert Handler().post() == 1
@pytest.mark.parametrize("sqlite_session", [(Tenant,)], indirect=True)
def test_with_session_read_mode_does_not_commit(sqlite_session: Session) -> None:
injected_session: Session | None = None
class Handler:
@session_module.with_session(write=False)
def get(self, session: Session) -> str:
nonlocal injected_session
injected_session = session
session.add(Tenant(name="uncommitted read tenant"))
session.flush()
return "ok"
with _bind_session_factory(sqlite_session):
assert Handler().get() == "ok"
assert injected_session is not None
assert not injected_session.in_transaction()
assert _tenant_names(sqlite_session) == []
def test_with_session_preserves_wrapped_metadata() -> None:
class Handler:
@session_module.with_session
def get(self, _session: Session) -> str:
"""handler docs"""
return "ok"
assert Handler.get.__name__ == "get"
assert Handler.get.__doc__ == "handler docs"
@@ -0,0 +1,163 @@
"""Application dependencies shared by controller tests."""
import sys
from collections.abc import Iterator
from dataclasses import dataclass
from functools import cache
from types import SimpleNamespace
from unittest.mock import create_autospec
import pytest
from flask import Flask, Response, request_finished
from sqlalchemy.orm import Session, sessionmaker
from core.app.apps.pipeline.pipeline_generator import PipelineGenerator
from extensions.application_services.app import AppServices
from extensions.ext_application_services import (
_batch_get_enterprise_webapp_access_modes,
_batch_get_enterprise_webapp_user_permissions,
)
from repositories.webapp_access_query_repository import WebAppAccessQueryRepository
from services.app.console_service import ConsoleAppService
from services.app.export_service import AppExportService
from services.app.import_service import AppImportService
from services.app.query_service import AppDiscoveryService
from services.credentials.query import CredentialQuery
from services.data_source.provider_service import DatasourceProviderService
from services.enterprise.enterprise_service import EnterpriseService
from services.tag_application_service import TagApplicationService
from services.webapp_access_adapters import EnterpriseWebAppAccessPolicyGateway
from services.webapp_access_query_service import WebAppAccessQueryService
from services.workflow.dsl_import import DslImportService
from tests.helpers.unit.controllers.error_contract import check_response, track_external_apis
track_external_apis()
def pytest_configure(config: pytest.Config) -> None:
config.addinivalue_line(
"markers",
"allow_error_contract_violations: the test serves contract-violating error responses on purpose",
)
@pytest.fixture(autouse=True)
def error_response_contract(request: pytest.FixtureRequest) -> Iterator[None]:
"""Fail a test whose served error responses contradict the documented error contract."""
if request.node.get_closest_marker("allow_error_contract_violations"):
yield
return
violations: list[str] = []
def receiver(sender: Flask, response: Response, **_: object) -> None:
check_response(sender, response, violations)
request_finished.connect(receiver)
try:
yield
finally:
request_finished.disconnect(receiver)
if violations:
pytest.fail("error responses contradict the documented contract:\n" + "\n".join(violations))
@pytest.fixture(autouse=True)
def datasource_application_dependencies(monkeypatch: pytest.MonkeyPatch) -> None:
# Most controller tests never use these services. Build the mock on demand,
# with a fresh cache for each test to preserve mock isolation.
@cache
def application_services() -> SimpleNamespace:
return SimpleNamespace(
data_sources=SimpleNamespace(
providers=create_autospec(DatasourceProviderService, instance=True, spec_set=True)
)
)
for name in (
"controllers.console.datasets.rag_pipeline.rag_pipeline_workflow",
"controllers.console.datasets.rag_pipeline.datasource_content_preview",
"controllers.console.datasets.website",
):
module = sys.modules.get(name)
if module is not None:
monkeypatch.setattr(module, "application_services", application_services)
@dataclass(frozen=True)
class PipelineKnowledgeStub:
pipeline_generator: PipelineGenerator
@dataclass(frozen=True)
class PipelineDataSourceStub:
providers: DatasourceProviderService
@dataclass(frozen=True)
class PipelineApplicationStub:
knowledge: PipelineKnowledgeStub
credential_queries: CredentialQuery
data_sources: PipelineDataSourceStub
@pytest.fixture
def pipeline_application(monkeypatch: pytest.MonkeyPatch) -> PipelineGenerator:
from controllers.console.datasets.rag_pipeline import rag_pipeline_workflow as console_workflow
from controllers.service_api.dataset.rag_pipeline import rag_pipeline_workflow as service_api_workflow
generator = create_autospec(PipelineGenerator, instance=True, spec_set=True)
registry = PipelineApplicationStub(
knowledge=PipelineKnowledgeStub(pipeline_generator=generator),
credential_queries=create_autospec(CredentialQuery, instance=True, spec_set=True),
data_sources=PipelineDataSourceStub(
providers=create_autospec(DatasourceProviderService, instance=True, spec_set=True)
),
)
monkeypatch.setattr(console_workflow, "application_services", lambda: registry)
monkeypatch.setattr(service_api_workflow, "application_services", lambda: registry)
return generator
@dataclass
class AppQueryTestServices:
console: ConsoleAppService
imports: AppImportService
exports: AppExportService
dsl_imports: DslImportService
discovery: AppDiscoveryService
@dataclass(frozen=True)
class ControllerTestServices:
apps: AppQueryTestServices
tags: TagApplicationService
webapp_access: WebAppAccessQueryService
@pytest.fixture
def app_query_services(
app_services: AppServices,
application_tags: TagApplicationService,
app: Flask,
sqlite_session_factory: sessionmaker[Session],
monkeypatch: pytest.MonkeyPatch,
) -> ControllerTestServices:
services = ControllerTestServices(
tags=application_tags,
apps=AppQueryTestServices(
console=app_services.console,
imports=app_services.imports,
exports=app_services.exports,
dsl_imports=app_services.dsl_imports,
discovery=app_services.discovery,
),
webapp_access=WebAppAccessQueryService(
access=WebAppAccessQueryRepository(session_factory=sqlite_session_factory),
webapp_auth_enabled=True,
policy=EnterpriseWebAppAccessPolicyGateway(webapp_auth=EnterpriseService.WebAppAuth),
get_access_modes=_batch_get_enterprise_webapp_access_modes,
get_user_permissions=_batch_get_enterprise_webapp_user_permissions,
),
)
monkeypatch.setitem(app.extensions, "application_services", services)
return services
Whitespace-only changes.
@@ -0,0 +1,37 @@
from unittest.mock import MagicMock
from uuid import UUID
import pytest
from sqlalchemy.orm import Session
from controllers.console.agent import app_helpers
from models.model import App, AppMode
from tests.helpers.unit.model_factories import make_app
def _app() -> App:
return make_app(name="Agent App", mode=AppMode.AGENT, icon_type=None)
def test_resolve_agent_runtime_app_model_reuses_caller_session(
monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
session = unbound_session
app = _app()
service = MagicMock()
service.get_agent_runtime_app_model.return_value = app
service_factory = MagicMock(return_value=service)
monkeypatch.setattr(app_helpers, "AgentRosterService", service_factory)
result = app_helpers.resolve_agent_runtime_app_model(
session=session,
tenant_id="tenant-1",
agent_id=UUID("00000000-0000-0000-0000-000000000001"),
)
assert result is app
service_factory.assert_called_once_with(session)
service.get_agent_runtime_app_model.assert_called_once_with(
tenant_id="tenant-1",
agent_id="00000000-0000-0000-0000-000000000001",
)
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,299 @@
import inspect
from collections.abc import Callable
from dataclasses import dataclass, field, replace
from datetime import UTC, datetime
from uuid import UUID
import pytest
from flask import Flask
from pydantic import ValidationError
from werkzeug.exceptions import Forbidden, NotFound
from controllers.common.rbac import AgentId, RBACCheck
from controllers.console import flask_admission
from controllers.console.agent import tracing
from controllers.console.app.app import AppTracePayload
from extensions.ext_application_services import ApplicationServices
from libs.login import AccountWithTenant
from machinery.context import RequestContext
from models.account import Account, AccountStatus, TenantAccountRole
from services.app.agent_app_contracts import AgentAppNotFoundError
from services.app_tracing_config_service import AppTraceSettings, AppTracingConfigRecord
from services.tracing.provider_configs import TraceProviderCapabilitiesQuery
from services.tracing.registry import EntryPointTraceProviderCatalog
from tests.helpers.unit.config_override import apply_config_overrides
"""Agent tracing Console contracts and authorization stay separate from PlainApp."""
AGENT_ID = UUID("1fbc2f02-f7e0-4910-9032-cbe5bf6c65d5")
CONTEXT = RequestContext("request", None, "account", "tenant")
@dataclass
class ConfigCase:
services: ApplicationServices
calls: list[tuple[object, ...]] = field(default_factory=list)
record: AppTracingConfigRecord | None = None
failure: Exception | None = None
def _collect_agent_traces(monkeypatch: pytest.MonkeyPatch, case: ConfigCase, *, enabled: bool) -> None:
"""Serve the case's services from a deployment that collects Agent traces or not."""
capabilities = TraceProviderCapabilitiesQuery(
providers=EntryPointTraceProviderCatalog(), api_collection_enabled=enabled
)
services = replace(case.services, tracing=replace(case.services.tracing, provider_capabilities=capabilities))
monkeypatch.setattr(tracing, "application_services", lambda: services)
class TestTracingCases:
@staticmethod
@pytest.fixture
def service(monkeypatch: pytest.MonkeyPatch, account_application_services: ApplicationServices) -> ConfigCase:
case = ConfigCase(account_application_services)
target = account_application_services.agent_tracing_configs
def get_trace(context: RequestContext, agent_id: str) -> AppTraceSettings:
case.calls.append(("get_trace", context, agent_id))
if case.failure is not None:
raise case.failure
return AppTraceSettings()
def set_trace(context: RequestContext, agent_id: str, settings: AppTraceSettings) -> None:
case.calls.append(("set_trace", context, agent_id, settings))
def get(context: RequestContext, agent_id: str, provider: str) -> AppTracingConfigRecord | None:
case.calls.append(("get", context, agent_id, provider))
return case.record
def delete(context: RequestContext, agent_id: str, provider: str) -> None:
case.calls.append(("delete", context, agent_id, provider))
monkeypatch.setattr(target, "get_trace", get_trace)
monkeypatch.setattr(target, "set_trace", set_trace)
monkeypatch.setattr(target, "get", get)
monkeypatch.setattr(target, "delete", delete)
monkeypatch.setattr(tracing, "application_services", lambda: account_application_services)
return case
@staticmethod
def test_status_round_trips_content_policy(app: Flask, service: ConfigCase) -> None:
with app.test_request_context(
json={"enabled": True, "tracing_provider": "langfuse", "capture_content": True, "capture_agent": False}
):
result = inspect.unwrap(tracing.AgentTraceApi.post)(tracing.AgentTraceApi(), CONTEXT, AGENT_ID)
assert result == {
"enabled": True,
"tracing_provider": "langfuse",
"capture_content": True,
"capture_agent": False,
}
assert service.calls == [("set_trace", CONTEXT, str(AGENT_ID), AppTraceSettings(True, "langfuse", True, False))]
@staticmethod
def test_enable_requires_provider_even_when_field_omitted() -> None:
with pytest.raises(ValidationError, match="tracing_provider is required"):
AppTracePayload.model_validate({"enabled": True})
payload = AppTracePayload.model_validate({"enabled": False})
assert payload.capture_content is False
assert payload.capture_agent is True
@staticmethod
@pytest.mark.parametrize("enabled", [False, True])
def test_capabilities_reports_current_api_gate_without_claiming_runtime_delivery(
app: Flask, service: ConfigCase, monkeypatch: pytest.MonkeyPatch, enabled: bool
) -> None:
_collect_agent_traces(monkeypatch, service, enabled=enabled)
with app.test_request_context("/?tracing_provider=langfuse"):
result = inspect.unwrap(tracing.AgentTraceCapabilitiesApi.get)(
tracing.AgentTraceCapabilitiesApi(), CONTEXT, AGENT_ID
)
assert service.calls == [("get_trace", CONTEXT, str(AGENT_ID))]
assert result["api_collection_enabled"] is enabled
assert result["agent_spans"] is True
assert result["export_ack"] == "accepted"
assert "runtime_enabled" not in result
assert "queryable" not in result
@staticmethod
@pytest.mark.parametrize("enabled", [False, True])
def test_app_capabilities_reports_api_gate(
app: Flask, monkeypatch: pytest.MonkeyPatch, enabled: bool, service: ConfigCase
) -> None:
calls: list[tuple[RequestContext, str]] = []
def get_trace(context: RequestContext, app_id: str) -> AppTraceSettings:
calls.append((context, app_id))
return AppTraceSettings()
monkeypatch.setattr(service.services.apps.console, "get_trace", get_trace)
_collect_agent_traces(monkeypatch, service, enabled=enabled)
with app.test_request_context("/?tracing_provider=mlflow"):
result = inspect.unwrap(tracing.AppTraceCapabilitiesApi.get)(
tracing.AppTraceCapabilitiesApi(), CONTEXT, AGENT_ID
)
assert result["api_collection_enabled"] is enabled
assert result["provider"] == "mlflow"
assert calls == [(CONTEXT, str(AGENT_ID))]
@staticmethod
def test_get_config_absent_and_delete_has_no_body(app: Flask, service: ConfigCase) -> None:
with app.test_request_context("/?tracing_provider=langfuse"):
assert inspect.unwrap(tracing.AgentTraceConfigApi.get)(
tracing.AgentTraceConfigApi(), CONTEXT, AGENT_ID
) == {"has_not_configured": True}
assert inspect.unwrap(tracing.AgentTraceConfigApi.delete)(
tracing.AgentTraceConfigApi(), CONTEXT, AGENT_ID
) == (
"",
204,
)
assert service.calls == [
("get", CONTEXT, str(AGENT_ID), "langfuse"),
("delete", CONTEXT, str(AGENT_ID), "langfuse"),
]
@staticmethod
def test_invalid_agent_returns_not_found(app: Flask, service: ConfigCase) -> None:
service.failure = AgentAppNotFoundError()
with app.test_request_context(), pytest.raises(NotFound):
inspect.unwrap(tracing.AgentTraceApi.get)(tracing.AgentTraceApi(), CONTEXT, AGENT_ID)
@staticmethod
@pytest.mark.parametrize(
"method",
[
tracing.AgentTraceApi.post,
tracing.AgentTraceConfigApi.get,
tracing.AgentTraceConfigApi.post,
tracing.AgentTraceConfigApi.patch,
tracing.AgentTraceConfigApi.delete,
],
)
@pytest.mark.parametrize("rbac_enabled", [False, True])
def test_config_requires_editor_role_or_agent_edit_permission(
app: Flask, monkeypatch: pytest.MonkeyPatch, method: Callable[..., object], rbac_enabled: bool
) -> None:
account = Account(name="Reader", email="reader@example.com", status=AccountStatus.ACTIVE)
account.id, account.role = "account", TenantAccountRole.NORMAL
apply_config_overrides(monkeypatch, RBAC_ENABLED=rbac_enabled)
monkeypatch.setattr(
flask_admission,
"current_account_with_tenant",
lambda: AccountWithTenant(account=account, tenant_id="tenant"),
)
denied_calls: list[dict[str, object]] = []
def denied(**kwargs: object) -> None:
denied_calls.append(kwargs)
raise Forbidden()
monkeypatch.setattr(flask_admission, "enforce_rbac_checks", denied)
admission = inspect.unwrap(
method, stop=lambda candidate: "allowed_roles" in inspect.getclosurevars(candidate).nonlocals
)
with app.test_request_context(), pytest.raises(Forbidden):
admission(None, agent_id=AGENT_ID)
if rbac_enabled:
checks = denied_calls[0]["checks"]
assert isinstance(checks, (list, tuple))
(check,) = checks
assert isinstance(check, RBACCheck)
assert check.scene == tracing.RBACPermission.AGENT_EDIT
assert isinstance(check.locator, AgentId)
assert denied_calls[0]["path_args"] == {"agent_id": AGENT_ID}
else:
assert denied_calls == []
@staticmethod
def test_read_settings_and_masked_config_keep_agent_identity(app: Flask, service: ConfigCase) -> None:
now = datetime(2026, 1, 1, tzinfo=UTC)
service.record = AppTracingConfigRecord(
id="config",
app_id="backing-app",
tracing_provider="langfuse",
tracing_config={"secret_key": "[__HIDDEN__]", "project_url": "https://example.test/project"},
is_active=True,
created_at=now,
updated_at=now,
)
with app.test_request_context("/?tracing_provider=langfuse"):
settings = inspect.unwrap(tracing.AgentTraceApi.get)(tracing.AgentTraceApi(), CONTEXT, AGENT_ID)
config = inspect.unwrap(tracing.AgentTraceConfigApi.get)(tracing.AgentTraceConfigApi(), CONTEXT, AGENT_ID)
assert settings == {"enabled": False, "tracing_provider": None, "capture_content": False, "capture_agent": True}
assert config["tracing_config"] == service.record.tracing_config
assert config["app_id"] == "backing-app"
assert service.calls == [("get_trace", CONTEXT, str(AGENT_ID)), ("get", CONTEXT, str(AGENT_ID), "langfuse")]
@staticmethod
@pytest.mark.parametrize("create", [True, False])
@pytest.mark.parametrize("activate", [False, True])
def test_config_write_forwards_credentials_but_response_does_not_echo_them(
app: Flask, service: ConfigCase, monkeypatch: pytest.MonkeyPatch, create: bool, activate: bool
) -> None:
calls: list[tuple[RequestContext, str, str, dict[str, object], bool]] = []
def write(
context: RequestContext, agent_id: str, provider: str, config: dict[str, object], *, activate: bool
) -> None:
calls.append((context, agent_id, provider, config, activate))
target = service.services.agent_tracing_configs
monkeypatch.setattr(target, "create" if create else "update", write)
credentials = {"secret_key": "never-echo-this-secret"}
with app.test_request_context(
method="POST" if create else "PATCH",
json={"tracing_provider": "langfuse", "tracing_config": credentials, "activate": activate},
):
api = tracing.AgentTraceConfigApi()
result = inspect.unwrap(api.post if create else api.patch)(api, CONTEXT, AGENT_ID)
assert calls == [(CONTEXT, str(AGENT_ID), "langfuse", credentials, activate)]
assert result == (({"result": "success"}, 201) if create else {"result": "success"})
assert "never-echo-this-secret" not in str(result)
@staticmethod
@pytest.mark.parametrize(
("error", "expected"),
[
(tracing.ConsoleAppNotFoundError(), NotFound),
(tracing.AppTracingConfigAppNotFoundError(), tracing.AppNotFoundError),
(tracing.AppTracingConfigAlreadyExistsError(), tracing.TracingConfigAlreadyExistsError),
(tracing.AppTracingConfigNotFoundError(), tracing.TracingConfigNotFoundError),
(tracing.AppTracingConfigConflictError(), tracing.TracingConfigConflictError),
(
tracing.AppTracingConfigInvalidProviderError("private-provider-secret"),
tracing.UnsupportedTracingProviderError,
),
(tracing.AppTracingConfigProviderUnavailableError(), tracing.TracingProviderUnavailableError),
(tracing.AppTracingConfigInvalidConfigurationError(), tracing.InvalidTracingConfigError),
(tracing.AppTracingConfigVerificationFailedError(), tracing.TracingConfigVerificationFailedError),
(tracing.AppTracingConfigProcessingError(), tracing.TracingConfigProcessingError),
],
)
def test_config_domain_errors_use_public_contract_without_provider_details(
app: Flask, service: ConfigCase, error: Exception, expected: type[Exception]
) -> None:
service.failure = error
with app.test_request_context(), pytest.raises(expected) as caught:
inspect.unwrap(tracing.AgentTraceApi.get)(tracing.AgentTraceApi(), CONTEXT, AGENT_ID)
assert "private-provider-secret" not in str(caught.value)
@staticmethod
def test_unknown_capability_and_missing_app_return_public_errors(
app: Flask, service: ConfigCase, monkeypatch: pytest.MonkeyPatch
) -> None:
with (
app.test_request_context("/?tracing_provider=unknown"),
pytest.raises(tracing.UnsupportedTracingProviderError),
):
inspect.unwrap(tracing.AgentTraceCapabilitiesApi.get)(
tracing.AgentTraceCapabilitiesApi(), CONTEXT, AGENT_ID
)
def missing(_context: RequestContext, _app_id: str) -> AppTraceSettings:
raise tracing.ConsoleAppNotFoundError()
monkeypatch.setattr(service.services.apps.console, "get_trace", missing)
with app.test_request_context("/?tracing_provider=langfuse"), pytest.raises(NotFound):
inspect.unwrap(tracing.AppTraceCapabilitiesApi.get)(tracing.AppTraceCapabilitiesApi(), CONTEXT, AGENT_ID)
@@ -0,0 +1,308 @@
"""Run tracing endpoints preserve resource ownership, acknowledgement and error contracts."""
import inspect
from collections.abc import Callable
from dataclasses import dataclass, field, replace
from datetime import UTC, datetime, timedelta, timezone
from functools import wraps
from uuid import UUID
import pytest
from flask import Flask
from flask_restx import Resource
from pydantic import ValidationError
from werkzeug.exceptions import Forbidden, NotFound
from controllers.common.rbac import AgentId, PlainApp, RBACCheck
from controllers.console import flask_admission
from controllers.console.agent import tracing_runs
from domain.tracing.trace_run_agg import TraceRunState, TraceSourceKind
from extensions.ext_application_services import ApplicationServices
from libs.external_api import ExternalApi
from libs.login import AccountWithTenant
from machinery.context import RequestContext
from models.account import Account, AccountStatus, TenantAccountRole
from services.app.agent_app_contracts import AgentAppNotFoundError
from services.tracing.collection import TraceRunStatus
from services.tracing.errors import TraceCollectionConflictError, TraceCollectionError, TraceCollectionNotFoundError
from tests.helpers.unit.config_override import apply_config_overrides
CONTEXT = RequestContext("request", None, "account", "tenant")
AGENT_ID = UUID("01a11111-1111-7111-8111-111111111111")
APP_ID = UUID("01a22222-2222-7222-8222-222222222222")
SOURCE_ID = UUID("01a33333-3333-7333-8333-333333333333")
NODE_ID = UUID("01a44444-4444-7444-8444-444444444444")
NOT_COLLECTED = TraceRunStatus(
status=TraceRunState.NOT_COLLECTED,
source_kind="message",
source_id=str(SOURCE_ID),
provider=None,
trace_id=None,
trace_url=None,
span_url=None,
project_url=None,
config_revision=None,
capture_content=None,
capture_agent=None,
span_count=None,
attempts=None,
error_code=None,
accepted_at=None,
capabilities=None,
)
@dataclass
class RunCase:
services: ApplicationServices
"""The composition root the handlers resolve; its Agent trace runs answer with ``response``."""
owner_calls: list[tuple[RequestContext, str]] = field(default_factory=list)
status_calls: list[dict[str, object]] = field(default_factory=list)
retry_calls: list[dict[str, object]] = field(default_factory=list)
response: TraceRunStatus = NOT_COLLECTED
owner_error: Exception | None = None
retry_error: Exception | None = None
@pytest.fixture
def services(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
account_application_services: ApplicationServices,
) -> RunCase:
case = RunCase(account_application_services)
def resolve(context: RequestContext, agent_id: str) -> str:
case.owner_calls.append((context, agent_id))
if case.owner_error is not None:
raise case.owner_error
return str(APP_ID)
def status(**kwargs: object) -> TraceRunStatus:
case.status_calls.append(kwargs)
return case.response
def retry(**kwargs: object) -> TraceRunStatus:
case.retry_calls.append(kwargs)
if case.retry_error is not None:
raise case.retry_error
return replace(case.response, status=TraceRunState.RETRYING)
runs = account_application_services.tracing.agent_traces
monkeypatch.setattr(account_application_services.agent_tracing_configs, "resolve_app_id", resolve)
monkeypatch.setattr(runs, "status", status)
monkeypatch.setattr(runs, "retry", retry)
monkeypatch.setitem(app.extensions, "application_services", account_application_services)
return case
@pytest.mark.parametrize(
"accepted_at",
[
datetime(2026, 1, 1),
datetime(2026, 1, 1, tzinfo=UTC),
datetime(2026, 1, 1, 8, tzinfo=timezone(timedelta(hours=8))),
],
)
def test_agent_status_resolves_owner_and_never_exposes_destination_secrets(
app: Flask, services: RunCase, accepted_at: datetime
) -> None:
services.response = replace(
services.response,
status=TraceRunState.ACCEPTED,
provider="langfuse",
trace_id="trace-id",
trace_url="https://example.com/trace",
project_url="https://example.com/project/frozen",
accepted_at=accepted_at,
config_revision="frozen-revision",
)
with app.test_request_context(f"/?node_execution_id={NODE_ID}"):
result = inspect.unwrap(tracing_runs.AgentTraceRunApi.get)(
tracing_runs.AgentTraceRunApi(), CONTEXT, AGENT_ID, SOURCE_ID
)
assert services.owner_calls == [(CONTEXT, str(AGENT_ID))]
assert services.status_calls == [
{
"tenant_id": "tenant",
"app_id": str(APP_ID),
"source_kind": "message",
"source_id": str(SOURCE_ID),
"node_execution_id": str(NODE_ID),
}
]
assert result["accepted_at"] == "2026-01-01T00:00:00Z"
assert result["queryable"] is None
assert result["config_revision"] == "frozen-revision"
assert result["project_url"] == "https://example.com/project/frozen"
assert "provider_config" not in result
@pytest.mark.parametrize("kind", ["message", "workflow", "node"])
def test_app_status_source_scope_and_not_collected(app: Flask, services: RunCase, kind: TraceSourceKind) -> None:
services.response = replace(services.response, source_kind=kind)
with app.test_request_context():
result = inspect.unwrap(tracing_runs.AppTraceRunApi.get)(
tracing_runs.AppTraceRunApi(), CONTEXT, APP_ID, kind, SOURCE_ID
)
assert services.owner_calls == []
assert result["status"] == "not_collected"
assert result["project_url"] is None
assert services.status_calls == [
{
"tenant_id": "tenant",
"app_id": str(APP_ID),
"source_kind": kind,
"source_id": str(SOURCE_ID),
"node_execution_id": None,
}
]
@pytest.mark.parametrize("ack", [False, True])
@pytest.mark.parametrize("agent", [False, True])
def test_retry_forwards_only_frozen_run_identity_and_explicit_ack(
app: Flask, services: RunCase, ack: bool, agent: bool
) -> None:
with app.test_request_context(
f"/?node_execution_id={NODE_ID}", method="POST", json={"acknowledge_possible_duplicates": ack} if ack else {}
):
if agent:
result = inspect.unwrap(tracing_runs.AgentTraceRunRetryApi.post)(
tracing_runs.AgentTraceRunRetryApi(), CONTEXT, AGENT_ID, SOURCE_ID
)
else:
result = inspect.unwrap(tracing_runs.AppTraceRunRetryApi.post)(
tracing_runs.AppTraceRunRetryApi(), CONTEXT, APP_ID, "message", SOURCE_ID
)
assert result["status"] == "retrying"
assert services.retry_calls == [
{
"tenant_id": "tenant",
"app_id": str(APP_ID),
"source_kind": "message",
"source_id": str(SOURCE_ID),
"node_execution_id": str(NODE_ID),
"acknowledge_possible_duplicates": ack,
}
]
@pytest.mark.parametrize("payload", [{"provider": "different-provider"}, {"acknowledge_possible_duplicates": "true"}])
def test_retry_rejects_destination_changes_and_non_boolean_ack(
app: Flask, services: RunCase, payload: dict[str, str]
) -> None:
with app.test_request_context(method="POST", json=payload), pytest.raises(ValidationError):
inspect.unwrap(tracing_runs.AppTraceRunRetryApi.post)(
tracing_runs.AppTraceRunRetryApi(), CONTEXT, APP_ID, "message", SOURCE_ID
)
assert services.retry_calls == []
def test_source_kind_is_validated_before_service_lookup(app: Flask, services: RunCase) -> None:
with app.test_request_context(), pytest.raises(ValidationError):
inspect.unwrap(tracing_runs.AppTraceRunApi.get)(
tracing_runs.AppTraceRunApi(), CONTEXT, APP_ID, "unknown", SOURCE_ID
)
assert services.status_calls == []
def test_agent_owner_rejection_prevents_run_lookup(app: Flask, services: RunCase) -> None:
services.owner_error = AgentAppNotFoundError()
with app.test_request_context(), pytest.raises(NotFound):
inspect.unwrap(tracing_runs.AgentTraceRunApi.get)(tracing_runs.AgentTraceRunApi(), CONTEXT, AGENT_ID, SOURCE_ID)
assert services.status_calls == []
@pytest.mark.parametrize(
("error", "code", "status"),
[
(TraceCollectionNotFoundError, "tracing_source_not_found", 404),
(TraceCollectionNotFoundError, "tracing_node_not_found", 404),
(TraceCollectionNotFoundError, "tracing_run_not_found", 404),
(TraceCollectionConflictError, "tracing_already_accepted", 409),
(TraceCollectionConflictError, "tracing_retry_not_allowed", 409),
(TraceCollectionConflictError, "tracing_duplicate_acknowledgement_required", 409),
],
)
def test_retry_business_errors_match_served_error_contract(
services: RunCase, error: type[TraceCollectionError], code: str, status: int
) -> None:
services.retry_error = error(code)
target = tracing_runs.AppTraceRunRetryApi.post
@wraps(target)
def post(self: Resource) -> dict[str, object]:
return inspect.unwrap(target)(self, CONTEXT, APP_ID, "message", SOURCE_ID)
resource = type("RetryContractResource", (Resource,), {"post": post})
app = Flask("trace-error-contract")
app.extensions["application_services"] = services.services
api = ExternalApi(app)
api.add_resource(resource, "/retry")
with app.test_client() as client:
response = client.post("/retry", json={})
assert response.status_code == status
body = response.json
assert body is not None
assert body["code"] == code
assert body["status"] == status
@pytest.mark.parametrize(
("method", "permission", "locator"),
[
(tracing_runs.AgentTraceRunApi.get, tracing_runs.RBACPermission.AGENT_LOG_MANAGE, AgentId),
(tracing_runs.AppTraceRunApi.get, tracing_runs.RBACPermission.APP_LOG_AND_ANNOTATION, PlainApp),
(tracing_runs.AgentTraceRunRetryApi.post, tracing_runs.RBACPermission.AGENT_EDIT, AgentId),
(tracing_runs.AppTraceRunRetryApi.post, tracing_runs.RBACPermission.APP_TRACING_CONFIG, PlainApp),
],
)
def test_run_endpoints_enforce_resource_permissions(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
method: Callable[..., object],
permission: tracing_runs.RBACPermission,
locator: type[AgentId] | type[PlainApp],
) -> None:
account = Account(name="Reader", email="reader@example.com", status=AccountStatus.ACTIVE)
account.id, account.role = "account", TenantAccountRole.NORMAL
apply_config_overrides(monkeypatch, RBAC_ENABLED=True)
monkeypatch.setattr(
flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account=account, tenant_id="tenant")
)
denied_calls: list[dict[str, object]] = []
def denied(**kwargs: object) -> None:
denied_calls.append(kwargs)
raise Forbidden()
monkeypatch.setattr(flask_admission, "enforce_rbac_checks", denied)
admission = inspect.unwrap(
method, stop=lambda candidate: "allowed_roles" in inspect.getclosurevars(candidate).nonlocals
)
with app.test_request_context(), pytest.raises(Forbidden):
admission(None, agent_id=AGENT_ID) if locator is AgentId else admission(None, app_id=APP_ID)
checks = denied_calls[0]["checks"]
assert isinstance(checks, (list, tuple))
(check,) = checks
assert isinstance(check, RBACCheck)
assert check.scene == permission
assert isinstance(check.locator, locator)
@pytest.mark.parametrize("method", [tracing_runs.AgentTraceRunRetryApi.post, tracing_runs.AppTraceRunRetryApi.post])
def test_retry_rejects_readonly_members_without_rbac(
app: Flask, monkeypatch: pytest.MonkeyPatch, method: Callable[..., object]
) -> None:
account = Account(name="Reader", email="reader@example.com", status=AccountStatus.ACTIVE)
account.id, account.role = "account", TenantAccountRole.NORMAL
apply_config_overrides(monkeypatch, RBAC_ENABLED=False)
monkeypatch.setattr(
flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account=account, tenant_id="tenant")
)
admission = inspect.unwrap(
method, stop=lambda candidate: "allowed_roles" in inspect.getclosurevars(candidate).nonlocals
)
with app.test_request_context(), pytest.raises(Forbidden):
admission(None)
Whitespace-only changes.
@@ -0,0 +1,32 @@
import pytest
from controllers.console.app.advanced_prompt_template import AdvancedPromptTemplateResponse
from core.prompt.prompt_templates.advanced_prompt_templates import (
CHAT_APP_CHAT_PROMPT_CONFIG,
CHAT_APP_COMPLETION_PROMPT_CONFIG,
COMPLETION_APP_CHAT_PROMPT_CONFIG,
COMPLETION_APP_COMPLETION_PROMPT_CONFIG,
)
@pytest.mark.parametrize(
"template",
[
CHAT_APP_CHAT_PROMPT_CONFIG,
CHAT_APP_COMPLETION_PROMPT_CONFIG,
COMPLETION_APP_CHAT_PROMPT_CONFIG,
COMPLETION_APP_COMPLETION_PROMPT_CONFIG,
],
)
def test_prompt_templates_keep_their_shape(template: dict[str, object]) -> None:
dumped = AdvancedPromptTemplateResponse.model_validate(template).model_dump(mode="json", exclude_unset=True)
assert dumped == template
def test_completion_templates_keep_their_stop_words() -> None:
dumped = AdvancedPromptTemplateResponse.model_validate(CHAT_APP_COMPLETION_PROMPT_CONFIG).model_dump(
mode="json", exclude_unset=True
)
assert dumped["stop"] == ["Human:"]
@@ -0,0 +1,143 @@
"""Console admission and transport contracts for Agent App features and references."""
from dataclasses import dataclass, field
from inspect import unwrap
from uuid import UUID
import pytest
from flask import Flask
from werkzeug.exceptions import Forbidden
from controllers.console import flask_admission
from controllers.console.app import advanced_prompt_template, agent_app_access, agent_app_feature
from libs.login import AccountWithTenant
from machinery.context import RequestContext
from models.account import TenantAccountRole
from services.agent.errors import AgentNotFoundError
from services.app.advanced_prompt_template_service import AdvancedPromptTemplateService
from services.app.agent_app_contracts import AgentAppNotFoundError, AgentReferencingWorkflow
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.controllers.rbac_introspection import rbac_checks
from tests.helpers.unit.model_factories import make_account
CONTEXT = RequestContext("request", None, "actor", "tenant")
AGENT_ID = UUID("11111111-1111-1111-1111-111111111111")
@dataclass
class FeatureService:
calls: list[tuple[RequestContext, str, dict[str, object]]] = field(default_factory=list)
def update_features(self, context: RequestContext, agent_id: str, config: dict[str, object]) -> None:
self.calls.append((context, agent_id, config))
@dataclass
class AccessService:
calls: list[tuple[RequestContext, str]] = field(default_factory=list)
missing: bool = False
def list_referencing_workflows(self, context: RequestContext, agent_id: str) -> list[AgentReferencingWorkflow]:
self.calls.append((context, agent_id))
if self.missing:
raise AgentAppNotFoundError
return [
AgentReferencingWorkflow(
app_id="workflow-app",
app_name="Workflow",
app_mode="workflow",
app_icon_type=None,
app_icon=None,
app_icon_background=None,
app_updated_at=123,
workflow_id="workflow",
workflow_version="published",
node_ids=["node"],
)
]
@dataclass
class AgentServices:
features: FeatureService = field(default_factory=FeatureService)
access: AccessService = field(default_factory=AccessService)
@dataclass
class Services:
agent_apps: AgentServices = field(default_factory=AgentServices)
advanced_prompt_templates: AdvancedPromptTemplateService = field(default_factory=AdvancedPromptTemplateService)
@pytest.fixture
def services(monkeypatch: pytest.MonkeyPatch) -> Services:
services = Services()
for module in (agent_app_feature, agent_app_access, advanced_prompt_template):
monkeypatch.setattr(module, "application_services", lambda: services)
return services
def test_features_parse_full_state_and_drop_soul_fields(app: Flask, services: Services) -> None:
with app.test_request_context(
"/", method="POST", json={"opening_statement": "Hi", "speech_to_text": None, "model": {"name": "x"}}
):
result = unwrap(agent_app_feature.AgentAppFeatureConfigResource.post)(
agent_app_feature.AgentAppFeatureConfigResource(), CONTEXT, AGENT_ID
)
assert result == {"result": "success"}
assert services.agent_apps.features.calls == [(CONTEXT, str(AGENT_ID), {"opening_statement": "Hi"})]
@pytest.mark.parametrize("role", list(TenantAccountRole))
def test_feature_admission_enforces_editing_roles(
app: Flask, services: Services, monkeypatch: pytest.MonkeyPatch, role: TenantAccountRole
) -> None:
apply_config_overrides(monkeypatch, RBAC_ENABLED=False)
account = make_account(account_id="actor", name="Editor", email="editor@example.com", role=role)
monkeypatch.setattr(flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, "tenant"))
monkeypatch.setattr(flask_admission, "get_request_id", lambda: "request")
monkeypatch.setattr(flask_admission, "get_trace_id", lambda: None)
# Exercise the declared admission policy after setup/login/initialization.
view = unwrap(
agent_app_feature.AgentAppFeatureConfigResource.post,
stop=lambda handler: handler.__code__.co_name == "inject_request_context",
)
with app.test_request_context("/", method="POST", json={}):
if role in (TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR):
assert view(agent_app_feature.AgentAppFeatureConfigResource(), agent_id=AGENT_ID) == {"result": "success"}
assert services.agent_apps.features.calls == [(CONTEXT, str(AGENT_ID), {})]
else:
with pytest.raises(Forbidden):
view(agent_app_feature.AgentAppFeatureConfigResource(), agent_id=AGENT_ID)
assert services.agent_apps.features.calls == []
def test_agent_endpoints_keep_rbac_scenes() -> None:
for view, scene in (
(agent_app_feature.AgentAppFeatureConfigResource.post, agent_app_feature.RBACPermission.AGENT_EDIT),
(agent_app_access.AgentAppReferencingWorkflowsResource.get, agent_app_access.RBACPermission.AGENT_PREVIEW),
):
[check] = rbac_checks(view)
assert isinstance(check.locator, agent_app_access.AgentId)
assert check.scene == scene
def test_access_serializes_workflow_metadata(services: Services) -> None:
result = unwrap(agent_app_access.AgentAppReferencingWorkflowsResource.get)(object(), CONTEXT, AGENT_ID)
assert services.agent_apps.access.calls == [(CONTEXT, str(AGENT_ID))]
assert result["data"][0]["node_ids"] == ["node"]
assert result["data"][0]["app_updated_at"] == 123
services.agent_apps.access.missing = True
with pytest.raises(AgentNotFoundError):
unwrap(agent_app_access.AgentAppReferencingWorkflowsResource.get)(object(), CONTEXT, AGENT_ID)
@pytest.mark.parametrize("app_mode", ["chat", "completion", "invalid"])
@pytest.mark.usefixtures("services")
def test_prompt_response_preserves_omitted_fields(app: Flask, app_mode: str) -> None:
with app.test_request_context("/", query_string={"app_mode": app_mode, "model_mode": "chat", "model_name": "gpt"}):
result = unwrap(advanced_prompt_template.AdvancedPromptTemplateList.get)(object(), CONTEXT)
if app_mode == "invalid":
assert result == {}
else:
assert set(result) == {"chat_prompt_config"}
@@ -0,0 +1,182 @@
"""Transport parsing, permission declarations and sandbox error serialization."""
from collections.abc import Callable
from dataclasses import dataclass
from inspect import unwrap
from uuid import UUID
import pytest
from dify_agent.client import DifyAgentClientError, DifyAgentHTTPError, DifyAgentTimeoutError
from dify_agent.protocol import BindingFileListResponse, BindingFileReadResponse
from flask import Flask
from flask_restx import Resource
from controllers.console import agent_app_sandbox as module
from machinery.context import RequestContext
from services.agent.errors import AgentNotFoundError
from services.app.agent_app_contracts import (
AgentAppNotFoundError,
AgentSandboxBindingNotFoundError,
AgentSandboxCaller,
AgentSandboxDownload,
AgentSandboxDownloadUnavailableError,
AgentSandboxInfo,
AgentSandboxUnavailableError,
SandboxCaller,
WorkflowSandboxAppNotFoundError,
WorkflowSandboxCaller,
)
from tests.helpers.unit.controllers.error_body import raised_error
from tests.helpers.unit.controllers.rbac_introspection import rbac_checks
CONTEXT = RequestContext("request", "trace", "actor", "workspace")
RESOURCE_ID = UUID("11111111-1111-1111-1111-111111111111")
class SandboxService:
def __init__(self) -> None:
self.calls: list[tuple[str, RequestContext, SandboxCaller, str]] = []
self.error: Exception | None = None
def record(self, operation: str, context: RequestContext, caller: SandboxCaller, path: str = "") -> None:
self.calls.append((operation, context, caller, path))
if self.error:
raise self.error
def get_info(self, context: RequestContext, caller: SandboxCaller) -> AgentSandboxInfo:
self.record("info", context, caller)
return AgentSandboxInfo(workspace_cwd=".")
def list_files(self, context: RequestContext, caller: SandboxCaller, path: str) -> BindingFileListResponse:
self.record("list", context, caller, path)
return BindingFileListResponse(path=path, entries=[], truncated=False)
def read_file(self, context: RequestContext, caller: SandboxCaller, path: str) -> BindingFileReadResponse:
self.record("read", context, caller, path)
return BindingFileReadResponse(path=path, size=5, truncated=False, binary=False, text="hello")
def download_file(self, context: RequestContext, caller: SandboxCaller, path: str) -> AgentSandboxDownload:
self.record("download", context, caller, path)
return AgentSandboxDownload(url="https://files.example/report.txt")
@dataclass
class AgentServices:
sandbox: SandboxService
@dataclass
class Services:
agent_apps: AgentServices
@pytest.fixture
def service(monkeypatch: pytest.MonkeyPatch) -> SandboxService:
service = SandboxService()
monkeypatch.setattr(module, "application_services", lambda: Services(AgentServices(service)))
return service
@pytest.mark.parametrize(
("resource", "method", "verb", "operation", "workflow"),
[
(module.AgentAppSandboxInfoResource, module.AgentAppSandboxInfoResource.get, "get", "info", False),
(module.AgentAppSandboxListResource, module.AgentAppSandboxListResource.get, "get", "list", False),
(module.AgentAppSandboxReadResource, module.AgentAppSandboxReadResource.get, "get", "read", False),
(
module.AgentAppSandboxDownloadResource,
module.AgentAppSandboxDownloadResource.post,
"post",
"download",
False,
),
(module.WorkflowAgentSandboxListResource, module.WorkflowAgentSandboxListResource.get, "get", "list", True),
(module.WorkflowAgentSandboxReadResource, module.WorkflowAgentSandboxReadResource.get, "get", "read", True),
(
module.WorkflowAgentSandboxDownloadResource,
module.WorkflowAgentSandboxDownloadResource.post,
"post",
"download",
True,
),
],
)
def test_controller_parses_and_serializes(
app: Flask,
service: SandboxService,
resource: type[Resource],
method: Callable[..., object],
verb: str,
operation: str,
workflow: bool,
) -> None:
payload = {"node_execution_id": "execution"} if workflow else {"caller_type": "build_draft", "caller_id": "draft"}
if operation != "info":
payload["path"] = "~/report.txt"
kwargs = {"json": payload} if verb == "post" else {"query_string": payload}
params = (RESOURCE_ID, RESOURCE_ID, "node") if workflow else (RESOURCE_ID,)
with app.test_request_context("/", method=verb.upper(), **kwargs):
result = unwrap(method)(resource(), CONTEXT, *params)
caller = (
WorkflowSandboxCaller(str(RESOURCE_ID), str(RESOURCE_ID), "node", "execution")
if workflow
else (AgentSandboxCaller(str(RESOURCE_ID), "build_draft", "draft"))
)
assert service.calls == [(operation, CONTEXT, caller, "" if operation == "info" else "~/report.txt")]
if operation == "info":
assert result == {"workspace_cwd": "."}
elif operation == "download":
assert result == {"url": "https://files.example/report.txt"}
elif operation == "read":
assert result == {"path": "~/report.txt", "size": 5, "truncated": False, "binary": False, "text": "hello"}
else:
assert result == {"path": "~/report.txt", "entries": [], "truncated": False}
[check] = rbac_checks(method)
if workflow:
assert isinstance(check.locator, module.PlainApp)
assert check.scene == module.RBACPermission.APP_VIEW_LAYOUT
else:
assert isinstance(check.locator, module.AgentId)
assert check.scene == (
module.RBACPermission.AGENT_EDIT if operation == "download" else module.RBACPermission.AGENT_PREVIEW
)
@pytest.mark.parametrize(
("error", "code", "message", "status"),
[
(AgentSandboxBindingNotFoundError("no active binding"), "no_active_binding", "no active binding", 404),
(AgentSandboxUnavailableError("unavailable"), "inspector_unavailable", "unavailable", 503),
(
AgentSandboxDownloadUnavailableError("cannot download"),
"binding_file_download_unavailable",
"cannot download",
502,
),
(DifyAgentHTTPError(409, {"code": "conflict", "message": "busy"}), "conflict", "busy", 409),
(DifyAgentHTTPError(500, "backend exploded"), "agent_backend_error", "backend exploded", 500),
(DifyAgentTimeoutError("connection refused"), "agent_backend_unreachable", "connection refused", 502),
(DifyAgentClientError("transport failed"), "agent_backend_unreachable", "transport failed", 502),
],
)
def test_sandbox_error_responses(
app: Flask, service: SandboxService, error: Exception, code: str, message: str, status: int
) -> None:
service.error = error
with app.test_request_context("/?caller_type=conversation&caller_id=conversation"):
result = raised_error(lambda: unwrap(module.AgentAppSandboxInfoResource.get)(object(), CONTEXT, RESOURCE_ID))
assert result == ({"code": code, "message": message}, status)
@pytest.mark.parametrize(
("error", "expected"),
[
(AgentAppNotFoundError(), AgentNotFoundError),
(WorkflowSandboxAppNotFoundError(), module.AppNotFoundError),
(RuntimeError("unexpected"), RuntimeError),
],
)
def test_resource_errors_keep_existing_http_contract(error: Exception, expected: type[Exception]) -> None:
with pytest.raises(expected):
module._handle(error)
@@ -0,0 +1,627 @@
"""Unit tests for the console agent config inspector routes.
These tests unwrap the Flask decorators and focus on version resolution,
workflow-node agent binding, and service delegation for the new config surface.
"""
from __future__ import annotations
from datetime import datetime
from inspect import unwrap
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
from uuid import UUID
import pytest
from flask import Flask
from pydantic import ValidationError
from sqlalchemy import event
from sqlalchemy.orm import Session
from controllers.console.app import agent_config_inspector as inspector
from controllers.console.app.agent_config_inspector import (
AgentConfigFileDownloadApi,
AgentConfigFilePreviewApi,
AgentConfigFilesApi,
AgentConfigFilesByAgentApi,
AgentConfigManifestApi,
AgentConfigManifestByAgentApi,
AgentConfigSkillFileDownloadApi,
AgentConfigSkillFileDownloadByAgentApi,
AgentConfigSkillFilePreviewByAgentApi,
AgentConfigSkillInspectByAgentApi,
AgentConfigSkillsApi,
AgentConfigSkillUploadByAgentApi,
)
from extensions.storage.storage_type import StorageType
from models.account import Account
from models.agent import (
Agent,
AgentConfigDraft,
AgentConfigDraftType,
AgentScope,
AgentSource,
WorkflowAgentBindingType,
WorkflowAgentNodeBinding,
)
from models.agent_config_entities import AgentSoulConfig, WorkflowNodeJobConfig
from models.enums import CreatorUserRole
from models.model import App, AppMode, UploadFile
from models.workflow import Workflow, WorkflowType
from services.agent_config_service import AgentConfigServiceError
from tests.helpers.unit.controllers.error_body import raised_error
_MOD = "controllers.console.app.agent_config_inspector"
app = Flask(__name__)
def _raw(method):
return unwrap(method)
_APP = App(
id="app-1",
tenant_id="tenant-1",
name="Agent app",
description="",
mode=AppMode.AGENT,
enable_site=True,
enable_api=True,
max_active_requests=0,
)
_APP.bound_agent_id_with_session = lambda *, session: "agent-1" # type: ignore[method-assign]
_USER = Account(name="User", email="user@example.com")
_USER.id = "acct-1"
def test_resolve_bound_agent_uses_injected_session(unbound_session: Session):
session = unbound_session
resolver = MagicMock(return_value="agent-1")
app_model = App(
id="app-2",
tenant_id="tenant-1",
name="Agent app",
description="",
mode=AppMode.AGENT,
enable_site=True,
enable_api=True,
max_active_requests=0,
)
app_model.bound_agent_id_with_session = resolver # type: ignore[method-assign]
result = inspector._resolve_agent_id(session, app_model, None)
assert result == "agent-1"
resolver.assert_called_once_with(session=session)
assert resolver.call_args.kwargs["session"] is session
def test_manifest_by_agent_resolves_build_draft_version(unbound_session: Session):
raw = _raw(AgentConfigManifestByAgentApi.get)
with app.test_request_context("/?draft_type=debug_build"):
with (
patch(f"{_MOD}.resolve_agent_runtime_app_model", return_value=_APP),
patch(f"{_MOD}.AgentComposerService") as composer,
patch(f"{_MOD}.AgentConfigService") as config_service,
):
composer.load_agent_app_build_draft.return_value = {"draft": {"id": "build-draft-1"}}
config_service.return_value.manifest.return_value = {
"agent_id": "agent-1",
"config_version": {"id": "build-draft-1", "kind": "build_draft", "writable": True},
"skills": {"items": []},
"files": {"items": []},
"env_keys": [],
"note": "",
}
body = raw(AgentConfigManifestByAgentApi(), unbound_session, "tenant-1", _USER, "agent-1")
assert body["config_version"]["kind"] == "build_draft"
assert config_service.return_value.manifest.call_args.kwargs["config_version_id"] == "build-draft-1"
assert config_service.return_value.manifest.call_args.kwargs["config_version_kind"].value == "build_draft"
def test_manifest_resolves_workflow_node_agent_and_normal_draft(unbound_session: Session):
raw = _raw(AgentConfigManifestApi.get)
with app.test_request_context("/?node_id=node-1"):
with patch(f"{_MOD}.AgentComposerService") as composer, patch(f"{_MOD}.AgentConfigService") as config_service:
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.manifest.return_value = {
"agent_id": "wf-agent-9",
"config_version": {"id": "draft-1", "kind": "draft", "writable": True},
"skills": {"items": []},
"files": {"items": []},
"env_keys": [],
"note": "",
}
body = raw(AgentConfigManifestApi(), unbound_session, _USER, _APP)
assert body["agent_id"] == "wf-agent-9"
assert composer.resolve_workflow_node_agent_id.call_args.kwargs["node_id"] == "node-1"
assert config_service.return_value.manifest.call_args.kwargs["config_version_kind"].value == "draft"
def test_normal_draft_read_resolution_does_not_commit(sqlite_session: Session) -> None:
session = sqlite_session
commits: list[str] = []
event.listen(session, "after_commit", lambda _session: commits.append("commit"))
with patch(f"{_MOD}.AgentComposerService") as composer:
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
version_id, version_kind = inspector._resolve_console_version(
session=session,
tenant_id="tenant-1",
agent_id="agent-1",
account_id="acct-1",
version_id=None,
draft_type="draft",
)
assert version_id == "draft-1"
assert version_kind.value == "draft"
assert commits == []
def test_normal_config_reads_fall_back_to_snapshot_without_creating_draft(unbound_session: Session) -> None:
with patch(f"{_MOD}.AgentComposerService") as composer:
composer.load_agent_composer.return_value = {"draft": None, "active_config_snapshot": {"id": "snapshot-1"}}
version_id, version_kind = inspector._resolve_console_version(
session=unbound_session,
tenant_id="tenant-1",
agent_id="agent-1",
account_id="acct-1",
version_id=None,
draft_type="draft",
)
composer.prepare_agent_composer_draft.assert_not_called()
assert version_id == "snapshot-1"
assert version_kind.value == "snapshot"
def test_stale_inline_config_reads_use_effective_snapshot(unbound_session: Session) -> None:
with patch(f"{_MOD}.AgentComposerService") as composer:
composer.load_agent_composer.return_value = {
"agent": {"scope": "workflow_only"},
"draft": {"id": "draft-1", "base_snapshot_id": "snapshot-1"},
"active_config_snapshot": {"id": "snapshot-2"},
}
version_id, version_kind = inspector._resolve_console_version(
session=unbound_session,
tenant_id="tenant-1",
agent_id="agent-1",
account_id="acct-1",
version_id=None,
draft_type="draft",
)
composer.prepare_agent_composer_draft.assert_not_called()
assert version_id == "snapshot-2"
assert version_kind.value == "snapshot"
def test_config_write_prepares_draft_before_independent_service_session(sqlite_session: Session) -> None:
commits: list[str] = []
event.listen(sqlite_session, "after_commit", lambda _session: commits.append("commit"))
with app.test_request_context("/", method="POST"), patch(f"{_MOD}.AgentComposerService") as composer:
composer.prepare_agent_composer_draft.return_value = SimpleNamespace(id="draft-1")
target = inspector._resolve_target(
session=sqlite_session,
tenant_id="tenant-1",
agent_id="agent-1",
account_id="acct-1",
version_id=None,
draft_type="draft",
)
composer.prepare_agent_composer_draft.assert_called_once_with(
session=sqlite_session, tenant_id="tenant-1", agent_id="agent-1", account_id="acct-1"
)
composer.load_agent_composer.assert_not_called()
assert target.version_id == "draft-1"
assert target.version_kind.value == "draft"
assert commits == ["commit"]
def test_skill_inspect_by_agent_returns_strict_json_response(unbound_session: Session):
raw = _raw(AgentConfigSkillInspectByAgentApi.get)
with app.test_request_context("/"):
with (
patch(f"{_MOD}.resolve_agent_runtime_app_model", return_value=_APP),
patch(f"{_MOD}.AgentComposerService") as composer,
patch(f"{_MOD}.AgentConfigService") as config_service,
):
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.inspect_skill.return_value = {
"id": "pdf-toolkit",
"name": "pdf-toolkit",
"description": "Work with PDFs.",
"size": 42,
"mime_type": "application/zip",
"hash": "sha256:abc",
"source": "config_skill_zip",
"files": [
{"path": "SKILL.md", "name": "SKILL.md", "type": "file", "previewable": True, "downloadable": True}
],
"skill_md": {
"path": "SKILL.md",
"size": 24,
"truncated": False,
"binary": False,
"text": "# PDF Toolkit\nUse it.\n",
},
"warnings": [],
}
response = raw(
AgentConfigSkillInspectByAgentApi(), unbound_session, "tenant-1", _USER, "agent-1", "pdf-toolkit"
)
assert response.status_code == 200
assert response.get_json()["name"] == "pdf-toolkit"
assert b"PDF Toolkit" in response.get_data()
def test_file_preview_api_passes_through_and_maps_errors(unbound_session: Session):
raw = _raw(AgentConfigFilePreviewApi.get)
with app.test_request_context("/?node_id=node-1"):
with patch(f"{_MOD}.AgentComposerService") as composer, patch(f"{_MOD}.AgentConfigService") as config_service:
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.preview_file.return_value = {
"name": "sample.txt",
"size": 5,
"truncated": False,
"binary": False,
"text": "hello",
}
body = raw(AgentConfigFilePreviewApi(), unbound_session, _USER, _APP, "sample.txt")
assert body["text"] == "hello"
with app.test_request_context("/?node_id=node-1"):
with patch(f"{_MOD}.AgentComposerService") as composer, patch(f"{_MOD}.AgentConfigService") as config_service:
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.preview_file.side_effect = AgentConfigServiceError(
"config_file_not_found", "missing", status_code=404
)
body, status = raised_error(
lambda: raw(AgentConfigFilePreviewApi(), unbound_session, _USER, _APP, "missing.txt")
)
assert status == 404
assert body["code"] == "config_file_not_found"
def test_skill_upload_by_agent_delegates_after_version_resolution(unbound_session: Session):
raw = _raw(AgentConfigSkillUploadByAgentApi.post)
with app.test_request_context("/?draft_type=debug_build"):
with (
patch(f"{_MOD}.resolve_agent_runtime_app_model", return_value=_APP),
patch(f"{_MOD}.AgentComposerService") as composer,
patch(
f"{_MOD}._upload_skill_for_target",
return_value=(
{
"skill": {"id": "alpha", "name": "alpha", "file_id": "tool-file-1", "description": "Alpha"},
"config_version": {"id": "build-draft-1", "kind": "build_draft", "writable": True},
},
201,
),
) as upload_skill,
):
composer.load_agent_app_build_draft.return_value = {"draft": {"id": "build-draft-1"}}
body, status = raw(AgentConfigSkillUploadByAgentApi(), unbound_session, "tenant-1", _USER, "agent-1")
assert status == 201
assert body["skill"]["name"] == "alpha"
assert upload_skill.call_args.kwargs["version_id"] == "build-draft-1"
assert upload_skill.call_args.kwargs["version_kind"].value == "build_draft"
def test_file_upload_by_agent_delegates_to_service_owned_upload_lookup(unbound_session: Session):
raw = _raw(AgentConfigFilesByAgentApi.post)
with app.test_request_context("/?draft_type=debug_build", json={"upload_file_id": "upload-1"}):
with (
patch(f"{_MOD}.resolve_agent_runtime_app_model", return_value=_APP),
patch(f"{_MOD}.AgentComposerService") as composer,
patch(f"{_MOD}.AgentConfigService") as config_service,
):
composer.load_agent_app_build_draft.return_value = {"draft": {"id": "build-draft-1"}}
config_service.return_value.push_file_for_console.return_value = {
"file": {"id": "guide.txt", "name": "guide.txt", "file_id": "upload-1"},
"config_version": {"id": "build-draft-1", "kind": "build_draft", "writable": True},
}
body, status = raw(
AgentConfigFilesByAgentApi(),
inspector.AgentConfigFileUploadPayload(upload_file_id="upload-1"),
unbound_session,
"tenant-1",
_USER,
"agent-1",
)
assert status == 201
assert body["file"]["name"] == "guide.txt"
assert config_service.return_value.push_file_for_console.call_args.kwargs["upload_file_id"] == "upload-1"
assert config_service.return_value.push_file_for_console.call_args.kwargs["config_version_id"] == "build-draft-1"
assert (
config_service.return_value.push_file_for_console.call_args.kwargs["config_version_kind"].value == "build_draft"
)
def test_skill_list_api_uses_config_list_shape(unbound_session: Session) -> None:
raw = _raw(AgentConfigSkillsApi.get)
with app.test_request_context("/?node_id=node-1"):
with patch(f"{_MOD}.AgentComposerService") as composer, patch(f"{_MOD}.AgentConfigService") as config_service:
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.list_skills.return_value = {
"agent_id": "wf-agent-9",
"config_version": {"id": "draft-1", "kind": "draft", "writable": True},
"items": [{"id": "alpha", "name": "alpha", "file_id": "tool-file-1", "description": "Alpha"}],
}
body = raw(AgentConfigSkillsApi(), unbound_session, _USER, _APP)
assert body["items"][0]["name"] == "alpha"
assert body["items"][0]["file_id"] == "tool-file-1"
assert config_service.return_value.list_skills.call_args.kwargs["agent_id"] == "wf-agent-9"
def test_file_list_api_uses_config_list_shape(unbound_session: Session) -> None:
raw = _raw(AgentConfigFilesApi.get)
with app.test_request_context("/?node_id=node-1"):
with patch(f"{_MOD}.AgentComposerService") as composer, patch(f"{_MOD}.AgentConfigService") as config_service:
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.list_files.return_value = {
"agent_id": "wf-agent-9",
"config_version": {"id": "draft-1", "kind": "draft", "writable": True},
"items": [
{
"id": "guide.txt",
"name": "guide.txt",
"file_id": "upload-file-1",
"hash": "sha256:file-1",
"mime_type": "text/plain",
"size": 7,
}
],
}
body = raw(AgentConfigFilesApi(), unbound_session, _USER, _APP)
assert body == {
"agent_id": "wf-agent-9",
"config_version": {"id": "draft-1", "kind": "draft", "writable": True},
"items": [
{
"id": "guide.txt",
"name": "guide.txt",
"file_id": "upload-file-1",
"hash": "sha256:file-1",
"mime_type": "text/plain",
"size": 7,
}
],
}
assert config_service.return_value.list_files.call_args.kwargs["agent_id"] == "wf-agent-9"
def test_skill_file_preview_by_agent_reads_path_query(unbound_session: Session) -> None:
raw = _raw(AgentConfigSkillFilePreviewByAgentApi.get)
with app.test_request_context("/?draft_type=debug_build&path=references/guide.md"):
with (
patch(f"{_MOD}.resolve_agent_runtime_app_model", return_value=_APP),
patch(f"{_MOD}.AgentComposerService") as composer,
patch(f"{_MOD}.AgentConfigService") as config_service,
):
composer.load_agent_app_build_draft.return_value = {"draft": {"id": "build-draft-1"}}
config_service.return_value.preview_skill_file.return_value = {
"path": "references/guide.md",
"size": 11,
"truncated": False,
"binary": False,
"text": "hello world",
}
body = raw(AgentConfigSkillFilePreviewByAgentApi(), unbound_session, "tenant-1", _USER, "agent-1", "alpha")
assert body["path"] == "references/guide.md"
assert config_service.return_value.preview_skill_file.call_args.kwargs["path"] == "references/guide.md"
def test_skill_file_download_by_agent_returns_proxy_url(unbound_session: Session) -> None:
raw = _raw(AgentConfigSkillFileDownloadByAgentApi.get)
with app.test_request_context("/?draft_type=debug_build&path=references/guide.md"):
with (
patch(f"{_MOD}.resolve_agent_runtime_app_model", return_value=_APP),
patch(f"{_MOD}.AgentComposerService") as composer,
patch(f"{_MOD}.AgentConfigService") as config_service,
patch(
f"{_MOD}.url_for",
return_value="/console/api/agent/agent-1/config/skills/alpha/files/content?path=references%2Fguide.md&draft_type=debug_build",
),
):
composer.load_agent_app_build_draft.return_value = {"draft": {"id": "build-draft-1"}}
config_service.return_value.resolve_skill_file_member_path.return_value = "references/guide.md"
response = raw(
AgentConfigSkillFileDownloadByAgentApi(), unbound_session, "tenant-1", _USER, "agent-1", "alpha"
)
assert response.status_code == 200
assert response.get_json()["url"].endswith(
"/agent/agent-1/config/skills/alpha/files/content?path=references%2Fguide.md&draft_type=debug_build"
)
def test_skill_file_download_by_agent_validates_member_path(unbound_session: Session) -> None:
raw = _raw(AgentConfigSkillFileDownloadByAgentApi.get)
with app.test_request_context("/?draft_type=debug_build&path=references/missing.md"):
with (
patch(f"{_MOD}.resolve_agent_runtime_app_model", return_value=_APP),
patch(f"{_MOD}.AgentComposerService") as composer,
patch(f"{_MOD}.AgentConfigService") as config_service,
):
composer.load_agent_app_build_draft.return_value = {"draft": {"id": "build-draft-1"}}
config_service.return_value.resolve_skill_file_member_path.side_effect = AgentConfigServiceError(
"config_skill_file_not_found", "missing", status_code=404
)
body, status = raised_error(
lambda: raw(
AgentConfigSkillFileDownloadByAgentApi(), unbound_session, "tenant-1", _USER, "agent-1", "alpha"
)
)
assert status == 404
assert body["code"] == "config_skill_file_not_found"
def test_skill_file_download_api_forwards_workflow_node_and_draft_type(unbound_session: Session) -> None:
raw = _raw(AgentConfigSkillFileDownloadApi.get)
with app.test_request_context("/?node_id=node-1&draft_type=debug_build&path=references/guide.md"):
with (
patch(f"{_MOD}.AgentComposerService") as composer,
patch(f"{_MOD}.AgentConfigService") as config_service,
patch(
f"{_MOD}.url_for",
return_value="/console/api/apps/app-1/agent/config/skills/alpha/files/content?node_id=node-1&draft_type=debug_build&path=references%2Fguide.md",
) as url_for_mock,
):
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_app_build_draft.return_value = {"draft": {"id": "build-draft-1"}}
config_service.return_value.resolve_skill_file_member_path.return_value = "references/guide.md"
response = raw(AgentConfigSkillFileDownloadApi(), unbound_session, _USER, _APP, "alpha")
assert response.status_code == 200
assert response.get_json()["url"].endswith(
"/apps/app-1/agent/config/skills/alpha/files/content?node_id=node-1&draft_type=debug_build&path=references%2Fguide.md"
)
assert url_for_mock.call_args.kwargs == {
"_external": False,
"app_id": "app-1",
"draft_type": "debug_build",
"name": "alpha",
"node_id": "node-1",
"path": "references/guide.md",
}
def test_skill_file_download_api_propagates_member_lookup_404s(unbound_session: Session) -> None:
raw = _raw(AgentConfigSkillFileDownloadApi.get)
with app.test_request_context("/?node_id=node-1&path=references/missing.md"):
with patch(f"{_MOD}.AgentComposerService") as composer, patch(f"{_MOD}.AgentConfigService") as config_service:
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.resolve_skill_file_member_path.side_effect = AgentConfigServiceError(
"config_skill_file_not_found", "missing", status_code=404
)
body, status = raised_error(
lambda: raw(AgentConfigSkillFileDownloadApi(), unbound_session, _USER, _APP, "alpha")
)
assert status == 404
assert body["code"] == "config_skill_file_not_found"
def test_file_download_api_returns_signed_url_json(unbound_session: Session) -> None:
raw = _raw(AgentConfigFileDownloadApi.get)
with app.test_request_context("/?node_id=node-1"):
with patch(f"{_MOD}.AgentComposerService") as composer, patch(f"{_MOD}.AgentConfigService") as config_service:
composer.resolve_workflow_node_agent_id.return_value = "wf-agent-9"
composer.load_agent_composer.return_value = {"draft": {"id": "draft-1"}}
config_service.return_value.download_file_url.return_value = "https://example.com/guide.txt"
response = raw(AgentConfigFileDownloadApi(), unbound_session, _USER, _APP, "guide.txt")
assert response.status_code == 200
assert response.get_json() == {"url": "https://example.com/guide.txt"}
@pytest.mark.parametrize("upload_ids", [[], ["invalid-uuid"]])
def test_batch_file_upload_payload_requires_nonempty_uuid_list(upload_ids: list[str]) -> None:
with pytest.raises(ValidationError):
inspector.AgentConfigFilesUploadPayload.model_validate({"upload_file_ids": upload_ids})
@pytest.mark.parametrize("workflow_node", [False, True])
def test_batch_file_upload_routes_bind_and_serialize_real_workspace_files(
sqlite_session: Session, workflow_node: bool
) -> None:
tenant_id = "11111111-1111-1111-1111-111111111111"
agent_id = "22222222-2222-2222-2222-222222222222"
app_id = "33333333-3333-3333-3333-333333333333"
account_id = "44444444-4444-4444-4444-444444444444"
draft_id = "55555555-5555-5555-5555-555555555555"
file_id = "66666666-6666-6666-6666-666666666666"
workflow_id = "77777777-7777-7777-7777-777777777777"
user = Account(name="Batch uploader", email="batch@example.com")
user.id = account_id
app_model = App(
id=app_id,
tenant_id=tenant_id,
name="Batch app",
description="",
mode=AppMode.WORKFLOW if workflow_node else AppMode.AGENT,
enable_site=True,
enable_api=True,
max_active_requests=0,
)
agent = Agent(
id=agent_id,
tenant_id=tenant_id,
app_id=app_id,
name="Batch agent",
scope=AgentScope.WORKFLOW_ONLY if workflow_node else AgentScope.ROSTER,
source=AgentSource.WORKFLOW if workflow_node else AgentSource.AGENT_APP,
)
draft = AgentConfigDraft(
id=draft_id,
tenant_id=tenant_id,
agent_id=agent_id,
draft_type=AgentConfigDraftType.DRAFT,
config_snapshot=AgentSoulConfig(),
)
upload = UploadFile(
tenant_id=tenant_id,
storage_type=StorageType.LOCAL,
key="uploads/batch.txt",
name="batch.txt",
size=5,
extension="txt",
mime_type="text/plain",
created_by_role=CreatorUserRole.ACCOUNT,
created_by=account_id,
created_at=datetime(2025, 1, 1),
used=False,
)
upload.id = file_id
sqlite_session.add_all([app_model, agent, draft, upload])
if workflow_node:
sqlite_session.add(
Workflow(
id=workflow_id,
tenant_id=tenant_id,
app_id=app_id,
type=WorkflowType.WORKFLOW,
version="draft",
graph="{}",
_features="{}",
created_by=account_id,
)
)
sqlite_session.add(
WorkflowAgentNodeBinding(
tenant_id=tenant_id,
app_id=app_id,
workflow_id=workflow_id,
workflow_version="draft",
node_id="node-1",
binding_type=WorkflowAgentBindingType.INLINE_AGENT,
agent_id=agent_id,
node_job_config=WorkflowNodeJobConfig(),
)
)
sqlite_session.commit()
payload = inspector.AgentConfigFilesUploadPayload(upload_file_ids=[UUID(file_id)])
query = "/?node_id=node-1&draft_type=draft" if workflow_node else "/?draft_type=draft"
with app.test_request_context(query, method="POST"):
if workflow_node:
endpoint = inspector.AgentConfigFilesUploadApi()
body, status = _raw(endpoint.post)(endpoint, payload, sqlite_session, user, app_model)
else:
endpoint = inspector.AgentConfigFilesUploadByAgentApi()
body, status = _raw(endpoint.post)(endpoint, payload, sqlite_session, tenant_id, user, UUID(agent_id))
assert status == 201
assert body["files"] == [
{
"id": "batch.txt",
"name": "batch.txt",
"file_id": file_id,
"is_missing": False,
"size": 5,
"mime_type": "text/plain",
"hash": None,
}
]
assert body["config_version"] == {"id": draft_id, "kind": "draft", "writable": True}
sqlite_session.expire_all()
persisted = sqlite_session.get(AgentConfigDraft, draft_id)
assert persisted is not None
assert [file_ref.file_id for file_ref in persisted.config_snapshot.config_files] == [file_id]
@@ -0,0 +1,138 @@
from configs import dify_config
from controllers.console.app import annotation as annotation_module
from tasks.annotation.batch_import_annotations_task import batch_import_annotations_task
def test_annotation_reply_payload_valid() -> None:
"""Test AnnotationReplyPayload with valid data."""
payload = annotation_module.AnnotationReplyPayload(
score_threshold=0.5,
embedding_provider_name="openai",
embedding_model_name="text-embedding-3-small",
)
assert payload.score_threshold == 0.5
assert payload.embedding_provider_name == "openai"
assert payload.embedding_model_name == "text-embedding-3-small"
def test_annotation_setting_update_payload_valid() -> None:
"""Test AnnotationSettingUpdatePayload with valid data."""
payload = annotation_module.AnnotationSettingUpdatePayload(
score_threshold=0.75,
)
assert payload.score_threshold == 0.75
def test_annotation_list_query_defaults() -> None:
"""Test AnnotationListQuery with default parameters."""
query = annotation_module.AnnotationListQuery()
assert query.page == 1
assert query.limit == 20
assert query.keyword == ""
def test_annotation_list_query_custom_page() -> None:
"""Test AnnotationListQuery with custom page."""
query = annotation_module.AnnotationListQuery(page=3, limit=50)
assert query.page == 3
assert query.limit == 50
def test_annotation_list_query_with_keyword() -> None:
"""Test AnnotationListQuery with keyword."""
query = annotation_module.AnnotationListQuery(keyword="test")
assert query.keyword == "test"
def test_create_annotation_payload_with_message_id() -> None:
"""Test CreateAnnotationPayload with message ID."""
payload = annotation_module.CreateAnnotationPayload(
message_id="550e8400-e29b-41d4-a716-446655440000",
question="What is AI?",
)
assert payload.message_id == "550e8400-e29b-41d4-a716-446655440000"
assert payload.question == "What is AI?"
def test_create_annotation_payload_with_text() -> None:
"""Test CreateAnnotationPayload with text content."""
payload = annotation_module.CreateAnnotationPayload(
question="What is ML?",
answer="Machine learning is...",
)
assert payload.question == "What is ML?"
assert payload.answer == "Machine learning is..."
def test_update_annotation_payload() -> None:
"""Test UpdateAnnotationPayload."""
payload = annotation_module.UpdateAnnotationPayload(
question="Updated question",
answer="Updated answer",
)
assert payload.question == "Updated question"
assert payload.answer == "Updated answer"
def test_annotation_reply_status_query_enable() -> None:
"""Test AnnotationReplyStatusQuery with enable action."""
query = annotation_module.AnnotationReplyStatusQuery(action="enable")
assert query.action == "enable"
def test_annotation_reply_status_query_disable() -> None:
"""Test AnnotationReplyStatusQuery with disable action."""
query = annotation_module.AnnotationReplyStatusQuery(action="disable")
assert query.action == "disable"
def test_annotation_file_payload_valid() -> None:
"""Test AnnotationFilePayload with valid message ID."""
payload = annotation_module.AnnotationFilePayload(message_id="550e8400-e29b-41d4-a716-446655440000")
assert payload.message_id == "550e8400-e29b-41d4-a716-446655440000"
class TestAnnotationImportTaskOptimization:
"""Test optimizations in batch import task."""
def test_task_is_registered_with_queue(self) -> None:
"""Test that task is registered with the correct queue."""
# Celery sets `queue` on the registered task at runtime; the Task type does not declare it.
assert batch_import_annotations_task.queue == "dataset" # pyrefly: ignore[missing-attribute]
class TestConfigurationValues:
"""Test that security configuration values are properly set."""
def test_rate_limit_configs_exist(self) -> None:
"""Test that rate limit configurations are defined."""
assert hasattr(dify_config, "ANNOTATION_IMPORT_RATE_LIMIT_PER_MINUTE")
assert hasattr(dify_config, "ANNOTATION_IMPORT_RATE_LIMIT_PER_HOUR")
assert dify_config.ANNOTATION_IMPORT_RATE_LIMIT_PER_MINUTE > 0
assert dify_config.ANNOTATION_IMPORT_RATE_LIMIT_PER_HOUR > 0
def test_file_size_limit_config_exists(self) -> None:
"""Test that file size limit configuration is defined."""
assert hasattr(dify_config, "ANNOTATION_IMPORT_FILE_SIZE_LIMIT")
assert dify_config.ANNOTATION_IMPORT_FILE_SIZE_LIMIT > 0
assert dify_config.ANNOTATION_IMPORT_FILE_SIZE_LIMIT <= 10 # Reasonable max (10MB)
def test_record_limit_configs_exist(self) -> None:
"""Test that record limit configurations are defined."""
assert hasattr(dify_config, "ANNOTATION_IMPORT_MAX_RECORDS")
assert hasattr(dify_config, "ANNOTATION_IMPORT_MIN_RECORDS")
assert dify_config.ANNOTATION_IMPORT_MAX_RECORDS > 0
assert dify_config.ANNOTATION_IMPORT_MIN_RECORDS > 0
assert dify_config.ANNOTATION_IMPORT_MIN_RECORDS < dify_config.ANNOTATION_IMPORT_MAX_RECORDS
def test_concurrency_limit_config_exists(self) -> None:
"""Test that concurrency limit configuration is defined."""
assert hasattr(dify_config, "ANNOTATION_IMPORT_MAX_CONCURRENT")
assert dify_config.ANNOTATION_IMPORT_MAX_CONCURRENT > 0
assert dify_config.ANNOTATION_IMPORT_MAX_CONCURRENT <= 10 # Reasonable upper bound
def test_annotation_count_response() -> None:
assert annotation_module.AnnotationCountResponse(count=10).count == 10
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,918 @@
import io
import zipfile
from collections.abc import Callable, Iterator
from dataclasses import dataclass, field
from inspect import unwrap
from typing import BinaryIO, Protocol, cast
from unittest.mock import Mock
from uuid import UUID, uuid4
import httpx
import pytest
from flask import Flask
from flask_restx import Resource
from pydantic import ValidationError
from sqlalchemy import Engine, event, select
from sqlalchemy.orm import Session, sessionmaker
from werkzeug.exceptions import Forbidden
from constants.dsl_version import CURRENT_APP_DSL_VERSION
from controllers.console.app import app as app_module
from controllers.console.app import app_import as console
from controllers.console.app import app_import as controller
from controllers.console.app import app_import as import_module
from controllers.console.app.error import AppNotFoundError, DraftWorkflowNotSync
from controllers.inner_api.app import dsl as inner
from controllers.openapi import app_dsl as openapi
from controllers.openapi._errors import OpenApiErrorFormatter
from controllers.openapi._models import AppDslImportPayload
from core.rbac import RBACPermission
from enums import DeploymentEdition
from extensions.ext_redis import redis_client
from libs.external_api import ExternalApi
from machinery.context import RequestContext
from models.account import Account, Tenant, TenantAccountJoin, TenantAccountRole
from models.model import App, AppMode
from services import app_import_source
from services.agent.errors import InvalidRosterAgentPackageError
from services.agent.roster_package_importer import RosterAgentPackageImportResult
from services.app.console_gateway import AppTransferGateway, EnterpriseConsoleAppAccess
from services.app_dsl_service import AppDslService, PendingData
from services.app_package_service import AppPackageService, PreparedAppPackage
from services.billing_client import transport
from services.enterprise.enterprise_service import EnterpriseService
from services.entities.dsl_entities import AppImportPackage, AppImportParams, DslImportWarning, Import, ImportStatus
from services.entities.feature_entities import FeatureModel, LimitationModel
from services.errors.app import DraftChangedError
from services.errors.base import NoPermissionError
from services.feature_service import FeatureService
from services.plugin.dependencies_analysis import DependenciesAnalysisService
from services.recommended_app_package_service import RecommendedAgentPackageSource, RecommendedAppPackageService
from services.system_feature_service import SystemFeatureService
from tests.helpers.unit.config_override import apply_config_overrides
from tests.unit_tests.controllers.conftest import ControllerTestServices
"""Console imports finalize persistence before publishing permissions and access settings."""
class TestAppImportApiCases:
@staticmethod
@pytest.fixture
def import_context(sqlite_session_factory: sessionmaker[Session]) -> RequestContext:
account_id, tenant_id = str(uuid4()), str(uuid4())
account = Account(name="Importer", email="importer@example.com")
account.id = account_id
tenant = Tenant(name="Workspace")
tenant.id = tenant_id
with sqlite_session_factory.begin() as session:
session.add_all(
[
account,
tenant,
TenantAccountJoin(tenant_id=tenant_id, account_id=account_id, role=TenantAccountRole.OWNER),
]
)
return RequestContext("import-request", None, account_id, tenant_id)
@staticmethod
@pytest.fixture
def connections(sqlite_engine: Engine) -> Iterator[set[object]]:
checked_out: set[object] = set()
def checkout(connection: object, *_args: object) -> None:
checked_out.add(connection)
def checkin(connection: object, *_args: object) -> None:
checked_out.remove(connection)
event.listen(sqlite_engine, "checkout", checkout)
event.listen(sqlite_engine, "checkin", checkin)
try:
yield checked_out
assert not checked_out
finally:
event.remove(sqlite_engine, "checkout", checkout)
event.remove(sqlite_engine, "checkin", checkin)
@staticmethod
@pytest.mark.usefixtures("app_query_services")
@pytest.mark.parametrize("confirm", [False, True])
@pytest.mark.parametrize("overwrite", [False, True])
@pytest.mark.parametrize("status", list(ImportStatus))
def test_import_transaction_and_response_contract(
app: Flask,
sqlite_session_factory: sessionmaker[Session],
import_context: RequestContext,
connections: set[object],
monkeypatch: pytest.MonkeyPatch,
config_overrides,
status: ImportStatus,
overwrite: bool,
confirm: bool,
) -> None:
config_overrides(RBAC_ENABLED=True, DEPLOYMENT_EDITION="COMMUNITY")
monkeypatch.setattr(
"services.app.console_gateway.rbac_service.RBACService.CheckAccess.check", lambda *a, **k: True
)
app_id = str(uuid4())
result = Import(id="import-1", status=status, app_id=app_id, app_created=not overwrite)
pending = PendingData(
tenant_id=import_context.active_workspace_id,
account_id=import_context.account_id,
import_mode="yaml-content",
yaml_content="app: {}",
app_id=app_id if overwrite else None,
)
monkeypatch.setattr(redis_client, "get", lambda _key: pending.model_dump_json())
def persist(dsl: AppDslService, *, account: Account, **_kwargs) -> Import:
assert not connections, "Actor lookup must release its connection before starting the DSL operation"
assert account.id == import_context.account_id
assert account.current_tenant_id == import_context.active_workspace_id
dsl._session.add(
App(
id=app_id,
tenant_id=account.current_tenant_id,
name="Imported",
mode=AppMode.WORKFLOW,
enable_site=True,
enable_api=True,
)
)
dsl._session.flush()
return result
monkeypatch.setattr(AppDslService, "confirm_import" if confirm else "import_app", persist)
permissions: list[str] = []
access_updates: list[tuple[str, str]] = []
def get_permissions(_self, context: RequestContext, imported_id: str) -> list[str]:
assert not connections
assert context == import_context
with sqlite_session_factory() as session:
assert session.get(App, imported_id) is not None
permissions.append(imported_id)
return ["app.acl.view_layout"]
def update_access(imported_id: str, access_mode: str) -> None:
assert not connections, "WebApp access initialization must follow transaction completion"
access_updates.append((imported_id, access_mode))
monkeypatch.setattr(EnterpriseConsoleAppAccess, "created_permissions", get_permissions)
monkeypatch.setattr(SystemFeatureService, "is_webapp_auth_enabled", lambda: True)
monkeypatch.setattr(EnterpriseService.WebAppAuth, "update_app_access_mode", update_access)
with app.test_request_context(
method="POST",
json={
"mode": "yaml-content",
"yaml_content": "app: {}",
"app_id": app_id if overwrite else None,
},
):
if confirm:
api = controller.AppImportConfirmApi()
response, status_code = unwrap(api.post)(api, import_context, import_id="import-1")
else:
api = controller.AppImportApi()
response, status_code = unwrap(api.post)(api, import_context)
with sqlite_session_factory() as session:
assert (session.get(App, app_id) is not None) is (status != ImportStatus.FAILED)
completed = status in {ImportStatus.COMPLETED, ImportStatus.COMPLETED_WITH_WARNINGS}
assert permissions == ([app_id] if completed and not overwrite else [])
assert response["permission_keys"] == (["app.acl.view_layout"] if permissions else [])
# Overwrites keep the existing web app access mode; only completed creations get the private default.
assert access_updates == ([(app_id, "private")] if completed and not overwrite else [])
assert status_code == (
400 if status == ImportStatus.FAILED else 202 if status == ImportStatus.PENDING and not confirm else 200
)
@staticmethod
@pytest.mark.usefixtures("app_query_services")
@pytest.mark.parametrize("missing", [False, True])
def test_check_dependencies_releases_database_before_plugin_io(
app: Flask,
import_context: RequestContext,
sqlite_session_factory: sessionmaker[Session],
connections: set[object],
monkeypatch: pytest.MonkeyPatch,
missing: bool,
) -> None:
app_id = str(uuid4())
if not missing:
with sqlite_session_factory.begin() as session:
session.add(
App(
id=app_id,
tenant_id=import_context.active_workspace_id,
name="Imported",
mode=AppMode.CHAT,
enable_site=True,
enable_api=True,
)
)
monkeypatch.setattr(redis_client, "get", lambda _key: '{"dependencies":[]}')
called = []
def check(*, tenant_id: str, dependencies):
assert not connections
assert tenant_id == import_context.active_workspace_id
called.append(dependencies)
return []
monkeypatch.setattr(DependenciesAnalysisService, "get_leaked_dependencies", check)
api = controller.AppImportCheckDependenciesApi()
with app.test_request_context():
if missing:
with pytest.raises(AppNotFoundError):
unwrap(api.get)(api, import_context, app_id=app_id)
assert called == []
else:
response, code = unwrap(api.get)(api, import_context, app_id=app_id)
assert code == 200
assert response == {"leaked_dependencies": []}
assert called == [[]]
@staticmethod
@pytest.mark.parametrize("confirm", [False, True])
def test_permission_errors_are_mapped_at_http_boundary(
app_query_services, app: Flask, monkeypatch, confirm: bool
) -> None:
def denied(*_args, **_kwargs):
raise NoPermissionError("Import denied")
monkeypatch.setattr(app_query_services.apps.console, "confirm_import" if confirm else "import_app", denied)
context = RequestContext("request", None, "actor", "workspace")
with app.test_request_context(method="POST", json={"mode": "yaml-content"}):
if confirm:
api = controller.AppImportConfirmApi()
with pytest.raises(Forbidden, match="Import denied"):
unwrap(api.post)(api, context, import_id="import-1")
else:
api = controller.AppImportApi()
with pytest.raises(Forbidden, match="Import denied"):
unwrap(api.post)(api, context)
@staticmethod
def test_confirming_an_import_whose_draft_changed_is_a_conflict(
app_query_services, app: Flask, monkeypatch
) -> None:
"""A pending openapi import carries a draft_hash; a console confirm after the draft changed must not 500."""
def changed(*_args, **_kwargs):
raise DraftChangedError()
monkeypatch.setattr(app_query_services.apps.console, "confirm_import", changed)
context = RequestContext("request", None, "actor", "workspace")
with app.test_request_context(method="POST"):
api = controller.AppImportConfirmApi()
with pytest.raises(DraftWorkflowNotSync) as exc_info:
unwrap(api.post)(api, context, import_id="import-1")
assert exc_info.value.code == 409
@staticmethod
def test_import_response_schema_hides_creation_marker() -> None:
assert "app_created" not in controller.console_ns.models[Import.__name__].__schema__["properties"]
def _roster_archive() -> io.BytesIO:
source = io.BytesIO()
with zipfile.ZipFile(source, "w") as archive:
# Fixed timestamp: passing a filename string stamps the current local
# time (2-second ZIP resolution), so two archives built across a
# timestamp boundary differ byte-for-byte and flake the assertion below.
info = zipfile.ZipInfo("manifest.yaml", date_time=(1980, 1, 1, 0, 0, 0))
archive.writestr(info, "format: dify.roster-agent")
source.seek(0)
return source
def _mock_download(monkeypatch: pytest.MonkeyPatch, content: bytes | None = None) -> list[str]:
calls: list[str] = []
def fetch(method: str, url: str, **_kwargs: object) -> httpx.Response:
calls.append(url)
return httpx.Response(
200,
content=content if content is not None else _roster_archive().getvalue(),
request=httpx.Request(method, url),
)
monkeypatch.setattr(app_import_source.remote_fetcher, "make_request", fetch)
return calls
@dataclass(frozen=True)
class AgentImportCall:
tenant_id: str
account: Account
content: bytes
@dataclass
class Imports:
context: RequestContext
dsl_calls: list[AppImportParams] = field(default_factory=list)
packages: list[PreparedAppPackage] = field(default_factory=list)
agent_calls: list[AgentImportCall] = field(default_factory=list)
status: ImportStatus = ImportStatus.COMPLETED
app_created: bool = False
warnings: list[DslImportWarning] = field(default_factory=list)
def dsl(
self, context: RequestContext, params: AppImportParams, *, package: AppImportPackage | None = None
) -> Import:
assert context == self.context
self.dsl_calls.append(params)
if package is not None:
assert isinstance(package, PreparedAppPackage)
assert not package.archive.closed
self.packages.append(package)
return Import(id="import-1", status=self.status, app_id="app-1", app_created=self.app_created)
def agent(self, *, source: BinaryIO, tenant_id: str, account: Account) -> RosterAgentPackageImportResult:
self.agent_calls.append(AgentImportCall(tenant_id, account, source.read()))
return RosterAgentPackageImportResult(app_id="app-1", agent_id="agent-1", warnings=self.warnings)
def _post(
app: Flask,
imports: Imports,
*,
json: dict[str, object] | None = None,
data: dict[str, object] | None = None,
) -> tuple[dict[str, object], int]:
api = import_module.AppImportApi()
with app.test_request_context("/console/api/apps/imports", method="POST", json=json, data=data):
return cast(tuple[dict[str, object], int], unwrap(api.post)(api, imports.context))
class TestRosterPackageRoutesCases:
@staticmethod
@pytest.fixture
def imports(
app_query_services: ControllerTestServices,
sqlite_session_factory: sessionmaker[Session],
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
) -> Imports:
config_overrides(RBAC_ENABLED=False, DEPLOYMENT_EDITION="COMMUNITY")
actor, tenant = str(uuid4()), str(uuid4())
account = Account(name="Importer", email="importer@example.com")
account.id = actor
workspace = Tenant(name="Workspace")
workspace.id = tenant
with sqlite_session_factory.begin() as session:
session.add_all(
[
account,
workspace,
TenantAccountJoin(tenant_id=tenant, account_id=actor, role=TenantAccountRole.OWNER),
]
)
result = Imports(RequestContext("request", None, actor, tenant))
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
monkeypatch.setattr(transfers, "import_dsl", result.dsl)
monkeypatch.setattr(transfers._agent_importer, "import_package", result.agent)
monkeypatch.setattr("services.app.console_gateway.SystemFeatureService.is_webapp_auth_enabled", lambda: False)
return result
@staticmethod
def test_existing_import_route_dispatches_json_without_changing_payload(app: Flask, imports: Imports) -> None:
data, status = _post(app, imports, json={"mode": "yaml-content", "yaml_content": "app: {}"})
assert status == 200
assert data["status"] == "completed"
assert [params.model_dump() for params in imports.dsl_calls] == [
AppImportParams(mode="yaml-content", yaml_content="app: {}").model_dump()
]
assert imports.agent_calls == []
@staticmethod
@pytest.mark.parametrize(
"url",
[
"https://example.com/download?id=123",
"https://example.com/agent.ifpkg",
" https://example.com/agent.IFPKG?token=secret#download ",
],
)
def test_package_url_uses_agent_import(
app: Flask, imports: Imports, monkeypatch: pytest.MonkeyPatch, url: str
) -> None:
fetched = _mock_download(monkeypatch)
data, status = _post(app, imports, json={"mode": "yaml-url", "yaml_url": url})
assert status == 200
assert data["app_mode"] == "agent"
assert data["status"] == "completed"
assert len(fetched) == 1
assert imports.dsl_calls == []
(call,) = imports.agent_calls
assert call.tenant_id == imports.context.active_workspace_id
assert call.account.id == imports.context.account_id
assert call.account.is_admin_or_owner is True
@staticmethod
@pytest.mark.parametrize(
"url", ["https://example.com/app.yaml", "https://example.com/download", "https://example.com/agent.ifpkg"]
)
def test_yaml_url_keeps_dsl_import_without_package_retry(
app: Flask, imports: Imports, monkeypatch: pytest.MonkeyPatch, url: str
) -> None:
imports.status = ImportStatus.FAILED
fetched = _mock_download(monkeypatch, b"app: {}")
_, status = _post(
app, imports, json={"mode": "yaml-url", "yaml_url": url, "app_id": "existing", "name": "Renamed"}
)
assert status == 400
assert (
imports.dsl_calls[0].model_dump()
== AppImportParams(
mode="yaml-content", yaml_content="app: {}", app_id="existing", name="Renamed"
).model_dump()
)
assert len(fetched) == 1
assert imports.agent_calls == []
@staticmethod
def test_url_without_any_import_permission_does_not_download(
app: Flask, imports: Imports, monkeypatch: pytest.MonkeyPatch, config_overrides: Callable[..., None]
) -> None:
config_overrides(RBAC_ENABLED=True)
monkeypatch.setattr(
"services.app.console_gateway.rbac_service.RBACService.CheckAccess.check", lambda *_a, **_k: False
)
fetched = _mock_download(monkeypatch)
with pytest.raises(Forbidden):
_post(app, imports, json={"mode": "yaml-url", "yaml_url": "https://example.com/download"})
assert fetched == []
@staticmethod
@pytest.mark.parametrize("is_yaml", [False, True])
def test_url_quota_is_enforced_after_content_detection(
app: Flask,
imports: Imports,
app_query_services: ControllerTestServices,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
is_yaml: bool,
) -> None:
config_overrides(DEPLOYMENT_EDITION="CLOUD")
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
monkeypatch.setattr(transfers, "import_dsl", AppTransferGateway.import_dsl.__get__(transfers))
features = FeatureModel(apps=LimitationModel(size=1, limit=1))
monkeypatch.setattr("services.app_dsl_service.FeatureService.get_features", lambda *_a, **_k: features)
_mock_download(monkeypatch, b"app: {mode: workflow}" if is_yaml else _roster_archive().getvalue())
if is_yaml:
with pytest.raises(Forbidden, match="number of apps"):
_post(app, imports, json={"mode": "yaml-url", "yaml_url": "https://example.com/download"})
assert imports.agent_calls == []
assert imports.dsl_calls == []
else:
data, status = _post(app, imports, json={"mode": "yaml-url", "yaml_url": "https://example.com/download"})
assert status == 200
assert data["app_mode"] == "agent"
@staticmethod
def test_url_rejects_content_that_is_neither_yaml_nor_package(
app: Flask, imports: Imports, monkeypatch: pytest.MonkeyPatch
) -> None:
fetched = _mock_download(monkeypatch, b"[invalid")
with pytest.raises(InvalidRosterAgentPackageError):
_post(app, imports, json={"mode": "yaml-url", "yaml_url": "https://example.com/download"})
assert len(fetched) == 1
@staticmethod
@pytest.mark.parametrize("has_warning", [False, True])
def test_existing_import_route_accepts_package_and_preserves_import_response(
app: Flask, imports: Imports, has_warning: bool
) -> None:
imports.warnings = (
[DslImportWarning(code="agent_skill_missing", path="skills.s_000001", message="Missing Skill")]
if has_warning
else []
)
data, status = _post(app, imports, data={"file": (_roster_archive(), "agent.ifpkg")})
assert status == 200
assert data["app_id"] == "app-1"
assert data["app_mode"] == "agent"
assert data["status"] == ("completed-with-warnings" if has_warning else "completed")
assert data["warnings"] == [warning.model_dump(mode="json") for warning in imports.warnings]
assert data["id"]
assert imports.agent_calls[0].content == _roster_archive().getvalue()
@staticmethod
@pytest.mark.parametrize("from_url", [False, True])
@pytest.mark.parametrize("denied", [RBACPermission.AGENT_CREATE, RBACPermission.AGENT_IMPORT_EXPORT_DSL])
def test_package_import_checks_agent_permissions_before_materializing_resources(
app: Flask,
imports: Imports,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
denied: RBACPermission,
from_url: bool,
) -> None:
config_overrides(RBAC_ENABLED=True)
_mock_download(monkeypatch)
scenes: list[RBACPermission] = []
def check(*_args: object, scene: RBACPermission, **_kwargs: object) -> bool:
scenes.append(scene)
return scene != denied
monkeypatch.setattr("services.app.console_gateway.rbac_service.RBACService.CheckAccess.check", check)
kwargs: dict[str, dict[str, object]] = (
{"json": {"mode": "yaml-url", "yaml_url": "https://example.com/agent.ifpkg"}}
if from_url
else {"data": {"file": (_roster_archive(), "agent.ifpkg")}}
)
with pytest.raises(Forbidden):
_post(app, imports, **kwargs)
assert denied in scenes
if not from_url:
assert RBACPermission.APP_IMPORT_EXPORT_DSL not in scenes
assert imports.agent_calls == []
@staticmethod
@pytest.mark.parametrize("from_url", [False, True])
def test_package_import_rejects_overwrite(
app: Flask, imports: Imports, monkeypatch: pytest.MonkeyPatch, from_url: bool
) -> None:
_mock_download(monkeypatch)
kwargs: dict[str, dict[str, object]] = (
{"json": {"mode": "yaml-url", "yaml_url": "https://example.com/agent.ifpkg", "app_id": "existing"}}
if from_url
else {"data": {"app_id": "existing", "file": (_roster_archive(), "agent.ifpkg")}}
)
with pytest.raises(InvalidRosterAgentPackageError, match="overwriting"):
_post(app, imports, **kwargs)
@staticmethod
@pytest.mark.parametrize("from_url", [False, True])
@pytest.mark.parametrize("app_id", [None, "existing"])
@pytest.mark.parametrize("status", [ImportStatus.COMPLETED, ImportStatus.PENDING, ImportStatus.FAILED])
def test_ordinary_package_import_uses_dsl_permissions_and_confirmation(
app: Flask,
imports: Imports,
monkeypatch: pytest.MonkeyPatch,
app_id: str | None,
status: ImportStatus,
from_url: bool,
) -> None:
imports.status = status
dsl = "kind: app\nversion: 99.0.0\napp:\n mode: workflow\n"
with AppPackageService().export(dsl=dsl, name="Workflow", workflow_tools=[]) as package:
form: dict[str, object] = {"file": (package.archive, "workflow.ifpkg"), "name": "Renamed"}
if app_id:
form["app_id"] = app_id
if from_url:
_mock_download(monkeypatch, package.archive.read())
data, code = _post(
app,
imports,
json={
"mode": "yaml-url",
"yaml_url": "https://example.com/workflow.ifpkg",
"name": "Renamed",
"app_id": app_id,
},
)
else:
data, code = _post(app, imports, data=form)
assert code == {ImportStatus.FAILED: 400, ImportStatus.PENDING: 202}.get(status, 200)
assert len(imports.packages) == 1
assert imports.packages[0].archive.closed
assert data["status"] == status
assert len(imports.dsl_calls) == 1
assert (
imports.dsl_calls[0].model_dump()
== AppImportParams(mode="yaml-content", yaml_content=dsl, name="Renamed", app_id=app_id).model_dump()
)
assert imports.agent_calls == []
@staticmethod
@pytest.mark.parametrize("from_url", [False, True])
@pytest.mark.parametrize("overwrite", [False, True])
def test_ordinary_package_import_keeps_access_mode_on_overwrite(
app: Flask, imports: Imports, monkeypatch: pytest.MonkeyPatch, overwrite: bool, from_url: bool
) -> None:
imports.app_created = not overwrite
access_updates: list[tuple[str, str]] = []
monkeypatch.setattr("services.app.console_gateway.SystemFeatureService.is_webapp_auth_enabled", lambda: True)
monkeypatch.setattr(
EnterpriseService.WebAppAuth,
"update_app_access_mode",
lambda app_id, access_mode: access_updates.append((app_id, access_mode)),
)
app_id = "app-1" if overwrite else None
with AppPackageService().export(
dsl="kind: app\napp:\n mode: workflow\n", name="Workflow", workflow_tools=[]
) as package:
if from_url:
_mock_download(monkeypatch, package.archive.read())
_data, code = _post(
app,
imports,
json={"mode": "yaml-url", "yaml_url": "https://example.com/workflow.ifpkg", "app_id": app_id},
)
else:
form: dict[str, object] = {"file": (package.archive, "workflow.ifpkg")}
if app_id:
form["app_id"] = app_id
_data, code = _post(app, imports, data=form)
assert code == 200
assert access_updates == ([] if overwrite else [("app-1", "private")])
@staticmethod
def test_export_query_rejects_conflicting_version_selectors() -> None:
with pytest.raises(ValidationError, match="version_id and workflow_id cannot be used together"):
app_module.AppExportQuery.model_validate(
{"version_id": "11111111-1111-4111-8111-111111111111", "workflow_id": "workflow-1"}
)
@staticmethod
def test_template_import_resolves_catalog_source_and_preserves_overrides(
app: Flask, imports: Imports, app_query_services: ControllerTestServices, monkeypatch: pytest.MonkeyPatch
) -> None:
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
template_id = UUID("11111111-1111-4111-8111-111111111111")
version_id = UUID("22222222-2222-4222-8222-222222222222")
source = RecommendedAgentPackageSource("source-tenant", "source-agent", version_id)
catalog = Mock()
catalog.get_package_source.return_value = source
transfers._recommended_packages = RecommendedAppPackageService(sources=catalog, exporter=Mock())
import_template = Mock(return_value=RosterAgentPackageImportResult("new-app", "new-agent", []))
monkeypatch.setattr(transfers._agent_importer, "import_template", import_template)
data, status = _post(
app,
imports,
json={
"mode": "template",
"template_id": str(template_id),
"version_id": str(version_id),
"name": "My Agent",
"app_id": "",
},
)
assert status == 200
assert data["app_id"] == "new-app"
assert data["app_mode"] == "agent"
catalog.get_package_source.assert_called_once_with(str(template_id), version_id)
import_template.assert_called_once()
assert import_template.call_args.kwargs["source"] == source
assert import_template.call_args.kwargs["tenant_id"] == imports.context.active_workspace_id
assert import_template.call_args.kwargs["account"].id == imports.context.account_id
assert import_template.call_args.kwargs["name"] == "My Agent"
@staticmethod
def test_template_import_rejects_unlisted_source(
app: Flask, imports: Imports, app_query_services: ControllerTestServices, monkeypatch: pytest.MonkeyPatch
) -> None:
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
catalog = Mock()
catalog.get_package_source.return_value = None
transfers._recommended_packages = RecommendedAppPackageService(sources=catalog, exporter=Mock())
import_template = Mock()
monkeypatch.setattr(transfers._agent_importer, "import_template", import_template)
with pytest.raises(import_module.RecommendedAppNotFoundHttpError):
_post(
app,
imports,
json={
"mode": "template",
"template_id": "11111111-1111-4111-8111-111111111111",
"version_id": "22222222-2222-4222-8222-222222222222",
},
)
import_template.assert_not_called()
@staticmethod
def test_package_url_import_preserves_overrides(
app: Flask, imports: Imports, app_query_services: ControllerTestServices, monkeypatch: pytest.MonkeyPatch
) -> None:
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
import_url = Mock(return_value=RosterAgentPackageImportResult("new-app", "new-agent", []))
monkeypatch.setattr(transfers._agent_importer, "import_package_url", import_url)
data, status = _post(
app,
imports,
json={"mode": "ifpkg-url", "package_url": "https://example.com/agent.ifpkg", "name": "My Agent"},
)
assert status == 200
assert data["app_id"] == "new-app"
import_url.assert_called_once()
assert import_url.call_args.kwargs["url"] == "https://example.com/agent.ifpkg"
assert import_url.call_args.kwargs["name"] == "My Agent"
@staticmethod
def test_package_url_retains_legacy_optional_selectors(
app: Flask, imports: Imports, app_query_services: ControllerTestServices, monkeypatch: pytest.MonkeyPatch
) -> None:
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
import_url = Mock(return_value=RosterAgentPackageImportResult("new-app", "new-agent", []))
monkeypatch.setattr(transfers._agent_importer, "import_package_url", import_url)
data, status = _post(
app,
imports,
json={
"mode": "ifpkg-url",
"package_url": "https://example.com/agent.ifpkg",
"app_id": "",
"template_id": "11111111-1111-4111-8111-111111111111",
"version_id": "22222222-2222-4222-8222-222222222222",
},
)
assert status == 200
assert data["app_id"] == "new-app"
import_url.assert_called_once()
assert import_url.call_args.kwargs["url"] == "https://example.com/agent.ifpkg"
@staticmethod
@pytest.mark.parametrize("mode", ["template", "ifpkg-url"])
def test_template_import_checks_permissions_before_accessing_source(
app: Flask,
imports: Imports,
app_query_services: ControllerTestServices,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
mode: str,
) -> None:
config_overrides(RBAC_ENABLED=True)
monkeypatch.setattr(
"services.app.console_gateway.rbac_service.RBACService.CheckAccess.check", lambda *_a, **_k: False
)
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
importer = Mock()
monkeypatch.setattr(transfers, "_agent_importer", importer)
payload: dict[str, object] = (
{
"mode": "template",
"template_id": "11111111-1111-4111-8111-111111111111",
"version_id": "22222222-2222-4222-8222-222222222222",
}
if mode == "template"
else {"mode": "ifpkg-url", "package_url": "https://example.com/agent.ifpkg"}
)
with pytest.raises(Forbidden):
_post(app, imports, json=payload)
importer.assert_not_called()
@staticmethod
@pytest.mark.parametrize(
"extra",
[
{"app_id": "existing"},
{"yaml_content": "app: {}"},
],
)
def test_package_url_rejects_ambiguous_sources(app: Flask, imports: Imports, extra: dict[str, str]) -> None:
with pytest.raises(InvalidRosterAgentPackageError):
_post(app, imports, json={"mode": "ifpkg-url", "package_url": "https://example.com/agent.ifpkg", **extra})
@staticmethod
@pytest.mark.parametrize("quota", [False, True])
def test_ordinary_package_import_checks_permission_and_quota(
app: Flask,
imports: Imports,
app_query_services: ControllerTestServices,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
quota: bool,
) -> None:
config_overrides(RBAC_ENABLED=not quota, DEPLOYMENT_EDITION="CLOUD" if quota else "COMMUNITY")
transfers = app_query_services.apps.console._transfers
assert isinstance(transfers, AppTransferGateway)
monkeypatch.setattr(transfers, "import_dsl", AppTransferGateway.import_dsl.__get__(transfers))
monkeypatch.setattr(
"services.app.console_gateway.rbac_service.RBACService.CheckAccess.check", lambda *_a, **_k: False
)
features = FeatureModel(apps=LimitationModel(size=1, limit=1))
monkeypatch.setattr("services.app_dsl_service.FeatureService.get_features", lambda *_a, **_k: features)
with AppPackageService().export(
dsl="kind: app\napp: {mode: workflow}\n", name="Workflow", workflow_tools=[]
) as package:
with pytest.raises(Forbidden):
_post(app, imports, data={"file": (package.archive, "workflow.ifpkg")})
assert imports.dsl_calls == []
"""Quota failures retain their HTTP semantics across both app import surfaces."""
class _EndpointView(Protocol):
__handler__: Callable[..., tuple[object, int]]
class TestAppImportQuotaCases:
@staticmethod
@pytest.mark.parametrize(
("surface", "confirm"),
[("console", False), ("console", True), ("openapi", False), ("openapi", True), ("inner", False)],
)
@pytest.mark.parametrize("failure", ["timeout", "upstream_503", "invalid_response", "quota_exhausted"])
def test_import_quota_failure_http_status(
app_query_services: ControllerTestServices,
sqlite_session: Session,
monkeypatch: pytest.MonkeyPatch,
surface: str,
confirm: bool,
failure: str,
) -> None:
apply_config_overrides(
monkeypatch, DEPLOYMENT_EDITION=DeploymentEdition.CLOUD, INNER_API=True, INNER_API_KEY="test-inner-api-key"
)
monkeypatch.setattr("controllers.console.wraps._is_setup_completed", lambda: True)
account = Account(name="Importer", email="importer@example.com")
tenant = Tenant(name="Workspace")
account.id, tenant.id = str(uuid4()), str(uuid4())
sqlite_session.add_all(
[
account,
tenant,
TenantAccountJoin(tenant_id=tenant.id, account_id=account.id, role=TenantAccountRole.OWNER),
]
)
sqlite_session.commit()
context = RequestContext("request-1", None, account.id, tenant.id)
content = (
f"version: {CURRENT_APP_DSL_VERSION}\napp: {{name: Imported, mode: workflow}}\n"
"workflow: {graph: {nodes: [], edges: []}, features: {}}\n"
)
pending = PendingData(
tenant_id=tenant.id, account_id=account.id, import_mode="yaml-content", yaml_content=content
)
monkeypatch.setattr(redis_client, "get", lambda _: pending.model_dump_json())
def unexpected_side_effect(*_args: object, **_kwargs: object) -> None:
pytest.fail("A failed quota check must preserve pending data and avoid database writes")
monkeypatch.setattr(redis_client, "delete", unexpected_side_effect)
monkeypatch.setattr(AppDslService, "_create_or_update_app", unexpected_side_effect)
if failure == "quota_exhausted":
monkeypatch.setattr(
FeatureService,
"get_features",
lambda *_args, **_kwargs: FeatureModel(apps=LimitationModel(size=5, limit=5)),
)
else:
def failed_billing(*_args: object, **_kwargs: object) -> httpx.Response:
if failure == "timeout":
raise httpx.ReadTimeout("Private billing timeout details")
if failure == "upstream_503":
return httpx.Response(503, text="Private billing failure details")
return httpx.Response(200, json={"subscription": "Private invalid billing response"})
monkeypatch.setattr(transport, "_send", failed_billing)
app = Flask(__name__)
app.config["TESTING"] = True
app.extensions["application_services"] = app_query_services
api = ExternalApi(app, error_body_formatter=OpenApiErrorFormatter() if surface == "openapi" else None)
class AdmittedImport(Resource):
def post(self) -> tuple[object, int]:
if surface == "inner":
return inner.EnterpriseAppDSLImport().post(workspace_id=tenant.id)
if surface == "console":
if confirm:
controller = console.AppImportConfirmApi()
return unwrap(controller.post)(controller, context, import_id="pending-1")
controller = console.AppImportApi()
return unwrap(controller.post)(controller, context)
if confirm:
controller = openapi.AppDslImportConfirmApi()
return cast(_EndpointView, controller.post).__handler__(
controller, context, workspace_id=tenant.id, import_id="pending-1"
)
controller = openapi.AppDslImportApi()
return cast(_EndpointView, controller.post).__handler__(
controller,
context,
workspace_id=tenant.id,
body=AppDslImportPayload(mode="yaml-content", yaml_content=content),
)
api.add_resource(AdmittedImport, "/imports")
response = app.test_client().post(
"/imports",
json={"mode": "yaml-content", "yaml_content": content, "creator_email": account.email},
headers={"X-Inner-Api-Key": "test-inner-api-key"},
)
assert response.status_code == (403 if failure == "quota_exhausted" else 500)
assert "Private" not in response.get_data(as_text=True)
assert sqlite_session.scalar(select(App.id).where(App.tenant_id == tenant.id)) is None
@@ -0,0 +1,912 @@
from __future__ import annotations
import io
from collections.abc import Callable, Iterator
from inspect import unwrap
from unittest.mock import patch
from uuid import UUID
import pytest
from flask import Flask, Response
from sqlalchemy import Engine, event
from sqlalchemy.orm import Session
from werkzeug.datastructures import FileStorage
from werkzeug.exceptions import Forbidden, InternalServerError, UnprocessableEntity
from controllers.console import wraps
from controllers.console.app import audio
from controllers.console.app import audio as audio_module
from controllers.console.app.audio import (
AgentChatMessageAudioApi,
AgentChatMessageTextApi,
AgentTextToSpeechVoicesApi,
ChatMessageAudioApi,
ChatMessageTextApi,
TextModesApi,
TextToSpeechPayload,
TextToSpeechVoiceQuery,
)
from controllers.console.app.error import (
AppUnavailableError,
AudioTooLargeError,
CompletionRequestError,
NoAudioUploadedError,
ProviderModelCurrentlyNotSupportError,
ProviderNotInitializeError,
ProviderNotSupportSpeechToTextError,
ProviderQuotaExceededError,
SpeechToTextDisabledError,
UnsupportedAudioTypeError,
)
from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
from graphon.model_runtime.errors.invoke import InvokeError
from models import Account
from models import App as _audio_App
from models import AppMode as _audio_AppMode
from models.agent import Agent, AgentConfigDraftType, AgentKind, AgentScope, AgentSource, AgentStatus
from models.agent_config_entities import AgentSoulConfig
from models.model import App as _agent_audio_readonly_App
from models.model import AppMode as _agent_audio_readonly_AppMode
from services.agent.composer_service import AgentComposerService
from services.agent.errors import AgentNotFoundError, AgentVersionNotFoundError
from services.app_ref_service import AppRef, MessageRef
from services.audio_service import AudioService
from services.errors.app_model_config import AppModelConfigBrokenError
from services.errors.audio import (
AudioTooLargeServiceError,
NoAudioUploadedServiceError,
ProviderNotSupportSpeechToTextServiceError,
SpeechToTextDisabledServiceError,
UnsupportedAudioTypeServiceError,
)
from tests.helpers.unit.audio_runtime_fixtures import AudioRuntimeObservations
from tests.helpers.unit.model_factories import make_account, make_app
AGENT_ID = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
def _agent(scope: AgentScope = AgentScope.WORKFLOW_ONLY) -> Agent:
workflow_only = scope == AgentScope.WORKFLOW_ONLY
return Agent(
id=str(AGENT_ID),
tenant_id="tenant-1",
name="Audio agent",
agent_kind=AgentKind.DIFY_AGENT,
scope=scope,
source=AgentSource.WORKFLOW if workflow_only else AgentSource.AGENT_APP,
status=AgentStatus.ACTIVE,
app_id="parent-app-1" if workflow_only else "runtime-app-1",
backing_app_id="runtime-app-1" if workflow_only else None,
workflow_id="workflow-1" if workflow_only else None,
workflow_node_id="node-1" if workflow_only else None,
created_by="account-1",
updated_by="account-1",
)
class TestAgentAudioReadonlyCases:
@staticmethod
@pytest.fixture(autouse=True)
def audio_identity(monkeypatch: pytest.MonkeyPatch, config_overrides: Callable[..., None]) -> None:
config_overrides(LOGIN_DISABLED=True, RBAC_ENABLED=True)
monkeypatch.setattr(wraps, "_is_setup_completed", lambda: True)
monkeypatch.setattr(wraps, "current_account_with_tenant", lambda: (make_account(), "tenant-1"))
monkeypatch.setattr(audio, "enforce_rbac_checks", lambda **_kwargs: None)
@staticmethod
@pytest.fixture
def persistence_events(sqlite_engine: Engine) -> Iterator[list[str]]:
observed: list[str] = []
def record_statement(
_connection: object,
_cursor: object,
statement: str,
_parameters: object,
_context: object,
_executemany: bool,
) -> None:
operation = statement.lstrip().split(maxsplit=1)[0].upper()
if operation in {"INSERT", "UPDATE", "DELETE"}:
observed.append(operation)
def record_commit(_session: Session) -> None:
observed.append("COMMIT")
event.listen(sqlite_engine, "before_cursor_execute", record_statement)
event.listen(Session, "before_commit", record_commit)
try:
yield observed
finally:
event.remove(sqlite_engine, "before_cursor_execute", record_statement)
event.remove(Session, "before_commit", record_commit)
@staticmethod
@pytest.fixture(params=["voices", "preview"])
def request_audio(
request: pytest.FixtureRequest, app: Flask, audio_runtime: AudioRuntimeObservations
) -> tuple[Callable[[], object], AudioRuntimeObservations]:
if request.param == "voices":
audio_runtime.voices = [{"name": "Echo", "value": "echo"}]
def invoke() -> object:
with app.test_request_context(f"/console/api/agent/{AGENT_ID}/text-to-audio/voices?language=en-US"):
return audio.AgentTextToSpeechVoicesApi().get(agent_id=AGENT_ID)
else:
audio_runtime.tts_result = b"ID3audio"
def invoke() -> object:
with app.test_request_context(
f"/console/api/agent/{AGENT_ID}/text-to-audio",
method="POST",
json={"text": "Preview this voice", "voice": "echo"},
):
response = audio.AgentChatMessageTextApi().post(agent_id=AGENT_ID)
assert response is not None
try:
assert response.get_data() == b"ID3audio"
assert response.content_type == "audio/mpeg"
return response
finally:
response.close()
return invoke, audio_runtime
@staticmethod
@pytest.mark.parametrize("scope", [AgentScope.ROSTER, AgentScope.WORKFLOW_ONLY])
def test_audio_uses_existing_runtime_state_without_writes(
sqlite_session: Session,
request_audio: tuple[Callable[[], object], AudioRuntimeObservations],
persistence_events: list[str],
scope: AgentScope,
) -> None:
agent = _agent(scope)
runtime_app = make_app(app_id="runtime-app-1", mode=_agent_audio_readonly_AppMode.AGENT)
sqlite_session.add_all([agent, runtime_app])
sqlite_session.commit()
persistence_events.clear()
invoke, provider = request_audio
response = invoke()
assert len(provider.resolutions) == 1
assert response is not None
assert persistence_events == []
@staticmethod
def test_audio_does_not_materialize_a_missing_workflow_backing_app(
sqlite_session: Session,
request_audio: tuple[Callable[[], object], AudioRuntimeObservations],
persistence_events: list[str],
) -> None:
agent = _agent()
agent.backing_app_id = None
parent_app = make_app(app_id="parent-app-1", mode=_agent_audio_readonly_AppMode.WORKFLOW)
sqlite_session.add_all([agent, parent_app])
sqlite_session.commit()
persistence_events.clear()
invoke, provider = request_audio
with pytest.raises(AgentNotFoundError):
invoke()
assert provider.resolutions == []
assert provider.daemon_calls == []
assert persistence_events == []
sqlite_session.refresh(agent)
assert agent.backing_app_id is None
assert sqlite_session.get(_agent_audio_readonly_App, "runtime-app-1") is None
@staticmethod
@pytest.mark.parametrize("foreign_owner", ["agent", "app"])
def test_audio_scopes_both_agent_and_runtime_app_to_the_current_tenant(
sqlite_session: Session,
request_audio: tuple[Callable[[], object], AudioRuntimeObservations],
persistence_events: list[str],
foreign_owner: str,
) -> None:
agent = _agent()
runtime_app = make_app(app_id="runtime-app-1", mode=_agent_audio_readonly_AppMode.AGENT)
if foreign_owner == "agent":
agent.tenant_id = "tenant-2"
else:
runtime_app.tenant_id = "tenant-2"
sqlite_session.add_all([agent, runtime_app])
sqlite_session.commit()
persistence_events.clear()
invoke, provider = request_audio
with pytest.raises(AgentNotFoundError):
invoke()
assert provider.resolutions == []
assert provider.daemon_calls == []
assert persistence_events == []
@staticmethod
@pytest.mark.parametrize(
("provider_error", "expected_error"),
[
(ProviderTokenNotInitError("No TTS model configured"), ProviderNotInitializeError),
(QuotaExceededError(), ProviderQuotaExceededError),
(ModelCurrentlyNotSupportError(), ProviderModelCurrentlyNotSupportError),
(InvokeError("TTS provider unavailable"), CompletionRequestError),
(ValueError("Unknown voice"), ValueError),
(RuntimeError("Unexpected provider failure"), InternalServerError),
],
)
def test_provider_failures_preserve_error_contract_and_readonly_state(
sqlite_session: Session,
request_audio: tuple[Callable[[], object], AudioRuntimeObservations],
persistence_events: list[str],
provider_error: Exception,
expected_error: type[Exception],
) -> None:
sqlite_session.add_all(
[_agent(AgentScope.ROSTER), make_app(app_id="runtime-app-1", mode=_agent_audio_readonly_AppMode.AGENT)]
)
sqlite_session.commit()
persistence_events.clear()
invoke, provider = request_audio
provider.lookup_error = provider_error
with pytest.raises(expected_error):
invoke()
assert len(provider.resolutions) == 1
assert persistence_events == []
def _file_data():
return FileStorage(stream=io.BytesIO(b"audio"), filename="audio.wav", content_type="audio/wav")
def _app(*, app_id: str = "a1", tenant_id: str = "tenant-1") -> _audio_App:
return make_app(app_id=app_id, tenant_id=tenant_id, name="Audio app", icon_type=None, max_active_requests=0)
def _account(account_id: str = "account-1") -> Account:
return make_account(account_id=account_id, name="Audio account", email=f"{account_id}@example.com")
class TestAudioCases:
@staticmethod
def test_console_audio_api_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(AudioService, "transcript_asr", lambda **_kwargs: {"text": "ok"})
api = ChatMessageAudioApi()
handler = unwrap(api.post)
app_model = _app()
with app.test_request_context(
"/console/api/apps/app/audio-to-text", method="POST", data={"file": _file_data()}
):
response = handler(api, app_model=app_model)
assert response == {"text": "ok"}
@staticmethod
def test_console_audio_api_accepts_published_agent_apps() -> None:
assert _audio_AppMode.AGENT in audio_module._CONSOLE_AUDIO_TRANSCRIPT_APP_MODES
@staticmethod
def test_agent_console_audio_api_uses_agent_draft(
app: Flask, monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
app_model = _app(app_id="backing-app-1")
agent_soul = AgentSoulConfig.model_validate({"app_features": {"speech_to_text": {"enabled": True}}})
calls: dict[str, object] = {}
def resolve_agent_runtime_app_model(**kwargs):
calls["resolver"] = kwargs
return app_model
def load_agent_soul_for_debug(**kwargs):
calls["draft"] = kwargs
return agent_soul
def transcript_agent_asr(**kwargs):
calls["asr"] = kwargs
return {"text": "agent transcript"}
def enforce_rbac_checks(**kwargs):
calls["rbac"] = kwargs
monkeypatch.setattr(audio_module, "resolve_agent_runtime_app_model", resolve_agent_runtime_app_model)
monkeypatch.setattr(audio_module, "enforce_rbac_checks", enforce_rbac_checks)
monkeypatch.setattr(AgentComposerService, "load_agent_soul_for_debug", load_agent_soul_for_debug)
monkeypatch.setattr(AudioService, "transcript_agent_asr", transcript_agent_asr)
api = AgentChatMessageAudioApi()
handler = unwrap(api.post)
session = unbound_session
current_user = _account()
with app.test_request_context(
f"/console/api/agent/{agent_id}/audio-to-text",
method="POST",
data={"file": _file_data(), "draft_type": "debug_build"},
):
response = handler(
api,
session=session,
current_tenant_id="tenant-1",
current_user=current_user,
agent_id=agent_id,
)
assert response == {"text": "agent transcript"}
assert calls["resolver"] == {"session": session, "tenant_id": "tenant-1", "agent_id": agent_id}
rbac_call = calls["rbac"]
assert rbac_call["tenant_id"] == "tenant-1"
assert rbac_call["account_id"] == "account-1"
assert rbac_call["path_args"] == {"app_id": "backing-app-1"}
(rbac_check,) = rbac_call["checks"]
assert rbac_check.scene is audio_module.RBACPermission.APP_TEST_AND_RUN
assert isinstance(rbac_check.locator, audio_module.PlainApp)
assert calls["draft"] == {
"tenant_id": "tenant-1",
"agent_id": str(agent_id),
"account_id": "account-1",
"draft_type": AgentConfigDraftType.DEBUG_BUILD,
"session": session,
}
assert calls["asr"] == {
"app_model": app_model,
"agent_soul": agent_soul,
"file": calls["asr"]["file"],
"session": session,
"end_user": None,
}
@staticmethod
def test_agent_console_audio_api_defaults_to_normal_draft(
app: Flask, monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
captured: dict[str, object] = {}
monkeypatch.setattr(
audio_module,
"resolve_agent_runtime_app_model",
lambda **_kwargs: _app(app_id="backing-app-1"),
)
def load_agent_soul_for_debug(**kwargs):
captured.update(kwargs)
return AgentSoulConfig.model_validate({"app_features": {"speech_to_text": {"enabled": True}}})
monkeypatch.setattr(AgentComposerService, "load_agent_soul_for_debug", load_agent_soul_for_debug)
monkeypatch.setattr(AudioService, "transcript_agent_asr", lambda **_kwargs: {"text": "ok"})
api = AgentChatMessageAudioApi()
handler = unwrap(api.post)
with app.test_request_context(
f"/console/api/agent/{agent_id}/audio-to-text",
method="POST",
data={"file": _file_data()},
):
response = handler(
api,
session=unbound_session,
current_tenant_id="tenant-1",
current_user=_account(),
agent_id=agent_id,
)
assert response == {"text": "ok"}
assert captured["draft_type"] == AgentConfigDraftType.DRAFT
@staticmethod
def test_agent_console_audio_api_checks_rbac_with_backing_app_id(
app: Flask, monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
app_model = _app(app_id="backing-app-1")
soul_loaded = False
monkeypatch.setattr(audio_module, "resolve_agent_runtime_app_model", lambda **_kwargs: app_model)
def deny_access(**kwargs):
assert kwargs["path_args"] == {"app_id": "backing-app-1"}
raise Forbidden()
def load_agent_soul_for_debug(**_kwargs):
nonlocal soul_loaded
soul_loaded = True
return AgentSoulConfig()
monkeypatch.setattr(audio_module, "enforce_rbac_checks", deny_access)
monkeypatch.setattr(AgentComposerService, "load_agent_soul_for_debug", load_agent_soul_for_debug)
api = AgentChatMessageAudioApi()
handler = unwrap(api.post)
with app.test_request_context(
f"/console/api/agent/{agent_id}/audio-to-text",
method="POST",
data={"file": _file_data()},
):
with pytest.raises(Forbidden):
handler(
api,
session=unbound_session,
current_tenant_id="tenant-1",
current_user=_account(),
agent_id=agent_id,
)
assert soul_loaded is False
@staticmethod
def test_agent_console_audio_api_preserves_missing_build_draft_404(
app: Flask, monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
monkeypatch.setattr(
audio_module,
"resolve_agent_runtime_app_model",
lambda **_kwargs: _app(app_id="backing-app-1"),
)
monkeypatch.setattr(
AgentComposerService,
"load_agent_soul_for_debug",
lambda **_kwargs: (_ for _ in ()).throw(AgentVersionNotFoundError()),
)
api = AgentChatMessageAudioApi()
handler = unwrap(api.post)
with app.test_request_context(
f"/console/api/agent/{agent_id}/audio-to-text",
method="POST",
data={"file": _file_data(), "draft_type": "debug_build"},
):
with pytest.raises(AgentVersionNotFoundError):
handler(
api,
session=unbound_session,
current_tenant_id="tenant-1",
current_user=_account(),
agent_id=agent_id,
)
@staticmethod
@pytest.mark.parametrize(
("exc", "expected"),
[
(AppModelConfigBrokenError(), AppUnavailableError),
(NoAudioUploadedServiceError(), NoAudioUploadedError),
(AudioTooLargeServiceError("too big"), AudioTooLargeError),
(UnsupportedAudioTypeServiceError(), UnsupportedAudioTypeError),
(ProviderNotSupportSpeechToTextServiceError(), ProviderNotSupportSpeechToTextError),
(SpeechToTextDisabledServiceError(), SpeechToTextDisabledError),
(ProviderTokenNotInitError("token"), ProviderNotInitializeError),
(QuotaExceededError(), ProviderQuotaExceededError),
(ModelCurrentlyNotSupportError(), ProviderModelCurrentlyNotSupportError),
(InvokeError("invoke"), CompletionRequestError),
],
)
def test_console_audio_api_error_mapping(app: Flask, monkeypatch: pytest.MonkeyPatch, exc, expected) -> None:
monkeypatch.setattr(AudioService, "transcript_asr", lambda **_kwargs: (_ for _ in ()).throw(exc))
api = ChatMessageAudioApi()
handler = unwrap(api.post)
app_model = _app()
with app.test_request_context(
"/console/api/apps/app/audio-to-text", method="POST", data={"file": _file_data()}
):
with pytest.raises(expected):
handler(api, app_model=app_model)
@staticmethod
def test_console_audio_api_unhandled_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(
AudioService, "transcript_asr", lambda **_kwargs: (_ for _ in ()).throw(RuntimeError("boom"))
)
api = ChatMessageAudioApi()
handler = unwrap(api.post)
app_model = _app()
with app.test_request_context(
"/console/api/apps/app/audio-to-text", method="POST", data={"file": _file_data()}
):
with pytest.raises(InternalServerError):
handler(api, app_model=app_model)
@staticmethod
def test_console_text_api_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(AudioService, "transcript_tts", lambda **_kwargs: {"audio": "ok"})
api = ChatMessageTextApi()
handler = unwrap(api.post)
app_model = _app()
with app.test_request_context(
"/console/api/apps/app/text-to-audio",
method="POST",
json={"text": "hello", "voice": "v"},
):
response = handler(api, TextToSpeechPayload(text="hello"), app_model=app_model)
assert response == {"audio": "ok"}
@staticmethod
def test_console_text_api_builds_message_ref(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = ChatMessageTextApi()
handler = unwrap(api.post)
app_model = _app(app_id="app-1")
calls = {}
def fake_transcript_tts(**kwargs):
calls.update(kwargs)
return {"audio": "ok"}
monkeypatch.setattr(AudioService, "transcript_tts", fake_transcript_tts)
with (
app.test_request_context(
"/console/api/apps/app-1/text-to-audio",
method="POST",
json={"text": "hello", "message_id": "message-1"},
),
patch("controllers.console.app.audio.current_user", _account()),
):
response = handler(api, TextToSpeechPayload(text="hello", message_id="message-1"), app_model=app_model)
assert response == {"audio": "ok"}
assert calls["message_ref"] == MessageRef(AppRef("tenant-1", "app-1"), "message-1", account_id="account-1")
@staticmethod
def test_console_text_api_error_mapping(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(
AudioService, "transcript_tts", lambda **_kwargs: (_ for _ in ()).throw(QuotaExceededError())
)
api = ChatMessageTextApi()
handler = unwrap(api.post)
app_model = _app()
with app.test_request_context(
"/console/api/apps/app/text-to-audio",
method="POST",
json={"text": "hello"},
):
with pytest.raises(ProviderQuotaExceededError):
handler(api, TextToSpeechPayload(text="hello"), app_model=app_model)
@staticmethod
def test_console_text_modes_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
expected_voices = [{"name": "Voice 1", "value": "voice-1"}]
monkeypatch.setattr(AudioService, "transcript_tts_voices", lambda **_kwargs: expected_voices)
api = TextModesApi()
handler = unwrap(api.get)
app_model = _app(tenant_id="t1")
with app.test_request_context("/console/api/apps/app/text-to-audio/voices?language=en", method="GET"):
response = handler(api, TextToSpeechVoiceQuery(language="en-US"), app_model=app_model)
assert response == expected_voices
@staticmethod
def test_audio_to_text_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = ChatMessageAudioApi()
method = unwrap(api.post)
response_payload = {"text": "hello"}
monkeypatch.setattr(AudioService, "transcript_asr", lambda **_kwargs: response_payload)
app_model = _app(app_id="app-1")
data = {"file": (io.BytesIO(b"x"), "sample.wav")}
with app.test_request_context(
"/console/api/apps/app-1/audio-to-text",
method="POST",
data=data,
content_type="multipart/form-data",
):
response = method(api, app_model=app_model)
assert response == response_payload
@staticmethod
def test_audio_to_text_maps_audio_too_large(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = ChatMessageAudioApi()
method = unwrap(api.post)
monkeypatch.setattr(
AudioService,
"transcript_asr",
lambda **_kwargs: (_ for _ in ()).throw(AudioTooLargeServiceError("too large")),
)
app_model = _app(app_id="app-1")
data = {"file": (io.BytesIO(b"x"), "sample.wav")}
with app.test_request_context(
"/console/api/apps/app-1/audio-to-text",
method="POST",
data=data,
content_type="multipart/form-data",
):
with pytest.raises(AudioTooLargeError):
method(api, app_model=app_model)
@staticmethod
def test_text_to_audio_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = ChatMessageTextApi()
method = unwrap(api.post)
monkeypatch.setattr(AudioService, "transcript_tts", lambda **_kwargs: {"audio": "ok"})
app_model = _app(app_id="app-1")
with app.test_request_context(
"/console/api/apps/app-1/text-to-audio",
method="POST",
json={"text": "hello"},
):
response = method(api, TextToSpeechPayload(text="hello"), app_model=app_model)
assert response == {"audio": "ok"}
@staticmethod
def test_text_to_audio_voices_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = TextModesApi()
method = unwrap(api.get)
expected_voices = [{"name": "Voice 1", "value": "voice-1"}]
monkeypatch.setattr(AudioService, "transcript_tts_voices", lambda **_kwargs: expected_voices)
app_model = _app()
with app.test_request_context(
"/console/api/apps/app-1/text-to-audio/voices",
method="GET",
query_string={"language": "en-US"},
):
response = method(api, TextToSpeechVoiceQuery(language="en-US"), app_model=app_model)
assert response == expected_voices
@staticmethod
def test_audio_to_text_with_invalid_file(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = ChatMessageAudioApi()
method = unwrap(api.post)
monkeypatch.setattr(AudioService, "transcript_asr", lambda **_kwargs: {"text": "test"})
app_model = _app(app_id="app-1")
data = {"file": (io.BytesIO(b"invalid"), "sample.xyz")}
with app.test_request_context(
"/console/api/apps/app-1/audio-to-text",
method="POST",
data=data,
content_type="multipart/form-data",
):
# Should not raise, AudioService is mocked
response = method(api, app_model=app_model)
assert response == {"text": "test"}
@staticmethod
def test_text_to_audio_with_language_param(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = ChatMessageTextApi()
method = unwrap(api.post)
monkeypatch.setattr(AudioService, "transcript_tts", lambda **_kwargs: {"audio": "test"})
app_model = _app(app_id="app-1")
with app.test_request_context(
"/console/api/apps/app-1/text-to-audio",
method="POST",
json={"text": "hello", "language": "en-US"},
):
response = method(api, TextToSpeechPayload(text="hello"), app_model=app_model)
assert response == {"audio": "test"}
@staticmethod
def test_text_to_audio_voices_with_language_filter(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
api = TextModesApi()
method = unwrap(api.get)
monkeypatch.setattr(
AudioService,
"transcript_tts_voices",
lambda **_kwargs: [{"name": "Voice 1", "value": "voice-1"}],
)
app_model = _app()
with app.test_request_context(
"/console/api/apps/app-1/text-to-audio/voices?language=en-US",
method="GET",
):
response = method(api, TextToSpeechVoiceQuery(language="en-US"), app_model=app_model)
assert isinstance(response, list)
@staticmethod
def test_agent_text_to_speech_voices_uses_backing_app_and_language(app: Flask, unbound_session: Session) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
app_model = _app(app_id="backing-app-1")
current_user = _account()
voices = [{"name": "Voice 1", "value": "voice-1"}]
api = AgentTextToSpeechVoicesApi()
with (
patch.object(
audio_module, "resolve_existing_agent_runtime_app_model", return_value=app_model
) as resolve_app,
patch.object(audio_module, "enforce_rbac_checks") as check_access,
patch.object(AudioService, "transcript_tts_voices", return_value=voices) as get_voices,
app.test_request_context(f"/console/api/agent/{agent_id}/text-to-audio/voices?language=en-US"),
):
response = unwrap(api.get)(
api,
TextToSpeechVoiceQuery(language="en-US"),
session=unbound_session,
current_tenant_id="tenant-1",
current_user=current_user,
agent_id=agent_id,
)
assert response == voices
resolve_app.assert_called_once_with(session=unbound_session, tenant_id="tenant-1", agent_id=agent_id)
check_access.assert_called_once()
rbac_call = check_access.call_args.kwargs
assert rbac_call["tenant_id"] == "tenant-1"
assert rbac_call["account_id"] == current_user.id
assert rbac_call["path_args"] == {"agent_id": str(agent_id)}
(rbac_check,) = rbac_call["checks"]
assert rbac_check.scene is audio_module.RBACPermission.AGENT_PREVIEW
assert isinstance(rbac_check.locator, audio_module.AgentId)
get_voices.assert_called_once_with(tenant_id="tenant-1", language="en-US")
@staticmethod
def test_agent_text_to_speech_voices_does_not_query_provider_without_permission(
app: Flask, unbound_session: Session
) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
api = AgentTextToSpeechVoicesApi()
with (
patch.object(audio_module, "resolve_existing_agent_runtime_app_model") as resolve_app,
patch.object(audio_module, "enforce_rbac_checks", side_effect=Forbidden()),
patch.object(AudioService, "transcript_tts_voices") as get_voices,
app.test_request_context(f"/console/api/agent/{agent_id}/text-to-audio/voices?language=en-US"),
pytest.raises(Forbidden),
):
unwrap(api.get)(
api,
TextToSpeechVoiceQuery(language="en-US"),
session=unbound_session,
current_tenant_id="tenant-1",
current_user=_account(),
agent_id=agent_id,
)
get_voices.assert_not_called()
resolve_app.assert_not_called()
@staticmethod
def test_agent_text_to_speech_voices_rejects_missing_language(app: Flask, unbound_session: Session) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
api = AgentTextToSpeechVoicesApi()
view = unwrap(api.get)
# Stop at the innermost decorator so request validation runs without the auth and session layers.
handler = unwrap(api.get, stop=lambda f: f.__dict__.get("__wrapped__") is view)
with (
patch.object(audio_module, "resolve_existing_agent_runtime_app_model") as resolve_app,
patch.object(audio_module, "enforce_rbac_checks") as check_access,
app.test_request_context(f"/console/api/agent/{agent_id}/text-to-audio/voices", method="GET"),
pytest.raises(UnprocessableEntity),
):
handler(
api,
session=unbound_session,
current_tenant_id="tenant-1",
current_user=_account(),
agent_id=agent_id,
)
check_access.assert_not_called()
resolve_app.assert_not_called()
@staticmethod
@pytest.mark.parametrize("message_id", [None, "019ef3d2-b24c-7803-b428-18b5ee8fb854"])
def test_agent_text_to_speech_returns_audio_with_scoped_message(
app: Flask, unbound_session: Session, message_id: str | None
) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
app_model = _app(app_id="backing-app-1")
current_user = _account()
payload = TextToSpeechPayload(text="Preview this voice", voice="voice-1", message_id=message_id)
audio = Response(b"RIFF\x00\x00\x00\x00WAVE", content_type="audio/wav")
api = AgentChatMessageTextApi()
with (
patch.object(
audio_module, "resolve_existing_agent_runtime_app_model", return_value=app_model
) as resolve_app,
patch.object(audio_module, "enforce_rbac_checks") as check_access,
patch.object(AudioService, "transcript_tts", return_value=audio) as synthesize,
app.test_request_context(f"/console/api/agent/{agent_id}/text-to-audio", method="POST"),
):
response = unwrap(api.post)(
api,
req_data=payload,
session=unbound_session,
current_tenant_id="tenant-1",
current_user=current_user,
agent_id=agent_id,
)
assert response.get_data() == audio.get_data()
assert response.content_type == "audio/wav"
resolve_app.assert_called_once_with(session=unbound_session, tenant_id="tenant-1", agent_id=agent_id)
check_access.assert_called_once()
rbac_call = check_access.call_args.kwargs
assert rbac_call["tenant_id"] == "tenant-1"
assert rbac_call["account_id"] == current_user.id
assert rbac_call["path_args"] == {"agent_id": str(agent_id)}
(rbac_check,) = rbac_call["checks"]
assert rbac_check.scene is audio_module.RBACPermission.AGENT_TEST_AND_RUN
assert isinstance(rbac_check.locator, audio_module.AgentId)
synthesize.assert_called_once_with(
app_model=app_model,
session=unbound_session,
text=payload.text,
voice=payload.voice,
message_ref=MessageRef(AppRef("tenant-1", "backing-app-1"), message_id, account_id=current_user.id)
if message_id
else None,
is_draft=True,
)
@staticmethod
def test_agent_text_to_speech_denies_access_before_resolving_app(app: Flask, unbound_session: Session) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
api = AgentChatMessageTextApi()
with (
patch.object(audio_module, "resolve_existing_agent_runtime_app_model") as resolve_app,
patch.object(audio_module, "enforce_rbac_checks", side_effect=Forbidden()),
patch.object(AudioService, "transcript_tts") as synthesize,
app.test_request_context(f"/console/api/agent/{agent_id}/text-to-audio", method="POST"),
pytest.raises(Forbidden),
):
unwrap(api.post)(
api,
req_data=TextToSpeechPayload(text="Preview"),
session=unbound_session,
current_tenant_id="tenant-1",
current_user=_account(),
agent_id=agent_id,
)
resolve_app.assert_not_called()
synthesize.assert_not_called()
@staticmethod
@pytest.mark.parametrize("voices", [False, True])
def test_agent_tts_preserves_missing_agent_error(app: Flask, unbound_session: Session, voices: bool) -> None:
agent_id = UUID("019ef3d2-b24c-7803-b428-18b5ee8fb853")
api = AgentTextToSpeechVoicesApi() if voices else AgentChatMessageTextApi()
handler = unwrap(api.get if isinstance(api, AgentTextToSpeechVoicesApi) else api.post)
args: dict[str, object] = {
"session": unbound_session,
"current_tenant_id": "tenant-1",
"current_user": _account(),
"agent_id": agent_id,
}
if voices:
args["req_data"] = TextToSpeechVoiceQuery(language="en-US")
else:
args["req_data"] = TextToSpeechPayload(text="Preview")
with (
patch.object(audio_module, "resolve_existing_agent_runtime_app_model", side_effect=AgentNotFoundError()),
patch.object(audio_module, "enforce_rbac_checks"),
patch.object(AudioService, "transcript_tts") as synthesize,
patch.object(AudioService, "transcript_tts_voices") as get_voices,
app.test_request_context(f"/console/api/agent/{agent_id}/text-to-audio?language=en-US"),
pytest.raises(AgentNotFoundError),
):
handler(api, **args)
synthesize.assert_not_called()
get_voices.assert_not_called()
@@ -0,0 +1,155 @@
from __future__ import annotations
from decimal import Decimal
from sqlalchemy.orm import Session
from fields.conversation_fields import ConversationResponseSource
from graphon.enums import WorkflowExecutionStatus
from models import Account, EndUser, Message, MessageAnnotation, MessageFeedback
from models.enums import (
ConversationFromSource,
CreatorUserRole,
EndUserType,
FeedbackFromSource,
FeedbackRating,
InvokeFrom,
WorkflowRunTriggeredFrom,
)
from models.model import AppMode, Conversation
from models.workflow import WorkflowRun, WorkflowType
from tests.helpers.unit.model_factories import make_conversation
def _make_account() -> Account:
account = Account(name="Account", email="account@example.com", timezone="UTC")
account.id = "u1"
return account
def _conversation(*, conversation_id: str = "c1", app_id: str = "app-1") -> Conversation:
return make_conversation(
conversation_id=conversation_id,
app_id=app_id,
inputs={},
introduction="",
system_instruction="",
system_instruction_tokens=0,
status="normal",
invoke_from=InvokeFrom.EXPLORE,
from_source=ConversationFromSource.CONSOLE,
from_account_id="u1",
)
def test_conversation_response_source_uses_caller_session(sqlite_session: Session) -> None:
account = _make_account()
end_user = EndUser(
id="end-user-1",
tenant_id="tenant-1",
app_id="app-1",
type=EndUserType.SERVICE_API,
external_user_id="external-user-1",
name="End user",
session_id="end-user-session",
)
conversation = _conversation()
conversation.mode = AppMode.ADVANCED_CHAT
conversation.override_model_configs = "{}"
conversation.summary = "summary"
conversation.inputs = {"topic": "support"}
conversation.from_end_user_id = end_user.id
conversation.from_account_id = account.id
message = Message(
id="message-1",
app_id=conversation.app_id,
model_provider=None,
model_id=None,
override_model_configs=None,
conversation_id=conversation.id,
_inputs={},
query="first question",
message={},
message_tokens=1,
message_unit_price=Decimal(0),
message_price_unit=Decimal("0.001"),
answer="answer",
answer_tokens=1,
answer_unit_price=Decimal(0),
answer_price_unit=Decimal("0.001"),
parent_message_id=None,
provider_response_latency=0,
total_price=Decimal(0),
currency="USD",
error=None,
message_metadata=None,
invoke_from=InvokeFrom.EXPLORE,
from_source=ConversationFromSource.CONSOLE,
from_end_user_id=end_user.id,
from_account_id=account.id,
workflow_run_id="run-1",
app_mode=AppMode.ADVANCED_CHAT,
)
annotation = MessageAnnotation(
app_id=conversation.app_id,
question="question",
content="annotation",
account_id=account.id,
conversation_id=conversation.id,
message_id=message.id,
)
feedbacks = [
MessageFeedback(
app_id=conversation.app_id,
conversation_id=conversation.id,
message_id=message.id,
rating=rating,
from_source=source,
from_account_id=account.id,
)
for source, rating in (
(FeedbackFromSource.USER, FeedbackRating.LIKE),
(FeedbackFromSource.USER, FeedbackRating.DISLIKE),
(FeedbackFromSource.ADMIN, FeedbackRating.LIKE),
)
]
workflow_run = WorkflowRun(
id="run-1",
tenant_id="tenant-1",
app_id=conversation.app_id,
workflow_id="workflow-1",
type=WorkflowType.WORKFLOW,
triggered_from=WorkflowRunTriggeredFrom.DEBUGGING,
version="1",
graph="{}",
inputs="{}",
status=WorkflowExecutionStatus.SUCCEEDED,
outputs="{}",
error=None,
elapsed_time=1,
total_tokens=1,
total_steps=1,
created_by_role=CreatorUserRole.ACCOUNT,
created_by=account.id,
finished_at=None,
exceptions_count=0,
)
sqlite_session.add_all([account, end_user, conversation, message, annotation, workflow_run, *feedbacks])
sqlite_session.commit()
source = ConversationResponseSource(conversation, session=sqlite_session)
assert source.inputs == {"topic": "support"}
assert source.model_config == {"model_id": None, "provider": None}
assert source.summary_or_query == "summary"
assert source.annotated is True
annotation_source = source.annotation
assert annotation_source is not None
assert annotation_source.account is account
assert source.message_count == 1
assert source.user_feedback_stats == {"like": 1, "dislike": 1}
assert source.admin_feedback_stats == {"like": 1, "dislike": 0}
assert source.status_count == {"success": 1, "failed": 0, "partial_success": 0, "paused": 0}
assert source.first_message is not None
assert source.from_end_user_session_id == "end-user-session"
assert source.from_account_name == "Account"
@@ -0,0 +1,245 @@
"""Console conversation-variable behavior through the decorated resource and real SQL."""
from collections.abc import Callable
from datetime import datetime, timedelta
from typing import TypedDict, cast
from unittest.mock import create_autospec
from uuid import UUID
import pytest
from flask import Flask
from sqlalchemy import Engine
from sqlalchemy.orm import Session, sessionmaker
from werkzeug.exceptions import Forbidden, UnprocessableEntity
from controllers.console.app.conversation_variables import ConversationVariablesApi
from controllers.console.app.error import AppNotFoundError
from controllers.console.workspace.error import AccountNotInitializedError
from controllers.console.wraps import RBACPermission
from enums import DeploymentEdition
from extensions.ext_application_services import build_application_services
from extensions.ext_database import db
from extensions.ext_redis import RedisClientWrapper
from factories import variable_factory
from libs import login
from models import AppMode, ConversationVariable
from models.account import Account, AccountStatus, TenantAccountRole
from models.agent import Agent, AgentScope, AgentSource, AgentStatus
from services.enterprise.rbac_service import RBACService
from tests.helpers.unit.model_factories import make_account, make_app, make_tenant
APP_ID = "11111111-1111-1111-1111-111111111111"
OTHER_APP_ID = "22222222-2222-2222-2222-222222222222"
CONVERSATION_ID = "33333333-3333-3333-3333-333333333333"
class VariablePage(TypedDict):
page: int
limit: int
total: int
has_more: bool
data: list[dict[str, str | int | None]]
@pytest.fixture(autouse=True)
def admitted_account(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
sqlite_engine: Engine,
sqlite_session: Session,
sqlite_session_factory: sessionmaker[Session],
) -> Account:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD, LOGIN_DISABLED=True, RBAC_ENABLED=False)
account = make_account(tenant=make_tenant(), role=TenantAccountRole.NORMAL)
monkeypatch.setattr(login, "_resolve_current_user", lambda: account)
# Legacy admission still reads through the request session. New query
# adapters use the separately owned session factory bound to the same DB.
monkeypatch.setattr(db, "session", sqlite_session)
monkeypatch.setattr(type(db), "engine", property(lambda _self: sqlite_engine))
services = build_application_services(
database_client=sqlite_session_factory,
deployment_edition=DeploymentEdition.CLOUD,
initialization_password="",
redis=create_autospec(RedisClientWrapper, instance=True),
)
monkeypatch.setitem(app.extensions, "application_services", services)
sqlite_session.add(make_app(app_id=APP_ID, mode=AppMode.ADVANCED_CHAT))
sqlite_session.commit()
return account
def _get(app: Flask, *, app_id: str = APP_ID, conversation_id: str | None = CONVERSATION_ID) -> VariablePage:
params: dict[str, str] = {} if conversation_id is None else {"conversation_id": conversation_id}
with app.test_request_context(f"/console/api/apps/{app_id}/conversation-variables", query_string=params):
response = ConversationVariablesApi().get(app_id=UUID(app_id))
assert isinstance(response, dict)
return cast(VariablePage, response)
def _variable(
name: str,
*,
app_id: str = APP_ID,
conversation_id: str = CONVERSATION_ID,
value_type: str = "string",
value: object = "value",
) -> ConversationVariable:
variable = variable_factory.build_conversation_variable_from_mapping(
{"id": f"draft-{name}", "name": name, "value_type": value_type, "value": value, "description": "description"}
)
return ConversationVariable.from_variable(app_id=app_id, conversation_id=conversation_id, variable=variable)
@pytest.mark.parametrize(
("value_type", "value", "exposed_type", "exposed_value"),
[
("string", "hello", "string", "hello"),
("integer", 42, "number", "42"),
("float", 1.5, "number", "1.5"),
("boolean", True, "boolean", "True"),
("array[string]", ["a", "b"], "array[string]", "['a', 'b']"),
("object", {"key": "value"}, "object", "{'key': 'value'}"),
("array[object]", [{"x": 1}], "array[object]", "[{'x': 1}]"),
],
)
def test_variable_wire_values_and_storage_id(
app: Flask,
sqlite_session: Session,
value_type: str,
value: object,
exposed_type: str,
exposed_value: str,
) -> None:
row = _variable("example", value_type=value_type, value=value)
row.created_at = datetime(2026, 1, 1)
row.updated_at = datetime(2026, 1, 2)
sqlite_session.add(row)
sqlite_session.commit()
response = _get(app)
assert response == {
"page": 1,
"limit": 100,
"total": 1,
"has_more": False,
"data": [
{
"id": row.id,
"name": "example",
"value_type": exposed_type,
"value": exposed_value,
"description": "description",
"created_at": int(row.created_at.timestamp()),
"updated_at": int(row.updated_at.timestamp()),
}
],
}
assert row.id != row.to_variable().id
def test_variables_are_scoped_by_app_and_conversation(app: Flask, sqlite_session: Session) -> None:
sqlite_session.add_all(
[
make_app(app_id=OTHER_APP_ID, tenant_id="tenant-2", mode=AppMode.ADVANCED_CHAT),
_variable("visible"),
_variable("other-app", app_id=OTHER_APP_ID),
_variable("other-conversation", conversation_id="44444444-4444-4444-4444-444444444444"),
]
)
sqlite_session.commit()
assert [item["name"] for item in _get(app)["data"]] == ["visible"]
@pytest.mark.parametrize("count", [0, 101])
def test_first_hundred_variables_keep_existing_envelope_and_order(
app: Flask, sqlite_session: Session, count: int
) -> None:
for index in reversed(range(count)):
row = _variable(f"var-{index}")
row.created_at = datetime(2026, 1, 1) + timedelta(seconds=index)
sqlite_session.add(row)
sqlite_session.commit()
response = _get(app)
assert response["page"] == 1
assert response["limit"] == 100
assert response["total"] == min(count, 100)
assert response["has_more"] is False
assert [item["name"] for item in response["data"]] == [f"var-{index}" for index in range(min(count, 100))]
@pytest.mark.parametrize("condition", ["missing", "other-workspace", "wrong-mode"])
@pytest.mark.parametrize("conversation_id", [None, CONVERSATION_ID])
def test_app_admission_precedes_query_validation(
app: Flask, sqlite_session: Session, condition: str, conversation_id: str | None
) -> None:
if condition != "missing":
sqlite_session.add(
make_app(
app_id=OTHER_APP_ID,
tenant_id="tenant-2" if condition == "other-workspace" else "tenant-1",
mode=AppMode.CHAT if condition == "wrong-mode" else AppMode.ADVANCED_CHAT,
)
)
sqlite_session.commit()
with pytest.raises(AppNotFoundError) as error:
_get(app, app_id=OTHER_APP_ID, conversation_id=conversation_id)
expected = (
"App mode is not in the supported list: {'advanced-chat'}" if condition == "wrong-mode" else "App not found."
)
assert error.value.description == expected
@pytest.mark.parametrize("status", [AgentStatus.ACTIVE, AgentStatus.ARCHIVED])
def test_hidden_workflow_agent_app_stays_hidden(app: Flask, sqlite_session: Session, status: AgentStatus) -> None:
sqlite_session.add(make_app(app_id=OTHER_APP_ID, mode=AppMode.AGENT))
sqlite_session.add(
Agent(
tenant_id="tenant-1",
name="Workflow agent",
scope=AgentScope.WORKFLOW_ONLY,
source=AgentSource.WORKFLOW,
status=status,
backing_app_id=OTHER_APP_ID,
)
)
sqlite_session.commit()
with pytest.raises(AppNotFoundError, match="App not found"):
_get(app, app_id=OTHER_APP_ID)
def test_missing_query_is_422_only_after_app_admission(app: Flask) -> None:
with pytest.raises(UnprocessableEntity, match="conversation_id"):
_get(app, conversation_id=None)
@pytest.mark.parametrize("allowed", [False, True])
def test_rbac_policy_is_enforced_before_query_validation(
app: Flask,
admitted_account: Account,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
allowed: bool,
) -> None:
config_overrides(RBAC_ENABLED=True)
check = create_autospec(RBACService.CheckAccess.check, return_value=allowed)
monkeypatch.setattr(RBACService.CheckAccess, "check", check)
expected_error = UnprocessableEntity if allowed else Forbidden
with pytest.raises(expected_error):
_get(app, conversation_id=None)
assert check.call_count == 1
assert check.call_args.args == ("tenant-1", admitted_account.id)
assert check.call_args.kwargs["scene"] == RBACPermission.APP_CREATE_AND_MANAGEMENT
def test_uninitialized_account_cannot_read(app: Flask, admitted_account: Account) -> None:
admitted_account.status = AccountStatus.UNINITIALIZED
with pytest.raises(AccountNotInitializedError):
_get(app, conversation_id=None)
@@ -0,0 +1,883 @@
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")
@@ -0,0 +1,374 @@
import datetime as _mcp_server_response_datetime
from collections.abc import Callable, Sequence
from dataclasses import dataclass, field
from datetime import datetime as _mcp_server_admission_datetime
from inspect import unwrap
from types import SimpleNamespace
from uuid import UUID
import pytest
from flask import Flask
from werkzeug.exceptions import Conflict, Forbidden, NotFound, UnprocessableEntity
from controllers.common.rbac import PlainApp, RBACCheck
from controllers.console import console_ns, flask_admission
from controllers.console.app import mcp_server
from controllers.console.app import mcp_server as module
from controllers.console.app.error import AppNotFoundError
from controllers.console.app.mcp_server import (
AppMCPServerController,
AppMCPServerRefreshController,
AppMCPServerResponse,
)
from controllers.console.wraps import RBACPermission
from libs.login import AccountWithTenant
from machinery.context import RequestContext
from models.account import TenantAccountRole
from services.app.mcp_server_service import (
AppMCPServerAlreadyExistsError,
AppMCPServerAppNotFoundError,
AppMCPServerNotFoundError,
AppMCPServerRecord,
AppMCPServerStatus,
)
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.model_factories import make_account
"""App MCP Server routes retain their role and RBAC policy under unified admission."""
_MCP_SERVER_ADMISSION_APP_ID = UUID("11111111-1111-1111-1111-111111111111")
_MCP_SERVER_ADMISSION_RECORD = AppMCPServerRecord(
id="server",
name="name",
server_code="code",
description="description",
status=AppMCPServerStatus.ACTIVE,
parameters="{}",
created_at=_mcp_server_admission_datetime(2024, 1, 1),
updated_at=_mcp_server_admission_datetime(2024, 1, 1),
)
MUTATIONS = [
AppMCPServerController.post,
AppMCPServerController.put,
AppMCPServerRefreshController.post,
]
def admission(method: Callable[..., object]) -> Callable[..., object]:
return unwrap(method, stop=lambda view: "inject_request_context" in view.__code__.co_qualname)
class TestMcpServerAdmissionCases:
@staticmethod
@pytest.mark.parametrize("method", MUTATIONS)
@pytest.mark.parametrize("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])
def test_readonly_roles_cannot_mutate(
app: Flask, monkeypatch: pytest.MonkeyPatch, method: Callable[..., object], role: TenantAccountRole
) -> None:
account = make_account(role=role)
apply_config_overrides(monkeypatch, RBAC_ENABLED=False)
monkeypatch.setattr(
flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, "workspace")
)
with app.test_request_context(), pytest.raises(Forbidden):
admission(method)(None, app_id=_MCP_SERVER_ADMISSION_APP_ID)
@staticmethod
@pytest.mark.parametrize(
("method", "permission"),
[
(AppMCPServerController.get, RBACPermission.APP_VIEW_LAYOUT),
(AppMCPServerController.post, RBACPermission.APP_EDIT),
(AppMCPServerController.put, RBACPermission.APP_EDIT),
(AppMCPServerRefreshController.post, RBACPermission.APP_EDIT),
],
)
def test_rbac_checks_keep_app_scope(
app: Flask, monkeypatch: pytest.MonkeyPatch, method: Callable[..., object], permission: RBACPermission
) -> None:
account = make_account(role=TenantAccountRole.NORMAL)
apply_config_overrides(monkeypatch, RBAC_ENABLED=True)
monkeypatch.setattr(
flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, "workspace")
)
called = []
def denied(
*, tenant_id: str, account_id: str, checks: Sequence[RBACCheck], path_args: dict[str, object]
) -> None:
assert (tenant_id, account_id) == ("workspace", account.id)
assert path_args == {"app_id": _MCP_SERVER_ADMISSION_APP_ID}
assert len(checks) == 1
assert checks[0].scene == permission
assert isinstance(checks[0].locator, PlainApp)
called.append(True)
raise Forbidden
monkeypatch.setattr(flask_admission, "enforce_rbac_checks", denied)
with app.test_request_context(), pytest.raises(Forbidden):
admission(method)(None, app_id=_MCP_SERVER_ADMISSION_APP_ID)
assert called == [True]
@staticmethod
@pytest.mark.parametrize("role", [TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR])
def test_edit_roles_reach_service_with_request_context(
app: Flask, monkeypatch: pytest.MonkeyPatch, role: TenantAccountRole
) -> None:
account = make_account(role=role)
apply_config_overrides(monkeypatch, RBAC_ENABLED=False)
monkeypatch.setattr(
flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, "workspace")
)
monkeypatch.setattr(flask_admission, "enforce_rbac_checks", lambda **_kwargs: None)
monkeypatch.setattr(flask_admission, "get_trace_id", lambda: None)
contexts: list[RequestContext] = []
def refresh(context: RequestContext, _app_id: str) -> AppMCPServerRecord:
contexts.append(context)
return _MCP_SERVER_ADMISSION_RECORD
monkeypatch.setattr(
mcp_server,
"application_services",
lambda: SimpleNamespace(app_mcp_servers=SimpleNamespace(refresh=refresh)),
)
with app.test_request_context(method="POST", headers={"X-Trace-Id": "trace"}):
response = admission(AppMCPServerRefreshController.post)(None, app_id=_MCP_SERVER_ADMISSION_APP_ID)
assert isinstance(response, dict)
assert response["id"] == _MCP_SERVER_ADMISSION_RECORD.id
assert [(c.account_id, c.active_workspace_id, c.trace_id) for c in contexts] == [
(account.id, "workspace", "trace")
]
@staticmethod
@pytest.mark.parametrize("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])
def test_readonly_roles_can_read(app: Flask, monkeypatch: pytest.MonkeyPatch, role: TenantAccountRole) -> None:
account = make_account(role=role)
apply_config_overrides(monkeypatch, RBAC_ENABLED=False)
monkeypatch.setattr(
flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, "workspace")
)
monkeypatch.setattr(flask_admission, "enforce_rbac_checks", lambda **_kwargs: None)
monkeypatch.setattr(
mcp_server,
"application_services",
lambda: SimpleNamespace(app_mcp_servers=SimpleNamespace(get=lambda _context, _app_id: None)),
)
with app.test_request_context():
assert admission(AppMCPServerController.get)(None, app_id=_MCP_SERVER_ADMISSION_APP_ID) == {}
CONTEXT = RequestContext("request", None, "account", "workspace")
SERVER_ID = "abcdefab-1234-4567-89ab-abcdefabcdef"
_MCP_SERVER_RESPONSE_APP_ID = UUID("11111111-1111-1111-1111-111111111111")
_MCP_SERVER_RESPONSE_RECORD = AppMCPServerRecord(
id="server",
name="name",
server_code="code",
description="description",
status=AppMCPServerStatus.ACTIVE,
parameters='{"timeout": 30}',
created_at=_mcp_server_response_datetime.datetime(2024, 1, 1, tzinfo=_mcp_server_response_datetime.UTC),
updated_at=_mcp_server_response_datetime.datetime(2024, 1, 2, tzinfo=_mcp_server_response_datetime.UTC),
)
@dataclass
class Servers:
result: AppMCPServerRecord | None = _MCP_SERVER_RESPONSE_RECORD
error: Exception | None = None
calls: list[tuple[str, str, dict[str, object]]] = field(default_factory=list)
def get(self, context: RequestContext, app_id: str) -> AppMCPServerRecord | None:
return self._call("get", app_id)
def create(self, context: RequestContext, app_id: str, **kwargs: object) -> AppMCPServerRecord | None:
return self._call("create", app_id, **kwargs)
def update(self, context: RequestContext, app_id: str, **kwargs: object) -> AppMCPServerRecord | None:
return self._call("update", app_id, **kwargs)
def refresh(self, context: RequestContext, app_id: str) -> AppMCPServerRecord | None:
return self._call("refresh", app_id)
def _call(self, method: str, app_id: str, **kwargs: object) -> AppMCPServerRecord | None:
self.calls.append((method, app_id, kwargs))
if self.error is not None:
raise self.error
return self.result
class TestMcpServerResponseCases:
@staticmethod
@pytest.fixture
def servers(monkeypatch: pytest.MonkeyPatch) -> Servers:
servers = Servers()
monkeypatch.setattr(module, "application_services", lambda: SimpleNamespace(app_mcp_servers=servers))
return servers
class TestAppMCPServerResponse:
def test_parameters_json_string_parsed(self) -> None:
data: dict[str, object] = {
"id": "s1",
"name": "test",
"server_code": "code",
"description": "desc",
"status": "active",
"parameters": '{"key": "value"}',
}
resp = AppMCPServerResponse.model_validate(data)
assert resp.parameters == {"key": "value"}
def test_parameters_invalid_json_returns_original(self) -> None:
data: dict[str, object] = {
"id": "s1",
"name": "test",
"server_code": "code",
"description": "desc",
"status": "active",
"parameters": "not-valid-json",
}
resp = AppMCPServerResponse.model_validate(data)
assert resp.parameters == "not-valid-json"
def test_parameters_dict_passthrough(self) -> None:
data: dict[str, object] = {
"id": "s1",
"name": "test",
"server_code": "code",
"description": "desc",
"status": "active",
"parameters": {"already": "parsed"},
}
resp = AppMCPServerResponse.model_validate(data)
assert resp.parameters == {"already": "parsed"}
def test_parameters_json_array_parsed(self) -> None:
data: dict[str, object] = {
"id": "s1",
"name": "test",
"server_code": "code",
"description": "desc",
"status": "active",
"parameters": '["a", "b"]',
}
resp = AppMCPServerResponse.model_validate(data)
assert resp.parameters == ["a", "b"]
def test_timestamps_normalized(self) -> None:
dt = _mcp_server_response_datetime.datetime(2024, 1, 1, 0, 0, 0, tzinfo=_mcp_server_response_datetime.UTC)
data: dict[str, object] = {
"id": "s1",
"name": "test",
"server_code": "code",
"description": "desc",
"status": "active",
"parameters": {},
"created_at": dt,
"updated_at": dt,
}
resp = AppMCPServerResponse.model_validate(data)
assert resp.created_at == int(dt.timestamp())
assert resp.updated_at == int(dt.timestamp())
def test_timestamps_none(self) -> None:
data: dict[str, object] = {
"id": "s1",
"name": "test",
"server_code": "code",
"description": "desc",
"status": "active",
"parameters": {},
}
resp = AppMCPServerResponse.model_validate(data)
assert resp.created_at is None
assert resp.updated_at is None
@staticmethod
def test_get_serializes_record_and_missing_server(servers: Servers) -> None:
method = unwrap(module.AppMCPServerController.get)
response = method(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID)
assert response["parameters"] == {"timeout": 30}
assert response["created_at"] == 1704067200
servers.result = None
assert method(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID) == {}
@staticmethod
def test_post_parses_input_and_returns_201(app: Flask, servers: Servers) -> None:
with app.test_request_context(method="POST", json={"parameters": {"timeout": 30}}):
response, status = unwrap(module.AppMCPServerController.post)(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID)
assert status == 201
assert response["id"] == "server"
assert servers.calls == [
("create", str(_MCP_SERVER_RESPONSE_APP_ID), {"description": None, "parameters": {"timeout": 30}})
]
@staticmethod
@pytest.mark.parametrize("candidate", [SERVER_ID, SERVER_ID.upper(), UUID(SERVER_ID).hex, "{" + SERVER_ID + "}"])
def test_put_normalizes_server_id_and_passes_status(app: Flask, servers: Servers, candidate: str) -> None:
body = {"id": candidate, "parameters": {}, "description": "updated", "status": "inactive"}
with app.test_request_context(method="PUT", json=body):
unwrap(module.AppMCPServerController.put)(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID)
assert servers.calls == [
(
"update",
str(_MCP_SERVER_RESPONSE_APP_ID),
{"server_id": SERVER_ID, "description": "updated", "parameters": {}, "status": "inactive"},
)
]
@staticmethod
@pytest.mark.parametrize(
"body",
[
pytest.param({"id": "not-a-uuid", "parameters": {}}, id="malformed-id"),
pytest.param({"id": SERVER_ID, "parameters": {}, "status": "paused"}, id="unknown-status"),
pytest.param({"id": SERVER_ID, "parameters": {}, "status": ""}, id="blank-status"),
],
)
def test_put_rejects_invalid_payload_before_calling_service(
app: Flask, servers: Servers, body: dict[str, object]
) -> None:
with app.test_request_context(method="PUT", json=body), pytest.raises(UnprocessableEntity):
unwrap(module.AppMCPServerController.put)(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID)
assert servers.calls == []
@staticmethod
@pytest.mark.parametrize(
"method",
[
module.AppMCPServerController.get,
module.AppMCPServerController.post,
module.AppMCPServerController.put,
module.AppMCPServerRefreshController.post,
],
)
def test_unavailable_app_becomes_app_404(app: Flask, servers: Servers, method: Callable[..., object]) -> None:
servers.error = AppMCPServerAppNotFoundError()
with (
app.test_request_context(method="POST", json={"id": SERVER_ID, "parameters": {}}),
pytest.raises(AppNotFoundError) as error,
):
unwrap(method)(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID)
assert error.value.description == AppNotFoundError.description
@staticmethod
@pytest.mark.parametrize("method", [module.AppMCPServerController.put, module.AppMCPServerRefreshController.post])
def test_missing_server_becomes_404(app: Flask, servers: Servers, method: Callable[..., object]) -> None:
servers.error = AppMCPServerNotFoundError()
with app.test_request_context(method="POST", json={"id": SERVER_ID, "parameters": {}}), pytest.raises(NotFound):
unwrap(method)(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID)
@staticmethod
def test_duplicate_create_becomes_409(app: Flask, servers: Servers) -> None:
servers.error = AppMCPServerAlreadyExistsError()
with app.test_request_context(method="POST", json={"parameters": {}}), pytest.raises(Conflict):
unwrap(module.AppMCPServerController.post)(None, CONTEXT, _MCP_SERVER_RESPONSE_APP_ID)
@staticmethod
def test_routes_stay_app_scoped() -> None:
route_map = {resource.__name__: urls for resource, urls, _, _ in console_ns.resources}
assert route_map["AppMCPServerController"] == ("/apps/<uuid:app_id>/server",)
assert route_map["AppMCPServerRefreshController"] == ("/apps/<uuid:app_id>/server/refresh",)
assert not hasattr(module.AppMCPServerRefreshController, "get")
@@ -0,0 +1,273 @@
from __future__ import annotations
from datetime import UTC, datetime
import pytest
from flask import Flask
from sqlalchemy.orm import Session
from controllers.console.app import message as message_module
from core.app.entities.app_invoke_entities import InvokeFrom
from fields.conversation_fields import MessageResponseSource
from models.account import Account
from models.enums import ConversationFromSource, CreatorUserRole, FeedbackFromSource, FeedbackRating
from models.model import (
App,
AppAnnotationHitHistory,
AppMode,
Conversation,
Message,
MessageAgentThought,
MessageAnnotation,
MessageFeedback,
)
def _account() -> Account:
account = Account(name="Account", email="account@example.com")
account.id = "account-1"
return account
def _app(*, app_id: str = "app-1") -> App:
return App(
id=app_id,
tenant_id="tenant-1",
name="Chat App",
description="",
mode=AppMode.CHAT,
enable_site=True,
enable_api=True,
max_active_requests=0,
)
def _persist_message(session: Session, *, message_id: str, app_id: str = "app-1") -> Message:
conversation = Conversation(
app_id=app_id,
app_model_config_id=None,
model_provider=None,
override_model_configs=None,
model_id=None,
mode=AppMode.CHAT,
name="Conversation",
_inputs={},
introduction="",
system_instruction="",
system_instruction_tokens=0,
status="normal",
invoke_from=InvokeFrom.DEBUGGER,
from_source=ConversationFromSource.CONSOLE,
from_end_user_id=None,
from_account_id="account-1",
)
conversation.id = "conversation-1"
message = Message(
app_id=app_id,
conversation_id=conversation.id,
_inputs={},
query="query",
message="",
message_tokens=0,
message_unit_price=0,
message_price_unit=0,
answer="answer",
answer_tokens=0,
answer_unit_price=0,
answer_price_unit=0,
provider_response_latency=0,
total_price=0,
currency="USD",
invoke_from=InvokeFrom.DEBUGGER,
from_source=ConversationFromSource.CONSOLE,
from_end_user_id=None,
from_account_id="account-1",
app_mode=AppMode.CHAT,
)
message.id = message_id
session.add_all([_account(), _app(app_id=app_id), conversation, message])
session.flush()
return message
class TestMessageApiCases:
@staticmethod
def test_message_response_source_uses_caller_session_for_nested_fields(sqlite_session: Session) -> None:
session = sqlite_session
message_id = "550e8400-e29b-41d4-a716-446655440000"
message = _persist_message(sqlite_session, message_id=message_id)
message.inputs = {"topic": "support"}
feedback = MessageFeedback(
app_id=message.app_id,
conversation_id=message.conversation_id,
message_id=message.id,
rating=FeedbackRating.LIKE,
from_source=FeedbackFromSource.USER,
from_account_id="account-1",
)
annotation = MessageAnnotation(
app_id=message.app_id,
question="Question",
content="Answer",
account_id="account-1",
conversation_id=message.conversation_id,
message_id=message.id,
)
annotation.id = "annotation-1"
annotation_hit = AppAnnotationHitHistory(
app_id=message.app_id,
annotation_id=annotation.id,
source="annotation",
question="Question",
account_id="account-1",
score=0.0,
message_id=message.id,
annotation_question="Question",
annotation_content="Answer",
)
thought = MessageAgentThought(
message_id=message.id,
position=1,
created_by_role=CreatorUserRole.ACCOUNT,
created_by="account-1",
thought="Consider the request",
tool_labels_str="{}",
tool_meta_str="{}",
)
sqlite_session.add_all([feedback, annotation, annotation_hit, thought])
sqlite_session.commit()
source = MessageResponseSource(message, session=session)
assert source.inputs == {"topic": "support"}
assert source.user_feedback is feedback
assert source.feedbacks[0].from_account.id == "account-1"
annotation_source = source.annotation
assert annotation_source is not None
assert annotation_source.account.id == "account-1"
annotation_hit_history_source = source.annotation_hit_history
assert annotation_hit_history_source is not None
assert annotation_hit_history_source.annotation_create_account.id == "account-1"
assert source.agent_thoughts == [thought]
assert source.message_files == []
@staticmethod
def test_chat_messages_query_valid(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Test valid ChatMessagesQuery with all fields."""
query = message_module.ChatMessagesQuery(
conversation_id="550e8400-e29b-41d4-a716-446655440000",
first_id="550e8400-e29b-41d4-a716-446655440001",
limit=50,
)
assert query.limit == 50
@staticmethod
def test_chat_messages_query_defaults(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Test ChatMessagesQuery with defaults."""
query = message_module.ChatMessagesQuery(conversation_id="550e8400-e29b-41d4-a716-446655440000")
assert query.first_id is None
assert query.limit == 20
@staticmethod
def test_chat_messages_query_empty_first_id(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Test ChatMessagesQuery converts empty first_id to None."""
query = message_module.ChatMessagesQuery(
conversation_id="550e8400-e29b-41d4-a716-446655440000",
first_id="",
)
assert query.first_id is None
@staticmethod
def test_message_feedback_payload_valid_like(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Test AppMessageFeedbackPayload with like rating."""
payload = message_module.AppMessageFeedbackPayload(
message_id="550e8400-e29b-41d4-a716-446655440000",
rating="like",
content="Good answer",
)
assert payload.rating == "like"
assert payload.content == "Good answer"
@staticmethod
def test_message_feedback_payload_valid_dislike(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Test AppMessageFeedbackPayload with dislike rating."""
payload = message_module.AppMessageFeedbackPayload(
message_id="550e8400-e29b-41d4-a716-446655440000",
rating="dislike",
)
assert payload.rating == "dislike"
@staticmethod
def test_message_feedback_payload_no_rating(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
"""Test AppMessageFeedbackPayload without rating."""
payload = message_module.AppMessageFeedbackPayload(message_id="550e8400-e29b-41d4-a716-446655440000")
assert payload.rating is None
@staticmethod
@staticmethod
def test_message_detail_response_normalizes_aliases_and_timestamp(
app: Flask, monkeypatch: pytest.MonkeyPatch
) -> None:
"""Test MessageDetailResponse normalizes alias fields and datetime timestamps."""
created_at = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
response = message_module.MessageDetailResponse.model_validate(
{
"id": "550e8400-e29b-41d4-a716-446655440000",
"conversation_id": "550e8400-e29b-41d4-a716-446655440001",
"inputs": {"foo": "bar"},
"query": "hello",
"message": [{"text": "hello"}],
"message_tokens": 7,
"answer": "world",
"answer_tokens": 11,
"provider_response_latency": 1.25,
"from_source": "user",
"from_end_user_id": None,
"from_account_id": "550e8400-e29b-41d4-a716-446655440002",
"feedbacks": [],
"workflow_run_id": None,
"annotation": None,
"annotation_hit_history": None,
"status": "normal",
"created_at": created_at,
"agent_thoughts": [],
"message_files": [],
"message_metadata_dict": {"token_usage": 3},
"error": None,
"parent_message_id": None,
"extra_contents": [],
}
)
assert response.answer == "world"
assert response.message_tokens == 7
assert response.answer_tokens == 11
assert response.provider_response_latency == 1.25
assert response.metadata == {"token_usage": 3}
assert response.created_at == int(created_at.timestamp())
assert response.model_dump(mode="json") == {
"id": "550e8400-e29b-41d4-a716-446655440000",
"conversation_id": "550e8400-e29b-41d4-a716-446655440001",
"inputs": {"foo": "bar"},
"query": "hello",
"message": [{"text": "hello"}],
"message_tokens": 7,
"answer": "world",
"answer_tokens": 11,
"provider_response_latency": 1.25,
"from_source": "user",
"from_end_user_id": None,
"from_account_id": "550e8400-e29b-41d4-a716-446655440002",
"feedbacks": [],
"workflow_run_id": None,
"annotation": None,
"annotation_hit_history": None,
"created_at": int(created_at.timestamp()),
"agent_thoughts": [],
"message_files": [],
"metadata": {"token_usage": 3},
"retriever_resources": [],
"status": "normal",
"error": None,
"parent_message_id": None,
"extra_contents": [],
}
@@ -0,0 +1,894 @@
from __future__ import annotations
import importlib
import json
import os
from copy import deepcopy
from dataclasses import dataclass
from inspect import unwrap
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import DEFAULT, MagicMock
from uuid import uuid4
import pytest
import yaml
from flask import Flask
from flask.testing import FlaskClient
from flask_restx import Resource
from sqlalchemy import func, select
from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session, object_session, sessionmaker
from controllers.common import session as controller_session
from controllers.console.app import model_config as model_config_module
from core.app.app_config.easy_ui_based_app.dataset.manager import DatasetConfigManager
from core.app.app_config.easy_ui_based_app.model_config import manager as model_config_manager_module
from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfigManager
from core.app.apps.chat.app_config_manager import ChatAppConfigManager
from core.app.apps.completion.app_config_manager import CompletionAppConfigManager
from fields.app_model_config_response import AppModelConfigResponse
from libs.external_api import ExternalApi
from models.model import App, AppMode, AppModelConfig
from models.provider_ids import ModelProviderID
app_wraps_module = importlib.import_module("controllers.console.app.wraps")
def _model_config_payload(**fields: object) -> dict[str, object]:
return {
"model": {
"provider": "langgenius/openai/openai",
"name": "gpt-4o-mini",
"completion_params": {},
},
**fields,
}
def _existing_publish_configs() -> list[tuple[str, AppMode, dict[str, object]]]:
recommended_apps_path = Path(__file__).resolve().parents[5] / "constants" / "recommended_apps.json"
recommended_apps = json.loads(recommended_apps_path.read_text())["app_details"]
cases = []
for app_detail in recommended_apps.values():
payload = yaml.safe_load(app_detail["export_data"]).get("model_config")
if payload is not None:
cases.append((app_detail["name"], AppMode.value_of(app_detail["mode"]), payload))
# Mirrors the publish body's advanced-prompt, dataset-selection, and feature fields.
cases.append(
(
"configuration-editor-publish",
AppMode.CHAT,
_model_config_payload(
model={
"provider": "langgenius/openai/openai",
"name": "gpt-4o",
"mode": "chat",
"completion_params": {"temperature": 0.7},
},
pre_prompt="",
prompt_type="advanced",
chat_prompt_config={"prompt": [{"role": "system", "text": "hi"}]},
completion_prompt_config={
"prompt": {"text": "completion"},
"conversation_histories_role": {"assistant_prefix": "assistant", "user_prefix": "user"},
},
user_input_form=[{"text-input": {"label": "Name", "variable": "name", "required": True}}],
dataset_query_variable="context",
dataset_configs={
"retrieval_model": "multiple",
"datasets": {"datasets": [{"dataset": {"enabled": True, "id": "dataset-1"}}]},
},
agent_mode={"enabled": True, "max_iteration": 3, "strategy": "function_call", "tools": []},
external_data_tools=[],
more_like_this={"enabled": True},
opening_statement="hello",
suggested_questions=["how are you?"],
suggested_questions_after_answer={"enabled": False},
speech_to_text={"enabled": False},
text_to_speech={"enabled": False, "voice": "", "language": ""},
retriever_resource={"enabled": True},
sensitive_word_avoidance={"enabled": False},
file_upload={
"enabled": True,
"image": {
"enabled": True,
"detail": "high",
"number_limits": 2,
"transfer_methods": ["local_file"],
},
},
system_parameters={
"audio_file_size_limit": 1,
"file_size_limit": 1,
"image_file_size_limit": 1,
"video_file_size_limit": 1,
"workflow_file_upload_limit": 1,
},
),
)
)
return cases
@dataclass
class _ModelConfigHttp:
client: FlaskClient
app_model: App
session: Session
validate_configuration: MagicMock
signal: MagicMock
@pytest.fixture
def model_config_http(sqlite_session: Session, monkeypatch: pytest.MonkeyPatch) -> _ModelConfigHttp:
app_model = App(
id="app-1",
mode=AppMode.CHAT,
app_model_config_id="config-0",
updated_by=None,
)
original_config = AppModelConfig(app_id=app_model.id, created_by="u1", updated_by="u1")
original_config.id = "config-0"
sqlite_session.add(original_config)
sqlite_session.commit()
validate_configuration = MagicMock(
wraps=model_config_module.AppModelConfigService.validate_configuration,
return_value={"pre_prompt": "Validated prompt"},
)
monkeypatch.setattr(model_config_module.AppModelConfigService, "validate_configuration", validate_configuration)
signal = MagicMock()
monkeypatch.setattr(model_config_module.app_model_config_was_updated, "send", signal)
class ModelConfigHttpResource(Resource):
def post(self):
# Admission is supplied by this harness; parsing and HTTP errors use the real controller and API.
return unwrap(model_config_module.ModelConfigResource.post)(
model_config_module.ModelConfigResource(), sqlite_session, "t1", "u1", app_model=app_model
)
http_app = Flask(__name__)
http_app.config.update(TESTING=True)
ExternalApi(http_app).add_resource(ModelConfigHttpResource, "/apps/app-1/model-config")
return _ModelConfigHttp(http_app.test_client(), app_model, sqlite_session, validate_configuration, signal)
@pytest.fixture
def real_model_config_validation(model_config_http: _ModelConfigHttp, monkeypatch: pytest.MonkeyPatch) -> None:
assembly = MagicMock()
assembly.model_provider_factory.get_providers.return_value = [SimpleNamespace(provider="langgenius/openai/openai")]
assembly.provider_manager.get_configurations.return_value.get_models.return_value = [
SimpleNamespace(model="gpt-4o-mini", model_properties={"mode": "chat"})
]
monkeypatch.setattr(model_config_manager_module, "create_plugin_model_assembly", lambda **_kwargs: assembly)
monkeypatch.setattr(DatasetConfigManager, "is_dataset_exists", lambda *_args: True)
monkeypatch.setattr(
model_config_module.ToolManager,
"get_agent_tool_runtime",
MagicMock(side_effect=ValueError("Tool provider is unavailable in this test")),
)
model_config_http.validate_configuration.return_value = DEFAULT
def test_post_preserves_configuration_wire_for_business_validation(model_config_http: _ModelConfigHttp) -> None:
payload = _model_config_payload(
model={
"provider": "langgenius/openai/openai",
"name": "gpt-4o-mini",
"mode": "chat",
"completion_params": {
"temperature": 0,
"stop": [],
"provider_options": {"cache": False, "routing": {"fallback": None}},
},
},
pre_prompt="Answer {{topic}}",
prompt_type="advanced",
chat_prompt_config={"prompt": [{"role": "system", "text": "Answer {{topic}}"}]},
completion_prompt_config={
"prompt": {"text": "{{topic}}"},
"conversation_histories_role": {"user_prefix": "Human", "assistant_prefix": "Assistant"},
},
user_input_form=[
{"text-input": {"label": "Topic", "variable": "topic", "required": False, "default": ""}},
{"select": {"label": "Style", "variable": "style", "options": ["brief", "detailed"], "required": True}},
],
dataset_query_variable="topic",
dataset_configs={
"retrieval_model": "multiple",
"top_k": 3,
"score_threshold": 0,
"score_threshold_enabled": False,
"datasets": {"datasets": [{"dataset": {"id": "dataset-1", "enabled": True}}]},
"weights": {
"vector_setting": {
"vector_weight": 0.7,
"embedding_provider_name": "provider",
"embedding_model_name": "model",
},
"keyword_setting": {"keyword_weight": 0.3},
},
},
agent_mode={
"enabled": True,
"strategy": "function_call",
"max_iteration": 5,
"tools": [
{
"provider_id": "provider",
"provider_type": "builtin",
"tool_name": "search",
"tool_parameters": {
"query": "{{topic}}",
"limit": 0,
"filters": {"archived": False, "tags": ["docs", None, {"score": 0.5}]},
},
}
],
},
file_upload={
"enabled": True,
"number_limits": 3,
"allowed_file_types": ["image", "document"],
"allowed_file_extensions": [".pdf"],
"allowed_file_upload_methods": ["local_file", "remote_url"],
"image": {"enabled": True, "number_limits": 3, "transfer_methods": ["remote_url"]},
},
external_data_tools=[
{
"enabled": True,
"type": "api",
"label": "Context",
"variable": "context",
"config": {"api_based_extension_id": "extension-1", "options": {"limit": 0, "enabled": False}},
}
],
opening_statement="Hello",
suggested_questions=["What can you do?"],
suggested_questions_after_answer={"enabled": True},
more_like_this={"enabled": False},
speech_to_text={"enabled": True},
text_to_speech={"enabled": True, "voice": "alloy", "language": "en-US"},
retriever_resource={"enabled": True},
sensitive_word_avoidance={
"enabled": True,
"type": "keywords",
"config": {"keywords": "blocked", "inputs_config": {"enabled": True, "preset_response": ""}},
},
)
response = model_config_http.client.post("/apps/app-1/model-config", json=payload)
assert response.status_code == 200, response.get_json()
assert response.get_json() == {"result": "success"}
model_config_http.validate_configuration.assert_called_once_with(
tenant_id="t1", config=payload, app_mode=AppMode.CHAT, session=model_config_http.session
)
stored_config = model_config_http.session.get(AppModelConfig, model_config_http.app_model.app_model_config_id)
assert stored_config is not None
assert stored_config.pre_prompt == "Validated prompt"
assert model_config_http.signal.call_args.kwargs["session"] is model_config_http.session
@pytest.mark.parametrize(
"optional_fields",
[
{},
{
"pre_prompt": "",
"opening_statement": "",
"suggested_questions": [],
"chat_prompt_config": None,
"completion_prompt_config": None,
"file_upload": None,
"dataset_configs": {"score_threshold": 0, "score_threshold_enabled": False},
"agent_mode": {"enabled": False, "tools": []},
"speech_to_text": {"enabled": False},
"text_to_speech": {"enabled": False, "voice": ""},
"external_data_tools": [],
},
],
ids=["omitted", "explicit-empty-disabled-and-null"],
)
def test_post_keeps_optional_values_for_domain_defaults(
model_config_http: _ModelConfigHttp, optional_fields: dict[str, object]
) -> None:
payload = _model_config_payload(**optional_fields)
response = model_config_http.client.post("/apps/app-1/model-config", json=payload)
assert response.status_code == 200, response.get_json()
assert model_config_http.validate_configuration.call_args.kwargs["config"] == payload
@pytest.mark.parametrize(("case_name", "app_mode", "payload"), _existing_publish_configs())
def test_post_preserves_existing_publish_results(
model_config_http: _ModelConfigHttp,
monkeypatch: pytest.MonkeyPatch,
case_name: str,
app_mode: AppMode,
payload: dict[str, object],
) -> None:
selected_model = payload["model"]
assert isinstance(selected_model, dict)
assembly = MagicMock()
assembly.model_provider_factory.get_providers.return_value = [
SimpleNamespace(provider=str(ModelProviderID(selected_model["provider"])))
]
assembly.provider_manager.get_configurations.return_value.get_models.return_value = [
SimpleNamespace(model=selected_model["name"], model_properties={"mode": selected_model.get("mode", "chat")})
]
monkeypatch.setattr(model_config_manager_module, "create_plugin_model_assembly", lambda **_kwargs: assembly)
monkeypatch.setattr(
model_config_module.ToolManager,
"get_agent_tool_runtime",
MagicMock(side_effect=ValueError("Tool provider is unavailable in this test")),
)
config_manager = {
AppMode.CHAT: ChatAppConfigManager,
AppMode.COMPLETION: CompletionAppConfigManager,
AppMode.AGENT_CHAT: AgentChatAppConfigManager,
}[app_mode]
expected_config = config_manager.config_validate("t1", deepcopy(payload), model_config_http.session)
expected_record = AppModelConfig(app_id="app-1", created_by="u1", updated_by="u1").from_model_config_dict(
expected_config
)
assert "system_parameters" not in expected_config
assert "annotation_reply" not in expected_config
model_config_http.app_model.mode = app_mode
model_config_http.validate_configuration.return_value = DEFAULT
response = model_config_http.client.post("/apps/app-1/model-config", json=payload)
assert response.status_code == 200, (case_name, response.get_json())
assert response.get_json() == {"result": "success"}
stored_config = model_config_http.session.get(AppModelConfig, model_config_http.app_model.app_model_config_id)
assert stored_config is not None
assert stored_config.to_dict(annotation_reply={"enabled": False}) == expected_record.to_dict(
annotation_reply={"enabled": False}
), case_name
assert model_config_http.signal.call_args.kwargs["session"] is model_config_http.session
@pytest.mark.parametrize("app_mode", [AppMode.CHAT, AppMode.COMPLETION, AppMode.AGENT_CHAT])
@pytest.mark.usefixtures("real_model_config_validation")
@pytest.mark.parametrize(
("fields", "stored_path", "expected_value"),
[
(
{
"chat_prompt_config": {"prompt": [{"text": "Chat", "role": "system"}]},
"completion_prompt_config": {"prompt": {"text": "Completion"}},
},
("completion_prompt_config", "prompt"),
{"text": "Completion"},
),
(
{"text_to_speech": {}, "suggested_questions_after_answer": {}},
("text_to_speech",),
{"enabled": False, "voice": "", "language": ""},
),
(
{
"user_input_form": [
{
"text-input": {
"label": "Topic",
"variable": "topic",
"max_length": None,
"json_schema": None,
"icon": None,
"extension": {"values": [None, False, 0]},
}
}
]
},
("user_input_form",),
[
{
"text-input": {
"label": "Topic",
"variable": "topic",
"max_length": None,
"json_schema": None,
"icon": None,
"required": False,
"extension": {"values": [None, False, 0]},
}
}
],
),
(
{"user_input_form": [{"select": {"label": "Topic", "variable": "topic", "options": None}}]},
("user_input_form",),
[{"select": {"label": "Topic", "variable": "topic", "options": [], "required": False}}],
),
(
{"dataset_configs": {"datasets": {}}},
("dataset_configs", "datasets"),
{"strategy": "router", "datasets": []},
),
(
{"file_upload": {"image_config": {"enabled": None}}},
("file_upload",),
{"image_config": {"enabled": None}},
),
(
{
"agent_mode": {
"strategy": "react",
"tools": [
{
"enabled": None,
"provider_type": "builtin",
"provider_id": "time",
"tool_name": "time",
"tool_parameters": {},
"credential_id": None,
"plugin_unique_identifier": None,
}
],
"prompt": None,
}
},
("agent_mode", "tools"),
[
{
"provider_type": "builtin",
"provider_id": "time",
"tool_name": "time",
"tool_parameters": {},
"credential_id": None,
"plugin_unique_identifier": None,
"enabled": False,
}
],
),
],
ids=[
"completion-prompt-without-role",
"omitted-feature-options",
"nullable-input-values-and-json-extensions",
"select-null-options",
"empty-dataset-collection",
"image-config-null-extension",
"nullable-agent-credentials-and-prompt",
],
)
def test_post_persists_readable_configuration_variants(
model_config_http: _ModelConfigHttp,
app_mode: AppMode,
fields: dict[str, object],
stored_path: tuple[str, ...],
expected_value: object,
) -> None:
model_config_http.app_model.mode = app_mode
response = model_config_http.client.post("/apps/app-1/model-config", json=_model_config_payload(**deepcopy(fields)))
assert response.status_code == 200, response.get_json()
stored_config = model_config_http.session.get(AppModelConfig, model_config_http.app_model.app_model_config_id)
assert stored_config is not None
wire = stored_config.to_dict(annotation_reply={"enabled": False})
AppModelConfigResponse.model_validate(
{
**wire,
"created_by": stored_config.created_by,
"created_at": stored_config.created_at,
"updated_by": stored_config.updated_by,
"updated_at": stored_config.updated_at,
}
)
actual: object = wire
for key in stored_path:
assert isinstance(actual, dict)
actual = actual[key]
assert actual == expected_value
@pytest.mark.parametrize("app_mode", [AppMode.CHAT, AppMode.COMPLETION])
@pytest.mark.parametrize("strategy", ["router", "react"])
@pytest.mark.usefixtures("real_model_config_validation")
def test_post_keeps_legacy_tools_readable_across_planning_strategies(
model_config_http: _ModelConfigHttp, app_mode: AppMode, strategy: str
) -> None:
model_config_http.app_model.mode = app_mode
tools = [
{
"extension": {"values": [None, False]},
"dataset": {"id": "00000000-0000-0000-0000-000000000001", "enabled": None},
},
{"google_search": {"enabled": None}},
{"web_reader": {}},
{"wikipedia": {"enabled": False}},
{"current_datetime": {"enabled": True}},
{"sensitive-word-avoidance": {"enabled": False, "words": [], "canned_response": ""}},
]
response = model_config_http.client.post(
"/apps/app-1/model-config", json=_model_config_payload(agent_mode={"strategy": strategy, "tools": tools})
)
assert response.status_code == 200, response.get_json()
stored_config = model_config_http.session.get(AppModelConfig, model_config_http.app_model.app_model_config_id)
assert stored_config is not None
AppModelConfigResponse.model_validate(
{
**stored_config.to_dict(annotation_reply={"enabled": False}),
"created_by": stored_config.created_by,
"created_at": stored_config.created_at,
"updated_by": stored_config.updated_by,
"updated_at": stored_config.updated_at,
}
)
assert stored_config.agent_mode_dict["tools"] == [
{
"dataset": {"id": "00000000-0000-0000-0000-000000000001", "enabled": False},
"extension": {"values": [None, False]},
},
{"google_search": {"enabled": False}},
{"web_reader": {"enabled": False}},
{"wikipedia": {"enabled": False}},
{"current_datetime": {"enabled": True}},
{"sensitive-word-avoidance": {"enabled": False, "words": [], "canned_response": ""}},
]
@pytest.mark.parametrize(
"invalid_fields",
[
{"model": "gpt-4o-mini"},
{"model": {"provider": "langgenius/openai/openai", "name": "gpt-4o-mini", "completion_params": []}},
{"user_input_form": {"text-input": {"variable": "topic"}}},
{"file_upload": []},
{"chat_prompt_config": {"prompt": [{"role": "system", "text": {"invalid": "prompt"}}]}},
{"completion_prompt_config": {"conversation_histories_role": {"user_prefix": []}}},
{"user_input_form": [{"select": {"label": "Style", "variable": "style", "options": {"brief": True}}}]},
{"dataset_configs": {"weights": {"vector_setting": {"vector_weight": {"invalid": 0.7}}}}},
{
"agent_mode": {
"tools": [
{
"provider_id": "provider",
"provider_type": "builtin",
"tool_name": "search",
"tool_parameters": [],
}
]
}
},
{"file_upload": {"image": {"transfer_methods": "remote_url"}}},
{"speech_to_text": {"enabled": {"invalid": True}}},
{"external_data_tools": [{"enabled": True, "type": "api", "config": []}]},
{"chat_prompt_config": {"prompt": [{"text": "Missing role"}]}},
{"chat_prompt_config": {"prompt": None}},
{"completion_prompt_config": {"conversation_histories_role": {"user_prefix": "Human"}}},
{"text_to_speech": {"voice": None}},
{"suggested_questions_after_answer": {"model": None}},
{
"suggested_questions_after_answer": {
"model": {"provider": "provider", "name": "model", "completion_params": None}
}
},
{"file_upload": {"allowed_file_types": None}},
{"user_input_form": [{"text-input": {"label": "Topic", "variable": "topic", "options": None}}]},
{"dataset_configs": {"datasets": {"datasets": [{"dataset": {"enabled": None}}]}}},
{"file_upload": {"image": {"enabled": None}}},
{"dataset_configs": {"datasets": {"strategy": "router"}}},
{"dataset_configs": {"weights": {"vector_setting": {"vector_weight": 0.7}}}},
{"dataset_configs": {"metadata_filtering_conditions": {"conditions": [{"comparison_operator": "is"}]}}},
{"dataset_configs": {"retrieval_model": "unsupported"}},
{
"dataset_configs": {
"metadata_filtering_conditions": {
"conditions": [{"name": "topic", "comparison_operator": "unsupported"}]
}
}
},
{"suggested_questions_after_answer": {"model": {"provider": "p", "name": "m", "mode": "unsupported"}}},
{"agent_mode": {"tools": [{}]}},
{"agent_mode": {"tools": [{"enabled": False}]}},
{"agent_mode": {"tools": [{"provider_type": "builtin", "provider_id": "time", "tool_name": "time"}]}},
{"agent_mode": {"tools": [{"dataset": None}]}},
],
ids=[
"model-string",
"completion-params-list",
"form-object",
"file-upload-list",
"chat-prompt-text-object",
"completion-prefix-list",
"form-options-object",
"dataset-weight-object",
"agent-tool-parameters-list",
"image-transfer-methods-string",
"feature-enabled-object",
"external-tool-config-list",
"chat-prompt-role-missing",
"chat-prompt-null",
"completion-assistant-prefix-missing",
"text-to-speech-voice-null",
"suggested-model-null",
"suggested-completion-params-null",
"allowed-file-types-null",
"text-input-options-null",
"modern-dataset-enabled-null",
"legacy-image-enabled-null",
"dataset-list-missing",
"retrieval-weights-incomplete",
"metadata-condition-name-missing",
"retrieval-mode-unsupported",
"metadata-comparison-unsupported",
"suggested-model-mode-unsupported",
"empty-agent-tool",
"agent-tool-only-enabled",
"provider-tool-parameters-missing",
"legacy-dataset-null",
],
)
def test_post_rejects_invalid_wire_before_business_validation(
model_config_http: _ModelConfigHttp, invalid_fields: dict[str, object]
) -> None:
response = model_config_http.client.post("/apps/app-1/model-config", json=_model_config_payload(**invalid_fields))
assert response.status_code == 400, response.get_json()
assert response.get_json()["code"] == "invalid_param"
model_config_http.validate_configuration.assert_not_called()
model_config_http.signal.assert_not_called()
assert model_config_http.app_model.app_model_config_id == "config-0"
assert model_config_http.session.scalar(select(func.count()).select_from(AppModelConfig)) == 1
def test_post_keeps_business_validation_as_the_configuration_policy_owner(model_config_http: _ModelConfigHttp) -> None:
model_config_http.validate_configuration.side_effect = ValueError("model.name must be in the specified model list")
response = model_config_http.client.post("/apps/app-1/model-config", json=_model_config_payload())
assert response.status_code == 400, response.get_json()
assert response.get_json()["message"] == "model.name must be in the specified model list"
model_config_http.signal.assert_not_called()
assert model_config_http.app_model.app_model_config_id == "config-0"
assert model_config_http.session.scalar(select(func.count()).select_from(AppModelConfig)) == 1
def _assert_no_implicit_app_config_properties() -> None:
# `App.is_agent` and `App.app_model_config` used to be poisoned here with a
# raising property. Neither exists as an implicit accessor any more, so their
# absence enforces the same thing outright — assert it instead of
# monkeypatching an attribute that is gone.
assert not hasattr(App, "is_agent")
assert not hasattr(App, "app_model_config")
@pytest.mark.parametrize("app_mode", [AppMode.CHAT, AppMode.COMPLETION])
@pytest.mark.parametrize("sqlite_session", [(AppModelConfig,)], indirect=True)
def test_post_updates_non_agent_model_config_without_implicit_properties(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
app_mode: AppMode,
sqlite_session: Session,
) -> None:
"""Flush a non-agent config through the injected session without legacy model properties."""
api = model_config_module.ModelConfigResource()
method = unwrap(api.post)
app_model = App(
id="app-1",
mode=app_mode,
app_model_config_id="config-0",
updated_by=None,
)
original_config = AppModelConfig(app_id="app-1", created_by="u1", updated_by="u1")
original_config.id = "config-0"
original_config.agent_mode = None
sqlite_session.add(original_config)
sqlite_session.commit()
_assert_no_implicit_app_config_properties()
monkeypatch.setattr(
model_config_module.AppModelConfigService,
"validate_configuration",
lambda **_kwargs: {"pre_prompt": "hi"},
)
def _from_model_config_dict(self, model_config):
self.pre_prompt = model_config["pre_prompt"]
self.id = "config-1"
return self
monkeypatch.setattr(AppModelConfig, "from_model_config_dict", _from_model_config_dict)
send_mock = MagicMock()
monkeypatch.setattr(model_config_module.app_model_config_was_updated, "send", send_mock)
with app.test_request_context(
"/console/api/apps/app-1/model-config", method="POST", json=_model_config_payload(pre_prompt="hi")
):
response = method(api, sqlite_session, "t1", "u1", app_model=app_model)
assert send_mock.call_args.kwargs["session"] is sqlite_session
assert app_model.app_model_config_id == "config-1"
assert app_model.mode == app_mode
persisted_config = sqlite_session.get(AppModelConfig, "config-1")
assert persisted_config is not None
assert persisted_config.pre_prompt == "hi"
assert response["result"] == "success"
def test_post_uses_one_session_and_rolls_back_when_signal_fails(
app: Flask,
sqlite_engine: Engine,
monkeypatch: pytest.MonkeyPatch,
) -> None:
make_session = sessionmaker(bind=sqlite_engine, expire_on_commit=False)
app_id = str(uuid4())
tenant_id = str(uuid4())
user_id = str(uuid4())
with make_session.begin() as setup_session:
original_config = AppModelConfig(app_id=app_id, created_by=user_id, updated_by=user_id)
original_config.agent_mode = json.dumps({"tools": []})
setup_session.add(original_config)
setup_session.flush()
original_config_id = original_config.id
setup_session.add(
App(
id=app_id,
tenant_id=tenant_id,
name="Atomic app",
description="",
mode=AppMode.AGENT_CHAT,
icon_type=None,
icon=None,
icon_background=None,
app_model_config_id=original_config_id,
enable_site=True,
enable_api=True,
max_active_requests=None,
created_by=user_id,
)
)
monkeypatch.setattr(controller_session.session_factory, "create_session", make_session)
monkeypatch.setattr(
model_config_module.AppModelConfigService,
"validate_configuration",
lambda **_kwargs: {"agent_mode": {"tools": []}},
)
captured: dict[str, object] = {}
def load_app_model(session, requested_app_id: str):
loaded_app = session.get(App, requested_app_id)
captured["load_session"] = session
return loaded_app
def fail_signal(sender: App, **kwargs: object) -> None:
signal_session = kwargs["session"]
assert object_session(sender) is signal_session
assert signal_session is captured["load_session"]
raise RuntimeError("signal failed")
monkeypatch.setattr(app_wraps_module, "_load_app_model", load_app_model)
monkeypatch.setattr(model_config_module.app_model_config_was_updated, "send", fail_signal)
method = model_config_module.ModelConfigResource.post
while not os.path.normpath(method.__code__.co_filename).endswith(
os.path.join("controllers", "common", "session.py")
):
method = method.__wrapped__
assert os.path.normpath(method.__wrapped__.__code__.co_filename).endswith(
os.path.join("controllers", "console", "app", "wraps.py")
)
api = model_config_module.ModelConfigResource()
with (
app.test_request_context(
f"/console/api/apps/{app_id}/model-config", method="POST", json=_model_config_payload()
),
pytest.raises(RuntimeError, match="signal failed"),
):
method(
api,
current_tenant_id=tenant_id,
current_user_id=user_id,
app_id=app_id,
)
with make_session() as verification_session:
persisted_app = verification_session.get(App, app_id)
assert persisted_app is not None
assert persisted_app.app_model_config_id == original_config_id
config_count = verification_session.scalar(select(func.count()).select_from(AppModelConfig))
assert config_count == 1
@pytest.mark.parametrize("sqlite_session", [(AppModelConfig,)], indirect=True)
def test_post_encrypts_agent_tool_parameters(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
"""Agent parameter encryption reads and writes persisted model configurations."""
api = model_config_module.ModelConfigResource()
method = unwrap(api.post)
app_model = App(
id="app-1",
mode=AppMode.AGENT_CHAT,
app_model_config_id="config-0",
updated_by=None,
)
_assert_no_implicit_app_config_properties()
original_config = AppModelConfig(app_id="app-1", created_by="u1", updated_by="u1")
original_config.id = "config-0"
original_config.agent_mode = json.dumps(
{
"enabled": True,
"strategy": "function-calling",
"tools": [
{
"provider_id": "provider",
"provider_type": "builtin",
"tool_name": "tool",
"tool_parameters": {"secret": "masked"},
}
],
"prompt": None,
}
)
sqlite_session.add(original_config)
sqlite_session.commit()
monkeypatch.setattr(
model_config_module.AppModelConfigService,
"validate_configuration",
lambda **_kwargs: {
"pre_prompt": "hi",
"agent_mode": {
"enabled": True,
"strategy": "function-calling",
"tools": [
{
"provider_id": "provider",
"provider_type": "builtin",
"tool_name": "tool",
"tool_parameters": {"secret": "masked"},
}
],
"prompt": None,
},
},
)
monkeypatch.setattr(model_config_module.ToolManager, "get_agent_tool_runtime", lambda **_kwargs: object())
class _ParamManager:
def __init__(self, **_kwargs):
self.delete_called = False
def decrypt_tool_parameters(self, _value):
return {"secret": "decrypted"}
def mask_tool_parameters(self, _value):
return {"secret": "masked"}
def encrypt_tool_parameters(self, _value):
return {"secret": "encrypted"}
def delete_tool_parameters_cache(self):
self.delete_called = True
monkeypatch.setattr(model_config_module, "ToolParameterConfigurationManager", _ParamManager)
send_mock = MagicMock()
monkeypatch.setattr(model_config_module.app_model_config_was_updated, "send", send_mock)
with app.test_request_context(
"/console/api/apps/app-1/model-config", method="POST", json=_model_config_payload(pre_prompt="hi")
):
response = method(api, sqlite_session, "t1", "u1", app_model=app_model)
stored_config = sqlite_session.get(AppModelConfig, app_model.app_model_config_id)
assert stored_config is not None
stored_agent_mode = json.loads(stored_config.agent_mode)
assert app_model.mode == AppMode.AGENT_CHAT
assert stored_agent_mode["tools"][0]["tool_parameters"]["secret"] == "encrypted"
assert response["result"] == "success"
@@ -0,0 +1,793 @@
from __future__ import annotations
import inspect
import json
from collections.abc import Callable
from dataclasses import dataclass
from datetime import datetime
from types import SimpleNamespace
from unittest.mock import MagicMock
from uuid import UUID
import pytest
from dify_trace_sdk.testing import RecordingEgress
from flask import Flask
from sqlalchemy import func, select
from sqlalchemy.orm import Session, sessionmaker
from werkzeug.exceptions import Forbidden
from controllers.common.rbac import PlainApp
from controllers.console import flask_admission
from controllers.console.app import app as app_module
from controllers.console.app import ops_trace as ops_trace_module
from controllers.console.app.error import (
AppNotFoundError,
InvalidTracingConfigError,
TracingConfigAlreadyExistsError,
TracingConfigConflictError,
TracingConfigNotFoundError,
TracingConfigProcessingError,
TracingConfigVerificationFailedError,
TracingProviderUnavailableError,
UnsupportedTracingProviderError,
)
from libs.exception import BaseHTTPException
from libs.login import AccountWithTenant
from machinery.context import RequestContext
from models.account import Account, AccountStatus, TenantAccountRole
from models.model import TraceAppConfig
from repositories.app.tracing_config_repository import SQLAlchemyAppTracingConfigRepository
from services.app_tracing_config_service import (
AppTracingConfigAlreadyExistsError,
AppTracingConfigAppNotFoundError,
AppTracingConfigConflictError,
AppTracingConfigInvalidConfigurationError,
AppTracingConfigInvalidProviderError,
AppTracingConfigNotFoundError,
AppTracingConfigProcessingError,
AppTracingConfigProviderUnavailableError,
AppTracingConfigRecord,
AppTracingConfigService,
AppTracingConfigVerificationFailedError,
)
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.model_factories import make_app
from tests.helpers.unit.services.tracing_ports import deployment_provider_configs
APP_ID = "11111111-1111-1111-1111-111111111111"
WORKSPACE_ID = "22222222-2222-2222-2222-222222222222"
ACCOUNT_ID = "33333333-3333-3333-3333-333333333333"
PROVIDER = "langfuse"
_MUTATION_METHODS = (
ops_trace_module.TraceAppConfigApi.post,
ops_trace_module.TraceAppConfigApi.patch,
ops_trace_module.TraceAppConfigApi.delete,
)
_CONTROLLER_METHODS: dict[str, Callable[..., object]] = {
"get": ops_trace_module.TraceAppConfigApi.get,
"post": ops_trace_module.TraceAppConfigApi.post,
"patch": ops_trace_module.TraceAppConfigApi.patch,
"delete": ops_trace_module.TraceAppConfigApi.delete,
}
def _service_method(tracing_configs: MagicMock, method_name: str) -> MagicMock:
return {
"get": tracing_configs.get,
"post": tracing_configs.create,
"patch": tracing_configs.update,
"delete": tracing_configs.delete,
}[method_name]
def _account(role: TenantAccountRole) -> Account:
account = Account(
name="Trace User",
email=f"{role.value}@example.com",
status=AccountStatus.ACTIVE,
)
account.id = ACCOUNT_ID
account.role = role
return account
def _request_context() -> RequestContext:
return RequestContext(
request_id="request-1",
trace_id="trace-1",
account_id=ACCOUNT_ID,
active_workspace_id=WORKSPACE_ID,
)
def _original(method: Callable[..., object]) -> Callable[..., object]:
return inspect.unwrap(method)
def _admission_injector(method: Callable[..., object]) -> Callable[..., object]:
return inspect.unwrap(
method,
stop=lambda candidate: "allowed_roles" in inspect.getclosurevars(candidate).nonlocals,
)
@pytest.fixture
def tracing_configs(monkeypatch: pytest.MonkeyPatch) -> MagicMock:
service = MagicMock()
monkeypatch.setattr(
ops_trace_module,
"application_services",
lambda: SimpleNamespace(app_tracing_configs=service),
)
return service
@dataclass(frozen=True)
class _ApplicationServices:
app_tracing_configs: AppTracingConfigService
@dataclass(frozen=True)
class _StoredConfigs:
"""Configurations persisted the way the provider gateway stores them, behind the real service."""
sessions: sessionmaker[Session]
egress: RecordingEgress
def add(self, tracing_provider: str, tracing_config: dict[str, str | None]) -> TraceAppConfig:
with self.sessions.begin() as session:
session.add(TraceAppConfig(app_id=APP_ID, tracing_provider=tracing_provider, tracing_config=tracing_config))
with self.sessions() as session:
return session.scalars(
select(TraceAppConfig).where(
TraceAppConfig.app_id == APP_ID, TraceAppConfig.tracing_provider == tracing_provider
)
).one()
def count(self) -> int:
with self.sessions() as session:
return session.scalar(select(func.count()).select_from(TraceAppConfig)) or 0
@pytest.fixture
def stored_configs(monkeypatch: pytest.MonkeyPatch, sqlite_session_factory: sessionmaker[Session]) -> _StoredConfigs:
with sqlite_session_factory.begin() as session:
session.add(make_app(app_id=APP_ID, tenant_id=WORKSPACE_ID))
egress = RecordingEgress([], grpc_target=None)
service = AppTracingConfigService(
configs=SQLAlchemyAppTracingConfigRepository(session_factory=sqlite_session_factory),
provider=deployment_provider_configs(egress),
)
monkeypatch.setattr(
ops_trace_module, "application_services", lambda: _ApplicationServices(app_tracing_configs=service)
)
return _StoredConfigs(sqlite_session_factory, egress)
@pytest.mark.parametrize("method_name", ["get", "delete"])
def test_trace_config_read_when_absent_or_deleted_never_contacts_the_provider(
app: Flask, stored_configs: _StoredConfigs, method_name: str
) -> None:
if method_name == "delete":
stored_configs.add("weave", {"api_key": "ciphertext-api-key", "entity": "dify", "project": "traces"})
with app.test_request_context("/"):
result = _original(_CONTROLLER_METHODS[method_name])(
ops_trace_module.TraceAppConfigApi(),
ops_trace_module.TraceProviderQuery(tracing_provider="weave"),
_request_context(),
UUID(APP_ID),
)
assert result == ({"has_not_configured": True} if method_name == "get" else ("", 204))
assert stored_configs.count() == 0
assert stored_configs.egress.requests == []
@pytest.mark.parametrize(
("provider", "stored", "presented", "configured_secrets"),
[
pytest.param(
"langfuse",
{
"public_key": "ciphertext-public-key",
"secret_key": "ciphertext-secret-key",
"host": "https://langfuse.example.com",
"project_key": "project-1",
},
{"host": "https://langfuse.example.com", "project_url": "https://langfuse.example.com/project/project-1"},
["public_key", "secret_key"],
id="all-secrets-set",
),
pytest.param(
"databricks",
{
"host": "https://dbc.example.com",
"experiment_id": "7",
"client_id": "client-1",
"client_secret": "",
"personal_access_token": "ciphertext-token",
},
{
"host": "https://dbc.example.com",
"experiment_id": "7",
"client_id": "client-1",
"project_url": "https://dbc.example.com/ml/experiments/7/traces",
},
["personal_access_token"],
id="empty-secret-not-configured",
),
pytest.param(
"mlflow",
{"tracking_uri": "https://mlflow.example.com", "experiment_id": "7", "username": "admin", "password": None},
{
"tracking_uri": "https://mlflow.example.com",
"experiment_id": "7",
"username": "admin",
"project_url": "https://mlflow.example.com/#/experiments/7/traces",
},
[],
id="no-secrets-set",
),
],
)
def test_trace_app_config_get_returns_configured_secrets_and_never_secret_values(
app: Flask,
stored_configs: _StoredConfigs,
provider: str,
stored: dict[str, str | None],
presented: dict[str, str],
configured_secrets: list[str],
) -> None:
record = stored_configs.add(provider, stored)
with app.test_request_context(f"/?tracing_provider={provider}"):
result = _original(ops_trace_module.TraceAppConfigApi.get)(
ops_trace_module.TraceAppConfigApi(),
ops_trace_module.TraceProviderQuery(tracing_provider=provider),
_request_context(),
UUID(APP_ID),
)
assert result == {
"id": record.id,
"app_id": APP_ID,
"tracing_provider": provider,
"tracing_config": presented,
"configured_secrets": configured_secrets,
"is_active": True,
"created_at": str(record.created_at),
"updated_at": str(record.updated_at),
}
assert "ciphertext" not in json.dumps(result)
assert stored_configs.egress.requests == []
@pytest.mark.parametrize(
("failure", "expected"),
[
(AppTracingConfigProviderUnavailableError(), TracingProviderUnavailableError),
(AppTracingConfigNotFoundError(), TracingConfigNotFoundError),
(AppTracingConfigConflictError(), TracingConfigConflictError),
(AppTracingConfigInvalidConfigurationError(), InvalidTracingConfigError),
(AppTracingConfigProcessingError(), TracingConfigProcessingError),
],
)
def test_enable_tracing_maps_configuration_failures(
app: Flask, monkeypatch: pytest.MonkeyPatch, failure: Exception, expected: type[BaseHTTPException]
) -> None:
console_apps = MagicMock()
console_apps.set_trace.side_effect = failure
monkeypatch.setattr(
app_module,
"application_services",
lambda: SimpleNamespace(apps=SimpleNamespace(console=console_apps)),
)
with (
app.test_request_context(
"/",
method="POST",
json={"enabled": True, "tracing_provider": "weave"},
),
pytest.raises(expected) as caught,
):
_original(app_module.AppTraceApi.post)(
app_module.AppTraceApi(),
_request_context(),
UUID(APP_ID),
)
assert caught.value.code == expected.code
assert caught.value.error_code == expected.error_code
assert caught.value.__cause__ is failure
@pytest.mark.parametrize("method", _MUTATION_METHODS)
def test_trace_config_mutations_reject_read_only_member_when_rbac_is_disabled(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
method: Callable[..., object],
) -> None:
account = _account(TenantAccountRole.NORMAL)
apply_config_overrides(monkeypatch, RBAC_ENABLED=False)
monkeypatch.setattr(
flask_admission,
"current_account_with_tenant",
lambda: AccountWithTenant(account=account, tenant_id=WORKSPACE_ID),
)
with app.test_request_context(), pytest.raises(Forbidden):
_admission_injector(method)(None, app_id=UUID(APP_ID))
@pytest.mark.parametrize("method", _MUTATION_METHODS)
def test_trace_config_mutations_require_app_tracing_permission_when_rbac_is_enabled(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
method: Callable[..., object],
) -> None:
account = _account(TenantAccountRole.NORMAL)
apply_config_overrides(monkeypatch, RBAC_ENABLED=True)
monkeypatch.setattr(
flask_admission,
"current_account_with_tenant",
lambda: AccountWithTenant(account=account, tenant_id=WORKSPACE_ID),
)
denied = MagicMock(side_effect=Forbidden())
monkeypatch.setattr(flask_admission, "enforce_rbac_checks", denied)
with app.test_request_context(), pytest.raises(Forbidden):
_admission_injector(method)(None, app_id=UUID(APP_ID))
denied.assert_called_once()
call = denied.call_args.kwargs
assert call["tenant_id"] == WORKSPACE_ID
assert call["account_id"] == ACCOUNT_ID
assert call["path_args"] == {"app_id": UUID(APP_ID)}
(check,) = call["checks"]
assert check.scene == ops_trace_module.RBACPermission.APP_TRACING_CONFIG
assert isinstance(check.locator, PlainApp)
def test_trace_config_get_preserves_read_access_for_normal_member() -> None:
admission = _admission_injector(ops_trace_module.TraceAppConfigApi.get)
assert inspect.getclosurevars(admission).nonlocals["allowed_roles"] is None
@pytest.mark.parametrize("method", _MUTATION_METHODS)
def test_trace_config_mutations_preserve_legacy_edit_roles(method: Callable[..., object]) -> None:
admission = _admission_injector(method)
assert inspect.getclosurevars(admission).nonlocals["allowed_roles"] == frozenset(
{
TenantAccountRole.OWNER,
TenantAccountRole.ADMIN,
TenantAccountRole.EDITOR,
}
)
def test_trace_app_config_get_empty_returns_exact_legacy_body(
app: Flask,
tracing_configs: MagicMock,
) -> None:
tracing_configs.get.return_value = None
with app.test_request_context("/?tracing_provider=langfuse"):
result = _original(ops_trace_module.TraceAppConfigApi.get)(
ops_trace_module.TraceAppConfigApi(),
ops_trace_module.TraceProviderQuery(tracing_provider=PROVIDER),
_request_context(),
UUID(APP_ID),
)
assert result == {"has_not_configured": True}
tracing_configs.get.assert_called_once_with(
context=_request_context(),
app_id=APP_ID,
tracing_provider=PROVIDER,
)
@pytest.mark.parametrize(
("provider", "config", "configured_secrets"),
[
(
"langfuse",
{"host": "https://cloud.langfuse.com", "project_url": "https://cloud.langfuse.com/project/p-1"},
("public_key", "secret_key"),
),
(
"mlflow",
{
"tracking_uri": "http://localhost:5000",
"experiment_id": "0",
"username": None,
"project_url": "http://localhost:5000/#/experiments/0/traces",
},
(),
),
],
)
def test_trace_app_config_get_configured_returns_exact_body(
app: Flask,
tracing_configs: MagicMock,
provider: str,
config: dict[str, str | None],
configured_secrets: tuple[str, ...],
) -> None:
tracing_configs.get.return_value = AppTracingConfigRecord(
id="trace-config-1",
app_id=APP_ID,
tracing_provider=provider,
tracing_config=config,
is_active=True,
created_at=datetime(2026, 1, 2, 3, 4, 5),
updated_at=datetime(2026, 1, 3, 4, 5, 6),
configured_secrets=configured_secrets,
)
with app.test_request_context(f"/?tracing_provider={provider}"):
result = _original(ops_trace_module.TraceAppConfigApi.get)(
ops_trace_module.TraceAppConfigApi(),
ops_trace_module.TraceProviderQuery(tracing_provider=provider),
_request_context(),
UUID(APP_ID),
)
assert result == {
"id": "trace-config-1",
"app_id": APP_ID,
"tracing_provider": provider,
"tracing_config": config,
"configured_secrets": list(configured_secrets),
"is_active": True,
"created_at": "2026-01-02 03:04:05",
"updated_at": "2026-01-03 04:05:06",
}
@pytest.mark.parametrize(
("method_name", "expected_result"),
[
pytest.param("post", ({"result": "success"}, 201), id="create"),
pytest.param("patch", {"result": "success"}, id="update"),
],
)
@pytest.mark.parametrize(
("provider", "config"),
[
("langfuse", {"public_key": "pk", "secret_key": "sk"}),
("mlflow", {"tracking_uri": "", "experiment_id": "0", "username": None, "password": "******"}),
],
)
@pytest.mark.parametrize("activate", [False, True])
def test_trace_app_config_write_returns_expected_response(
app: Flask,
tracing_configs: MagicMock,
method_name: str,
expected_result: object,
activate: bool,
provider: str,
config: dict[str, str | None],
) -> None:
payload = ops_trace_module.TraceConfigPayload(
tracing_provider=provider,
tracing_config=config,
activate=activate,
)
with app.test_request_context("/", method=method_name.upper()):
result = _original(_CONTROLLER_METHODS[method_name])(
ops_trace_module.TraceAppConfigApi(),
payload,
_request_context(),
UUID(APP_ID),
)
assert result == expected_result
_service_method(tracing_configs, method_name).assert_called_once_with(
context=_request_context(),
app_id=APP_ID,
tracing_provider=provider,
tracing_config=config,
activate=activate,
)
def test_trace_app_config_delete_returns_exact_204_response(
app: Flask,
tracing_configs: MagicMock,
) -> None:
with app.test_request_context("/?tracing_provider=langfuse", method="DELETE"):
result = _original(ops_trace_module.TraceAppConfigApi.delete)(
ops_trace_module.TraceAppConfigApi(),
ops_trace_module.TraceProviderQuery(tracing_provider=PROVIDER),
_request_context(),
UUID(APP_ID),
)
assert result == ("", 204)
tracing_configs.delete.assert_called_once_with(
context=_request_context(),
app_id=APP_ID,
tracing_provider=PROVIDER,
)
@pytest.mark.parametrize("method_name", ["get", "post", "patch", "delete"])
def test_trace_app_config_maps_missing_app_to_404(
app: Flask,
tracing_configs: MagicMock,
method_name: str,
) -> None:
service_method = _service_method(tracing_configs, method_name)
service_method.side_effect = AppTracingConfigAppNotFoundError()
query_or_payload = (
ops_trace_module.TraceProviderQuery(tracing_provider=PROVIDER)
if method_name in {"get", "delete"}
else ops_trace_module.TraceConfigPayload(tracing_provider=PROVIDER, tracing_config={})
)
with app.test_request_context("/"):
with pytest.raises(AppNotFoundError) as exc_info:
_original(_CONTROLLER_METHODS[method_name])(
ops_trace_module.TraceAppConfigApi(),
query_or_payload,
_request_context(),
UUID(APP_ID),
)
assert exc_info.value.code == 404
assert exc_info.value.error_code == "app_not_found"
@pytest.mark.parametrize(
("method_name", "service_error", "expected_http_error", "expected_status", "expected_code"),
[
pytest.param(
"patch",
AppTracingConfigConflictError(),
TracingConfigConflictError,
409,
"tracing_config_conflict",
id="patch-concurrent-change",
),
pytest.param(
"get",
AppTracingConfigProviderUnavailableError(),
TracingProviderUnavailableError,
400,
"tracing_provider_unavailable",
id="get-unavailable-provider",
),
pytest.param(
"post",
AppTracingConfigProviderUnavailableError(),
TracingProviderUnavailableError,
400,
"tracing_provider_unavailable",
id="post-unavailable-provider",
),
pytest.param(
"patch",
AppTracingConfigProviderUnavailableError(),
TracingProviderUnavailableError,
400,
"tracing_provider_unavailable",
id="patch-unavailable-provider",
),
pytest.param(
"post",
AppTracingConfigAlreadyExistsError(),
TracingConfigAlreadyExistsError,
409,
"trace_config_already_exists",
id="already-exists",
),
pytest.param(
"patch",
AppTracingConfigNotFoundError(),
TracingConfigNotFoundError,
404,
"trace_config_not_found",
id="patch-not-found",
),
pytest.param(
"delete",
AppTracingConfigNotFoundError(),
TracingConfigNotFoundError,
404,
"trace_config_not_found",
id="delete-not-found",
),
pytest.param(
"get",
AppTracingConfigInvalidProviderError("unknown"),
UnsupportedTracingProviderError,
400,
"unsupported_tracing_provider",
id="get-unsupported-provider",
),
pytest.param(
"post",
AppTracingConfigInvalidProviderError("unknown"),
UnsupportedTracingProviderError,
400,
"unsupported_tracing_provider",
id="post-unsupported-provider",
),
pytest.param(
"patch",
AppTracingConfigInvalidProviderError("unknown"),
UnsupportedTracingProviderError,
400,
"unsupported_tracing_provider",
id="patch-unsupported-provider",
),
pytest.param(
"delete",
AppTracingConfigInvalidProviderError("unknown"),
UnsupportedTracingProviderError,
400,
"unsupported_tracing_provider",
id="delete-unsupported-provider",
),
pytest.param(
"post",
AppTracingConfigInvalidConfigurationError(),
InvalidTracingConfigError,
400,
"invalid_tracing_config",
id="post-invalid-config",
),
pytest.param(
"patch",
AppTracingConfigInvalidConfigurationError(),
InvalidTracingConfigError,
400,
"invalid_tracing_config",
id="patch-invalid-config",
),
pytest.param(
"post",
AppTracingConfigVerificationFailedError(),
TracingConfigVerificationFailedError,
400,
"tracing_config_verification_failed",
id="post-verification-failed",
),
pytest.param(
"patch",
AppTracingConfigVerificationFailedError(),
TracingConfigVerificationFailedError,
400,
"tracing_config_verification_failed",
id="patch-verification-failed",
),
pytest.param(
"get",
AppTracingConfigProcessingError(),
TracingConfigProcessingError,
500,
"tracing_config_processing_failed",
id="get-processing-failed",
),
pytest.param(
"post",
AppTracingConfigProcessingError(),
TracingConfigProcessingError,
500,
"tracing_config_processing_failed",
id="post-processing-failed",
),
pytest.param(
"patch",
AppTracingConfigProcessingError(),
TracingConfigProcessingError,
500,
"tracing_config_processing_failed",
id="patch-processing-failed",
),
pytest.param(
"delete",
AppTracingConfigProcessingError(),
TracingConfigProcessingError,
500,
"tracing_config_processing_failed",
id="delete-processing-failed",
),
],
)
def test_trace_app_config_maps_application_errors_at_the_controller_boundary(
app: Flask,
tracing_configs: MagicMock,
method_name: str,
service_error: Exception,
expected_http_error: type[BaseHTTPException],
expected_status: int,
expected_code: str,
) -> None:
service_method = _service_method(tracing_configs, method_name)
service_method.side_effect = service_error
query_or_payload = (
ops_trace_module.TraceProviderQuery(tracing_provider=PROVIDER)
if method_name in {"get", "delete"}
else ops_trace_module.TraceConfigPayload(tracing_provider=PROVIDER, tracing_config={})
)
with app.test_request_context("/"):
with pytest.raises(expected_http_error) as exc_info:
_original(_CONTROLLER_METHODS[method_name])(
ops_trace_module.TraceAppConfigApi(),
query_or_payload,
_request_context(),
UUID(APP_ID),
)
assert exc_info.value.code == expected_status
assert exc_info.value.error_code == expected_code
assert exc_info.value.data == {
"code": expected_code,
"message": exc_info.value.description,
"status": expected_status,
}
@pytest.mark.parametrize("method_name", ["get", "post", "patch", "delete"])
def test_trace_app_config_maps_untyped_value_errors_to_internal_error(
app: Flask,
tracing_configs: MagicMock,
method_name: str,
) -> None:
service_method = _service_method(tracing_configs, method_name)
service_method.side_effect = ValueError("internal detail")
query_or_payload = (
ops_trace_module.TraceProviderQuery(tracing_provider=PROVIDER)
if method_name in {"get", "delete"}
else ops_trace_module.TraceConfigPayload(tracing_provider=PROVIDER, tracing_config={})
)
with app.test_request_context("/"), pytest.raises(TracingConfigProcessingError) as exc_info:
_original(_CONTROLLER_METHODS[method_name])(
ops_trace_module.TraceAppConfigApi(),
query_or_payload,
_request_context(),
UUID(APP_ID),
)
assert exc_info.value.code == 500
assert exc_info.value.error_code == "tracing_config_processing_failed"
assert exc_info.value.description == "The tracing configuration could not be processed."
assert exc_info.value.data == {
"code": "tracing_config_processing_failed",
"message": "The tracing configuration could not be processed.",
"status": 500,
}
@pytest.mark.parametrize("method_name", ["get", "post", "patch", "delete"])
def test_trace_app_config_does_not_mask_unexpected_errors(
app: Flask,
tracing_configs: MagicMock,
method_name: str,
) -> None:
service_method = _service_method(tracing_configs, method_name)
unexpected_error = RuntimeError("unexpected")
service_method.side_effect = unexpected_error
query_or_payload = (
ops_trace_module.TraceProviderQuery(tracing_provider=PROVIDER)
if method_name in {"get", "delete"}
else ops_trace_module.TraceConfigPayload(tracing_provider=PROVIDER, tracing_config={})
)
with app.test_request_context("/"), pytest.raises(RuntimeError) as exc_info:
_original(_CONTROLLER_METHODS[method_name])(
ops_trace_module.TraceAppConfigApi(),
query_or_payload,
_request_context(),
UUID(APP_ID),
)
assert exc_info.value is unexpected_error
@@ -0,0 +1,319 @@
"""Real HTTP and SQLite coverage for Console statistics admission.
Metric aggregation uses PostgreSQL/MySQL functions, so successful query results
are exercised by the controller integration tests against PostgreSQL. These tests
exercise the real identity and app queries without substituting query services.
"""
from collections.abc import Iterator
from dataclasses import dataclass
from http import HTTPStatus
from uuid import uuid4
import pytest
from flask import Blueprint, Flask, Response
from flask.testing import FlaskClient
from flask_restx import Resource
from redis import Redis
from sqlalchemy import Connection, Engine, event, text
from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
from werkzeug.test import TestResponse
from constants import HEADER_NAME_CSRF_TOKEN
from controllers.console.app import statistic, workflow_statistic
from controllers.console.wraps import _is_setup_completed
from enums import DeploymentEdition
from extensions.ext_application_services import build_application_services
from extensions.ext_login import DifyLoginManager, bind_account_loader, load_user_from_request, unauthorized_handler
from extensions.ext_redis import RedisClientWrapper
from libs.datetime_utils import naive_utc_now
from libs.external_api import ExternalApi
from libs.passport import PassportService
from libs.token import _real_cookie_name, generate_csrf_token
from models import Account, DifySetup, Tenant, TenantAccountJoin
from models.account import AccountStatus, TenantAccountRole
from models.agent import Agent, AgentScope, AgentSource
from models.engine import db
from models.model import App, AppMode
from tests.helpers.unit.config_override import config_overrides_context
@dataclass(frozen=True)
class _Endpoint:
path: str
resource: type[Resource]
mode: AppMode
_ENDPOINTS = (
_Endpoint("statistics/daily-messages", statistic.DailyMessageStatistic, AppMode.CHAT),
_Endpoint("statistics/daily-conversations", statistic.DailyConversationStatistic, AppMode.CHAT),
_Endpoint("statistics/daily-end-users", statistic.DailyTerminalsStatistic, AppMode.CHAT),
_Endpoint("statistics/token-costs", statistic.DailyTokenCostStatistic, AppMode.CHAT),
_Endpoint("statistics/average-session-interactions", statistic.AverageSessionInteractionStatistic, AppMode.CHAT),
_Endpoint("statistics/user-satisfaction-rate", statistic.UserSatisfactionRateStatistic, AppMode.CHAT),
_Endpoint("statistics/average-response-time", statistic.AverageResponseTimeStatistic, AppMode.COMPLETION),
_Endpoint("statistics/tokens-per-second", statistic.TokensPerSecondStatistic, AppMode.CHAT),
_Endpoint(
"workflow/statistics/daily-conversations", workflow_statistic.WorkflowDailyRunsStatistic, AppMode.WORKFLOW
),
_Endpoint(
"workflow/statistics/daily-terminals", workflow_statistic.WorkflowDailyTerminalsStatistic, AppMode.WORKFLOW
),
_Endpoint("workflow/statistics/token-costs", workflow_statistic.WorkflowDailyTokenCostStatistic, AppMode.WORKFLOW),
_Endpoint(
"workflow/statistics/average-app-interactions",
workflow_statistic.WorkflowAverageAppInteractionStatistic,
AppMode.WORKFLOW,
),
)
@dataclass(frozen=True)
class _Harness:
client: FlaskClient
session_factory: sessionmaker[Session]
account_id: str
tenant_id: str
headers: dict[str, str]
sessions: list[Session]
def create_app(self, mode: AppMode, *, tenant_id: str | None = None) -> str:
with self.session_factory.begin() as session:
app = App(
tenant_id=tenant_id or self.tenant_id,
name="Statistics app",
mode=mode,
created_by=self.account_id,
enable_api=True,
enable_site=True,
)
session.add(app)
session.flush()
return app.id
def get(self, endpoint: _Endpoint, app_id: str, *, query: dict[str, str] | None = None) -> TestResponse:
self.sessions.clear()
return self.client.get(f"/console/api/apps/{app_id}/{endpoint.path}", headers=self.headers, query_string=query)
@pytest.fixture
def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]) -> Iterator[_Harness]:
with (
Redis() as redis_client,
config_overrides_context(
DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY,
RBAC_ENABLED=False,
LOGIN_DISABLED=False,
INIT_PASSWORD="",
SECRET_KEY="statistics-http-test-secret-at-least-32-bytes",
),
):
app = Flask(__name__)
app.config.update(TESTING=True, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))
db.init_app(app)
redis = RedisClientWrapper()
redis.initialize(redis_client)
services = build_application_services(
database_client=sqlite_session_factory,
deployment_edition=DeploymentEdition.COMMUNITY,
initialization_password="",
redis=redis,
)
app.extensions["application_services"] = services
bind_account_loader(app, services.accounts.identity.load_user)
login_manager = DifyLoginManager()
login_manager.request_loader(load_user_from_request)
login_manager.unauthorized_handler(unauthorized_handler)
login_manager.init_app(app)
blueprint = Blueprint("console", __name__, url_prefix="/console/api")
api = ExternalApi(blueprint)
for endpoint in _ENDPOINTS:
api.add_resource(endpoint.resource, f"/apps/<uuid:app_id>/{endpoint.path}")
app.register_blueprint(blueprint)
now = naive_utc_now()
with sqlite_session_factory.begin() as session:
account = Account(
email="statistics@example.com",
name="Statistics viewer",
status=AccountStatus.ACTIVE,
initialized_at=now,
timezone="America/New_York",
)
account.last_active_at = now
tenant = Tenant(name="Statistics workspace")
session.add_all([account, tenant, DifySetup(version="test")])
session.flush()
session.add(
TenantAccountJoin(
tenant_id=tenant.id,
account_id=account.id,
role=TenantAccountRole.OWNER,
current=True,
)
)
account_id, tenant_id = account.id, tenant.id
# Complete the one-time setup check before observing request transactions.
# The legacy setup cache still owns a Flask-scoped Session independently.
with app.app_context():
_is_setup_completed.reset_success()
assert _is_setup_completed()
db.session.remove()
client = app.test_client()
csrf_token = generate_csrf_token(account_id)
client.set_cookie(_real_cookie_name("csrf_token"), csrf_token)
headers = {
"Authorization": f"Bearer {PassportService().issue({'user_id': account_id})}",
HEADER_NAME_CSRF_TOKEN: csrf_token,
}
sessions: list[Session] = []
def observe_session(session: Session, transaction: SessionTransaction, connection: Connection) -> None:
sessions.append(session)
@app.after_request
def assert_request_sessions_closed(response: Response) -> Response:
assert all(not session.in_transaction() and not session.identity_map for session in sessions)
return response
event.listen(Session, "after_begin", observe_session)
try:
yield _Harness(client, sqlite_session_factory, account_id, tenant_id, headers, sessions)
finally:
event.remove(Session, "after_begin", observe_session)
_is_setup_completed.reset_success()
with app.app_context():
db.session.remove()
db.engine.dispose()
@pytest.mark.parametrize("endpoint", _ENDPOINTS, ids=lambda endpoint: endpoint.path)
@pytest.mark.parametrize("visibility", ["missing", "different-workspace", "non-normal", "workflow-only"])
def test_statistics_reject_inaccessible_apps(harness: _Harness, endpoint: _Endpoint, visibility: str) -> None:
app_id = str(uuid4())
if visibility != "missing":
app_id = harness.create_app(
endpoint.mode, tenant_id=str(uuid4()) if visibility == "different-workspace" else None
)
with harness.session_factory.begin() as session:
app = session.get(App, app_id)
assert app is not None
if visibility == "non-normal":
# Persist a historical status not accepted by the current enum.
session.execute(
text("UPDATE apps SET status = :status WHERE id = :app_id"),
{"status": "archived", "app_id": app_id},
)
elif visibility == "workflow-only":
app.mode = AppMode.AGENT
session.add(
Agent(
tenant_id=harness.tenant_id,
name="Hidden workflow agent",
scope=AgentScope.WORKFLOW_ONLY,
source=AgentSource.WORKFLOW,
app_id=str(uuid4()),
backing_app_id=app_id,
)
)
response = harness.get(endpoint, app_id)
assert response.status_code == HTTPStatus.NOT_FOUND
body = response.get_json()
assert isinstance(body, dict)
assert body["code"] == "app_not_found"
assert response.content_type == "application/json"
assert harness.sessions
@pytest.mark.parametrize("endpoint", _ENDPOINTS, ids=lambda endpoint: endpoint.path)
@pytest.mark.parametrize("field", ["start", "end"])
def test_statistics_reject_invalid_dates_after_app_admission(
harness: _Harness, endpoint: _Endpoint, field: str
) -> None:
app_id = harness.create_app(endpoint.mode)
response = harness.get(endpoint, app_id, query={field: "not-a-date"})
assert response.status_code == HTTPStatus.BAD_REQUEST
body = response.get_json()
assert isinstance(body, dict)
assert body["code"] == "invalid_param"
assert "not-a-date" in body["message"]
assert harness.sessions
@pytest.mark.parametrize(
("endpoint", "unsupported_mode"),
[
(_ENDPOINTS[4], AppMode.COMPLETION),
(_ENDPOINTS[6], AppMode.CHAT),
(_ENDPOINTS[11], AppMode.ADVANCED_CHAT),
],
ids=["session-interactions", "response-time", "workflow-interactions"],
)
def test_statistics_preserve_app_mode_restrictions(
harness: _Harness, endpoint: _Endpoint, unsupported_mode: AppMode
) -> None:
app_id = harness.create_app(unsupported_mode)
response = harness.get(endpoint, app_id)
assert response.status_code == HTTPStatus.NOT_FOUND
body = response.get_json()
assert isinstance(body, dict)
assert body["code"] == "app_not_found"
assert "App mode is not in the supported list" in body["message"]
@pytest.mark.parametrize("mode", [AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT, AppMode.AGENT])
def test_session_interactions_admits_supported_chat_modes_before_date_validation(
harness: _Harness, mode: AppMode
) -> None:
app_id = harness.create_app(mode)
response = harness.get(_ENDPOINTS[4], app_id, query={"start": "invalid-date"})
assert response.status_code == HTTPStatus.BAD_REQUEST
body = response.get_json()
assert isinstance(body, dict)
assert body["code"] == "invalid_param"
def test_statistics_require_console_authentication(harness: _Harness) -> None:
app_id = harness.create_app(AppMode.CHAT)
response = harness.client.get(f"/console/api/apps/{app_id}/statistics/daily-messages")
assert response.status_code == HTTPStatus.UNAUTHORIZED
body = response.get_json()
assert isinstance(body, dict)
assert body["code"] == "unauthorized"
def test_statistics_require_valid_csrf_token(harness: _Harness) -> None:
app_id = harness.create_app(AppMode.CHAT)
response = harness.client.get(
f"/console/api/apps/{app_id}/statistics/daily-messages",
headers={"Authorization": harness.headers["Authorization"]},
)
assert response.status_code == HTTPStatus.UNAUTHORIZED
body = response.get_json()
assert isinstance(body, dict)
assert body["code"] == "unauthorized"
assert body["message"] == "CSRF token is missing or invalid."
@pytest.mark.parametrize("query_type", [statistic.StatisticTimeRangeQuery, workflow_statistic.WorkflowStatisticQuery])
def test_statistics_treat_blank_date_bounds_as_absent(
query_type: type[statistic.StatisticTimeRangeQuery] | type[workflow_statistic.WorkflowStatisticQuery],
) -> None:
query = query_type(start="", end="")
assert query.start is None
assert query.end is None
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,52 @@
from __future__ import annotations
from datetime import UTC, datetime
from controllers.console.app import workflow_app_log as workflow_app_log_module
from graphon.enums import WorkflowExecutionStatus
def test_workflow_app_log_query_parses_bool_and_datetime() -> None:
query = workflow_app_log_module.WorkflowAppLogQuery.model_validate(
{
"detail": "true",
"created_at__before": "2026-01-02T03:04:05Z",
"page": "2",
"limit": "10",
}
)
assert query.detail is True
assert query.created_at__before == datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
assert query.page == 2
assert query.limit == 10
def test_workflow_app_log_pagination_response_normalizes_nested_fields() -> None:
created_at = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
response = workflow_app_log_module.WorkflowAppLogPaginationResponse.model_validate(
{
"page": 1,
"limit": 20,
"total": 1,
"has_more": False,
"data": [
{
"id": "log-1",
"workflow_run": {
"id": "run-1",
"status": WorkflowExecutionStatus.SUCCEEDED,
"created_at": created_at,
"finished_at": created_at,
},
"details": {"trigger_metadata": {}},
"created_by_account": {"id": "acc-1", "name": "acc", "email": "acc@example.com"},
"created_at": created_at,
}
],
}
).model_dump(mode="json")
assert response["data"][0]["workflow_run"]["status"] == "succeeded"
assert response["data"][0]["workflow_run"]["created_at"] == int(created_at.timestamp())
assert response["data"][0]["created_at"] == int(created_at.timestamp())
@@ -0,0 +1,510 @@
"""Console workflow comment routes keep their admission policy and wire contracts on the application service."""
from __future__ import annotations
from collections.abc import Callable
from contextlib import AbstractContextManager, nullcontext
from dataclasses import dataclass
from datetime import datetime
from inspect import unwrap
from types import SimpleNamespace
from unittest.mock import MagicMock, PropertyMock, patch
from uuid import UUID
import pytest
from flask import Flask
from werkzeug.exceptions import Forbidden, HTTPException
from controllers.common.errors import ForbiddenError, InvalidArgumentError, NotFoundError
from controllers.console import console_ns, flask_admission
from controllers.console.app import workflow_comment as workflow_comment_module
from controllers.console.app.error import AppNotFoundError
from controllers.console.app.workflow_comment import (
WorkflowCommentDetailApi,
WorkflowCommentListApi,
WorkflowCommentMentionUsersApi,
WorkflowCommentReplyApi,
WorkflowCommentReplyDetailApi,
WorkflowCommentResolveApi,
)
from libs.login import AccountWithTenant
from machinery.context import RequestContext
from models.account import TenantAccountRole
from services.app.workflow_comment_service import (
InvalidMentionedUserIdError,
InvalidWorkflowCommentContentError,
WorkflowCommentAccount,
WorkflowCommentAppNotFoundError,
WorkflowCommentCreated,
WorkflowCommentDetail,
WorkflowCommentDraft,
WorkflowCommentEdit,
WorkflowCommentMentionRecord,
WorkflowCommentNotFoundError,
WorkflowCommentPermissionError,
WorkflowCommentReplyDraft,
WorkflowCommentReplyNotFoundError,
WorkflowCommentReplyRecord,
WorkflowCommentResolved,
WorkflowCommentSummary,
WorkflowCommentUpdated,
)
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.model_factories import make_account
WORKSPACE_ID = "tenant-123"
APP_ID = UUID("11111111-1111-1111-1111-111111111111")
JAN_1_2024_NOON = datetime(2024, 1, 1, 12, 0, 0)
JAN_1_2024_NOON_TS = int(JAN_1_2024_NOON.timestamp())
JAN_1_2024_1201 = datetime(2024, 1, 1, 12, 1, 0)
JAN_1_2024_1201_TS = int(JAN_1_2024_1201.timestamp())
JAN_1_2024_1202 = datetime(2024, 1, 1, 12, 2, 0)
JAN_1_2024_1202_TS = int(JAN_1_2024_1202.timestamp())
JAN_1_2024_1203 = datetime(2024, 1, 1, 12, 3, 0)
JAN_1_2024_1203_TS = int(JAN_1_2024_1203.timestamp())
AUTHOR = WorkflowCommentAccount(
id="account-123", name="tester", email="tester@example.com", avatar="https://example.com/avatar.png"
)
AUTHOR_JSON = {
"id": "account-123",
"name": "tester",
"email": "tester@example.com",
"avatar_url": "https://example.com/avatar.png",
}
MENTIONED = WorkflowCommentAccount(id="account-456", name="mentioned", email="mentioned@example.com", avatar=None)
MENTIONED_JSON = {"id": "account-456", "name": "mentioned", "email": "mentioned@example.com", "avatar_url": None}
def admission(method: Callable[..., object]) -> Callable[..., object]:
"""Skip setup/login wrappers and enter at the admission adapter that builds the RequestContext."""
return unwrap(method, stop=lambda view: "inject_request_context" in view.__code__.co_qualname)
@pytest.fixture
def comments(monkeypatch: pytest.MonkeyPatch) -> MagicMock:
service = MagicMock()
members = MagicMock()
monkeypatch.setattr(
workflow_comment_module,
"application_services",
lambda: SimpleNamespace(workflow_comments=service, workspaces=SimpleNamespace(member_queries=members)),
)
service.members = members
return service
def _admit(monkeypatch: pytest.MonkeyPatch, role: TenantAccountRole, *, rbac_enabled: bool = False) -> str:
account = make_account(account_id="account-123", role=role)
apply_config_overrides(monkeypatch, RBAC_ENABLED=rbac_enabled)
monkeypatch.setattr(
flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, WORKSPACE_ID)
)
monkeypatch.setattr(flask_admission, "get_trace_id", lambda: None)
return account.id
def _payload(payload: dict[str, object] | None) -> AbstractContextManager[object]:
if payload is None:
return nullcontext()
return patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value=payload)
@dataclass(frozen=True)
class WriteCase:
method: Callable[..., object]
http_method: str
kwargs: dict[str, object]
service: Callable[[MagicMock], MagicMock]
service_return: object = None
payload: dict[str, object] | None = None
CREATE_COMMENT = WriteCase(
WorkflowCommentListApi.post,
"POST",
{"app_id": APP_ID},
lambda comments: comments.create_comment,
WorkflowCommentCreated(id="comment-1", created_at=JAN_1_2024_NOON),
{"content": "hello", "position_x": 1.0, "position_y": 2.0, "mentioned_user_ids": []},
)
UPDATE_COMMENT = WriteCase(
WorkflowCommentDetailApi.put,
"PUT",
{"app_id": APP_ID, "comment_id": "comment-1"},
lambda comments: comments.update_comment,
WorkflowCommentUpdated(id="comment-1", updated_at=JAN_1_2024_NOON),
{"content": "hello"},
)
DELETE_COMMENT = WriteCase(
WorkflowCommentDetailApi.delete,
"DELETE",
{"app_id": APP_ID, "comment_id": "comment-1"},
lambda comments: comments.delete_comment,
)
RESOLVE_COMMENT = WriteCase(
WorkflowCommentResolveApi.post,
"POST",
{"app_id": APP_ID, "comment_id": "comment-1"},
lambda comments: comments.resolve_comment,
WorkflowCommentResolved(id="comment-1", resolved=True, resolved_at=JAN_1_2024_NOON, resolved_by="account-123"),
)
CREATE_REPLY = WriteCase(
WorkflowCommentReplyApi.post,
"POST",
{"app_id": APP_ID, "comment_id": "comment-1"},
lambda comments: comments.create_reply,
WorkflowCommentCreated(id="reply-1", created_at=JAN_1_2024_NOON),
{"content": "reply", "mentioned_user_ids": []},
)
UPDATE_REPLY = WriteCase(
WorkflowCommentReplyDetailApi.put,
"PUT",
{"app_id": APP_ID, "comment_id": "comment-1", "reply_id": "reply-1"},
lambda comments: comments.update_reply,
WorkflowCommentUpdated(id="reply-1", updated_at=JAN_1_2024_NOON),
{"content": "reply", "mentioned_user_ids": []},
)
DELETE_REPLY = WriteCase(
WorkflowCommentReplyDetailApi.delete,
"DELETE",
{"app_id": APP_ID, "comment_id": "comment-1", "reply_id": "reply-1"},
lambda comments: comments.delete_reply,
)
WRITE_CASES = [
pytest.param(CREATE_COMMENT, id="create-comment"),
pytest.param(UPDATE_COMMENT, id="update-comment"),
pytest.param(DELETE_COMMENT, id="delete-comment"),
pytest.param(RESOLVE_COMMENT, id="resolve-comment"),
pytest.param(CREATE_REPLY, id="create-reply"),
pytest.param(UPDATE_REPLY, id="update-reply"),
pytest.param(DELETE_REPLY, id="delete-reply"),
]
def _call(app: Flask, case: WriteCase) -> object:
with app.test_request_context(method=case.http_method, json=case.payload), _payload(case.payload):
return admission(case.method)(None, **case.kwargs)
@pytest.mark.parametrize("case", WRITE_CASES)
@pytest.mark.parametrize("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])
def test_write_endpoints_reject_read_only_roles(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock, case: WriteCase, role: TenantAccountRole
) -> None:
_admit(monkeypatch, role)
with pytest.raises(Forbidden):
_call(app, case)
case.service(comments).assert_not_called()
@pytest.mark.parametrize("case", WRITE_CASES)
@pytest.mark.parametrize("role", [TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR])
def test_write_endpoints_admit_edit_roles(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock, case: WriteCase, role: TenantAccountRole
) -> None:
_admit(monkeypatch, role)
case.service(comments).return_value = case.service_return
_call(app, case)
case.service(comments).assert_called_once()
@pytest.mark.parametrize("case", WRITE_CASES)
def test_rbac_replaces_the_legacy_role_gate(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock, case: WriteCase
) -> None:
# Like `edit_permission_required`, the role gate is skipped under RBAC; these routes declare no RBAC checks.
_admit(monkeypatch, TenantAccountRole.NORMAL, rbac_enabled=True)
case.service(comments).return_value = case.service_return
_call(app, case)
case.service(comments).assert_called_once()
def test_create_comment_passes_request_context_and_typed_draft(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock
) -> None:
account_id = _admit(monkeypatch, TenantAccountRole.EDITOR)
comments.create_comment.return_value = CREATE_COMMENT.service_return
payload: dict[str, object] = {
"content": "hello",
"position_x": 1.0,
"position_y": 2.0,
"mentioned_user_ids": ["user-1"],
}
with app.test_request_context(method="POST", json=payload), _payload(payload):
result = admission(WorkflowCommentListApi.post)(None, app_id=APP_ID)
assert result == ({"id": "comment-1", "created_at": JAN_1_2024_NOON_TS}, 201)
context, app_id, draft = comments.create_comment.call_args.args
assert isinstance(context, RequestContext)
assert (context.account_id, context.active_workspace_id) == (account_id, WORKSPACE_ID)
assert app_id == str(APP_ID)
assert draft == WorkflowCommentDraft(
content="hello", position_x=1.0, position_y=2.0, mentioned_user_ids=("user-1",)
)
def test_update_comment_keeps_omitted_mentions_omitted(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock
) -> None:
_admit(monkeypatch, TenantAccountRole.EDITOR)
comments.update_comment.return_value = UPDATE_COMMENT.service_return
payload: dict[str, object] = {"content": "hello", "position_x": 10.0, "position_y": 20.0}
with app.test_request_context(method="PUT", json=payload), _payload(payload):
result = admission(WorkflowCommentDetailApi.put)(None, app_id=APP_ID, comment_id="comment-1")
assert result == {"id": "comment-1", "updated_at": JAN_1_2024_NOON_TS}
_, _, comment_id, edit = comments.update_comment.call_args.args
assert comment_id == "comment-1"
assert edit == WorkflowCommentEdit(content="hello", position_x=10.0, position_y=20.0, mentioned_user_ids=None)
def test_reply_update_passes_typed_draft(app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock) -> None:
_admit(monkeypatch, TenantAccountRole.EDITOR)
comments.update_reply.return_value = UPDATE_REPLY.service_return
payload: dict[str, object] = {"content": "reply", "mentioned_user_ids": ["user-1"]}
with app.test_request_context(method="PUT", json=payload), _payload(payload):
result = admission(WorkflowCommentReplyDetailApi.put)(
None, app_id=APP_ID, comment_id="comment-1", reply_id="reply-1"
)
assert result == {"id": "reply-1", "updated_at": JAN_1_2024_NOON_TS}
_, _, comment_id, reply_id, draft = comments.update_reply.call_args.args
assert (comment_id, reply_id) == ("comment-1", "reply-1")
assert draft == WorkflowCommentReplyDraft(content="reply", mentioned_user_ids=("user-1",))
@pytest.mark.parametrize(
("case", "expected"),
[
pytest.param(
RESOLVE_COMMENT,
{"id": "comment-1", "resolved": True, "resolved_at": JAN_1_2024_NOON_TS, "resolved_by": "account-123"},
id="resolve",
),
pytest.param(CREATE_REPLY, ({"id": "reply-1", "created_at": JAN_1_2024_NOON_TS}, 201), id="create-reply"),
pytest.param(DELETE_COMMENT, ("", 204), id="delete-comment"),
pytest.param(DELETE_REPLY, ("", 204), id="delete-reply"),
],
)
def test_mutation_endpoints_serialize_responses(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock, case: WriteCase, expected: object
) -> None:
_admit(monkeypatch, TenantAccountRole.EDITOR)
case.service(comments).return_value = case.service_return
assert _call(app, case) == expected
@pytest.mark.parametrize("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])
def test_list_comments_serializes_summaries_for_any_member(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock, role: TenantAccountRole
) -> None:
_admit(monkeypatch, role)
comments.list_comments.return_value = (
WorkflowCommentSummary(
id="comment-1",
position_x=1.5,
position_y=2.5,
content="hello",
created_by="account-123",
created_by_account=AUTHOR,
created_at=datetime.fromtimestamp(1_700_000_000),
updated_at=datetime.fromtimestamp(1_700_000_001),
resolved=False,
resolved_at=None,
resolved_by=None,
resolved_by_account=None,
reply_count=0,
mention_count=0,
participants=(AUTHOR,),
),
)
with app.test_request_context():
response = admission(WorkflowCommentListApi.get)(None, app_id=APP_ID)
assert response == {
"data": [
{
"id": "comment-1",
"position_x": 1.5,
"position_y": 2.5,
"content": "hello",
"created_by": "account-123",
"created_by_account": AUTHOR_JSON,
"created_at": 1_700_000_000,
"updated_at": 1_700_000_001,
"resolved": False,
"resolved_at": None,
"resolved_by": None,
"resolved_by_account": None,
"reply_count": 0,
"mention_count": 0,
"participants": [AUTHOR_JSON],
}
]
}
def test_get_comment_serializes_detail(app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock) -> None:
_admit(monkeypatch, TenantAccountRole.NORMAL)
comments.get_comment.return_value = WorkflowCommentDetail(
id="comment-1",
position_x=1.5,
position_y=2.5,
content="hello",
created_by="account-123",
created_by_account=AUTHOR,
created_at=JAN_1_2024_NOON,
updated_at=JAN_1_2024_1201,
resolved=True,
resolved_at=JAN_1_2024_1202,
resolved_by="account-123",
resolved_by_account=AUTHOR,
replies=(
WorkflowCommentReplyRecord(
id="reply-1",
content="reply",
created_by="account-456",
created_by_account=MENTIONED,
created_at=JAN_1_2024_1203,
),
),
mentions=(
WorkflowCommentMentionRecord(
mentioned_user_id="account-456", mentioned_user_account=MENTIONED, reply_id="reply-1"
),
),
)
with app.test_request_context():
response = admission(WorkflowCommentDetailApi.get)(None, app_id=APP_ID, comment_id="comment-1")
assert response == {
"id": "comment-1",
"position_x": 1.5,
"position_y": 2.5,
"content": "hello",
"created_by": "account-123",
"created_by_account": AUTHOR_JSON,
"created_at": JAN_1_2024_NOON_TS,
"updated_at": JAN_1_2024_1201_TS,
"resolved": True,
"resolved_at": JAN_1_2024_1202_TS,
"resolved_by": "account-123",
"resolved_by_account": AUTHOR_JSON,
"replies": [
{
"id": "reply-1",
"content": "reply",
"created_by": "account-456",
"created_by_account": MENTIONED_JSON,
"created_at": JAN_1_2024_1203_TS,
}
],
"mentions": [
{"mentioned_user_id": "account-456", "mentioned_user_account": MENTIONED_JSON, "reply_id": "reply-1"}
],
}
_, app_id, comment_id = comments.get_comment.call_args.args
assert (app_id, comment_id) == (str(APP_ID), "comment-1")
def test_mention_users_requires_the_app_and_lists_workspace_members(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock
) -> None:
_admit(monkeypatch, TenantAccountRole.NORMAL)
comments.members.list_members.return_value = [
SimpleNamespace(
id="account-456",
name="mentioned",
email="mentioned@example.com",
avatar=None,
last_login_at=None,
last_active_at=None,
created_at=JAN_1_2024_NOON,
role="normal",
status="active",
)
]
with app.test_request_context():
result = admission(WorkflowCommentMentionUsersApi.get)(None, app_id=APP_ID)
assert isinstance(result, tuple)
response, status = result
assert isinstance(response, dict)
assert status == 200
assert [user["id"] for user in response["users"]] == ["account-456"]
comments.ensure_app.assert_called_once()
assert comments.ensure_app.call_args.args[1] == str(APP_ID)
comments.members.list_members.assert_called_once_with(WORKSPACE_ID)
def test_mention_users_rejects_unaddressable_app(
app: Flask, monkeypatch: pytest.MonkeyPatch, comments: MagicMock
) -> None:
_admit(monkeypatch, TenantAccountRole.NORMAL)
comments.ensure_app.side_effect = WorkflowCommentAppNotFoundError
with app.test_request_context(), pytest.raises(AppNotFoundError):
admission(WorkflowCommentMentionUsersApi.get)(None, app_id=APP_ID)
comments.members.list_members.assert_not_called()
@pytest.mark.parametrize(
("error", "expected_type", "expected_message"),
[
pytest.param(WorkflowCommentAppNotFoundError(), AppNotFoundError, "App not found.", id="app"),
pytest.param(WorkflowCommentNotFoundError(), NotFoundError, "Comment not found", id="comment"),
pytest.param(WorkflowCommentReplyNotFoundError(), NotFoundError, "Reply not found", id="reply"),
pytest.param(
WorkflowCommentPermissionError("Only the comment creator can update it"),
ForbiddenError,
"Only the comment creator can update it",
id="permission",
),
pytest.param(
InvalidWorkflowCommentContentError("Comment content cannot be empty"),
InvalidArgumentError,
"Comment content cannot be empty",
id="content",
),
pytest.param(
InvalidMentionedUserIdError("bad"), InvalidArgumentError, "bad is not a valid uuid.", id="mention-id"
),
],
)
def test_domain_errors_map_to_existing_transport_errors(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
comments: MagicMock,
error: Exception,
expected_type: type[Exception],
expected_message: str,
) -> None:
_admit(monkeypatch, TenantAccountRole.EDITOR)
comments.update_comment.side_effect = error
with pytest.raises(expected_type) as raised:
_call(app, UPDATE_COMMENT)
exception = raised.value
message = exception.description if isinstance(exception, HTTPException) else str(exception)
assert message == expected_message
def test_workflow_comment_response_schemas_are_registered() -> None:
assert workflow_comment_module.WorkflowCommentBasicList.__name__ in console_ns.models
assert workflow_comment_module.WorkflowCommentDetail.__name__ in console_ns.models
@@ -0,0 +1,481 @@
"""Unit tests for the Node Output Inspector controller (Stage 4 §8).
The controller has two non-trivial moving parts:
1. :func:`_sse_envelope` — wire-format builder for the SSE ``{event, data, id}``
records (decision D-5).
2. :func:`_stream_inspector_events` — the SSE generator that fans the redis
pub/sub stream out as snapshot / node_changed / workflow_run_completed /
error events.
We exercise both as plain functions with mocked dependencies (service +
``inspector_events.subscribe``) — going through Flask routes would multiply
the test scaffolding without buying additional confidence in the core
behaviour.
The Resource classes themselves are trivial wrappers (``_service().method()``
+ ``_InspectorNotFound`` translation), and are touched here only by import so
codecov sees them as exercised; their detailed behaviour is locked down by
the service-level tests in
``tests/unit_tests/services/workflow/test_node_output_inspector_service.py``.
"""
from __future__ import annotations
import json
from collections.abc import Iterator
from unittest.mock import ANY, MagicMock
from uuid import UUID
import pytest
from controllers.console.app import workflow_node_output_inspector as ctrl
from graphon.enums import WorkflowExecutionStatus
from models import App, AppMode
from models.model import IconType
from services.workflow.inspector_events import InspectorMessage
from services.workflow.node_output_inspector_service import (
NodeOutputInspectorError,
NodeOutputStatus,
NodeOutputsView,
NodeStatus,
WorkflowRunSnapshotView,
)
# ──────────────────────────────────────────────────────────────────────────────
# Fixtures
# ──────────────────────────────────────────────────────────────────────────────
@pytest.fixture
def app_model() -> App:
"""A real transient ``App`` the controller passes through to the service.
The SSE generator never reads its attributes — just forwards it — so a
transient mapped instance is sufficient.
"""
return App(
id="app-1",
tenant_id="tenant-1",
name="Inspector app",
description="",
mode=AppMode.WORKFLOW,
icon_type=IconType.EMOJI,
icon="robot",
icon_background="#FFFFFF",
enable_site=True,
enable_api=True,
max_active_requests=None,
)
@pytest.fixture
def run_id() -> UUID:
return UUID("00000000-0000-0000-0000-0000000000aa")
def _snapshot_view(*, status: str, node_id: str = "agent-1") -> WorkflowRunSnapshotView:
return WorkflowRunSnapshotView(
workflow_run_id="00000000-0000-0000-0000-0000000000aa",
workflow_run_status=WorkflowExecutionStatus(status),
node_outputs=[
NodeOutputsView(
node_id=node_id,
node_kind="agent",
node_display_name="Greeter",
node_status=NodeStatus.RUNNING if status == "running" else NodeStatus.READY,
outputs=[],
)
],
)
def _node_view(*, node_id: str = "agent-1", node_status: NodeStatus = NodeStatus.READY) -> NodeOutputsView:
return NodeOutputsView(
node_id=node_id,
node_kind="agent",
node_display_name="Greeter",
node_status=node_status,
outputs=[],
)
# ──────────────────────────────────────────────────────────────────────────────
# _sse_envelope
# ──────────────────────────────────────────────────────────────────────────────
def test_sse_envelope_serializes_dict_payload():
out = ctrl._sse_envelope("snapshot", {"foo": "bar"}, 7)
lines = out.rstrip("\n").split("\n")
assert lines[0] == "event: snapshot"
assert lines[1] == "id: 7"
assert lines[2] == 'data: {"foo": "bar"}'
assert out.endswith("\n\n") # SSE record separator
def test_sse_envelope_passes_strings_through_unmodified():
"""A raw string payload (e.g. ``:keepalive``) is emitted as-is."""
out = ctrl._sse_envelope("snapshot", ":keepalive", 1)
assert "data: :keepalive\n" in out
def test_sse_envelope_handles_unicode_payload():
out = ctrl._sse_envelope("node_changed", {"name": "你好"}, 3)
assert "你好" in out # ensure_ascii=False
# ──────────────────────────────────────────────────────────────────────────────
# _stream_inspector_events — fast path (already-terminal run)
# ──────────────────────────────────────────────────────────────────────────────
def _drain(stream: Iterator[str]) -> list[str]:
return list(stream)
def _stream(app_model, run_id) -> Iterator[str]:
"""Open the stream the way the handlers do: resolve the run first, then generate."""
return ctrl._stream_inspector_events(app_model, run_id, ctrl._initial_snapshot(app_model, run_id))
def _parse(record: str) -> tuple[str, dict | None]:
"""Pull ``event`` + ``data`` (json-decoded) out of one SSE record."""
event = None
data: dict | None = None
for line in record.rstrip("\n").split("\n"):
if line.startswith("event: "):
event = line[len("event: ") :]
elif line.startswith("data: "):
try:
data = json.loads(line[len("data: ") :])
except json.JSONDecodeError:
data = None
assert event is not None
return event, data
@pytest.fixture
def patch_service(monkeypatch: pytest.MonkeyPatch):
"""Replace ``_service()`` with a MagicMock per-test."""
fake = MagicMock()
monkeypatch.setattr(ctrl, "_service", lambda: fake)
return fake
@pytest.fixture
def patch_subscribe(monkeypatch: pytest.MonkeyPatch):
"""Patch the pub/sub subscribe iterator."""
def _make(messages: list[InspectorMessage | None]):
def _subscribe(workflow_run_id: str, *, timeout_seconds: float = 1.0):
for m in messages:
if m is None:
# heartbeat sentinel
yield InspectorMessage(
kind="node_changed",
workflow_run_id=workflow_run_id,
node_id=None,
status=None,
)
else:
yield m
monkeypatch.setattr(ctrl.inspector_events, "subscribe", _subscribe)
return _make
def test_stream_fast_path_when_run_already_terminal(patch_service, app_model, run_id):
"""A run that's already ``succeeded`` should produce ``snapshot`` →
``workflow_run_completed`` and close without subscribing to pub/sub."""
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="succeeded")
records = _drain(_stream(app_model, run_id))
assert len(records) == 2
e0, d0 = _parse(records[0])
e1, d1 = _parse(records[1])
assert e0 == "snapshot"
assert d0 is not None
assert d0["workflow_run_status"] == "succeeded"
assert e1 == "workflow_run_completed"
assert d1 is not None
assert d1["workflow_run_status"] == "succeeded"
def test_stream_fast_path_each_terminal_status(patch_service, app_model, run_id):
"""All four terminal statuses take the fast-path. Note the enum value for
partial success is the hyphenated ``partial-succeeded``."""
for terminal in ("succeeded", "failed", "stopped", "partial-succeeded"):
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status=terminal)
records = _drain(_stream(app_model, run_id))
events = [_parse(r)[0] for r in records]
assert events == ["snapshot", "workflow_run_completed"], terminal
def test_initial_snapshot_raises_the_404_before_the_response_exists(patch_service, app_model, run_id):
"""A missing run must be an HTTP 404. The handlers resolve the snapshot before building the
streaming ``Response``; raising inside the generator would arrive after the 200 went out."""
patch_service.snapshot_workflow_run.side_effect = NodeOutputInspectorError(
"workflow_run_not_found", "Workflow run not found."
)
with pytest.raises(ctrl._InspectorNotFound) as exc:
ctrl._initial_snapshot(app_model, run_id)
assert exc.value.error_code == "workflow_run_not_found"
assert not patch_service.node_detail.called
# ──────────────────────────────────────────────────────────────────────────────
# _stream_inspector_events — live path (run is running)
# ──────────────────────────────────────────────────────────────────────────────
def test_stream_live_emits_snapshot_then_node_changed_then_completion(
patch_service, patch_subscribe, app_model, run_id
):
"""Happy path: snapshot → 2× node_changed → workflow_run_completed."""
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
patch_service.node_detail.return_value = _node_view(node_id="agent-1")
msgs = [
InspectorMessage(kind="node_changed", workflow_run_id=str(run_id), node_id="agent-1", status="running"),
InspectorMessage(kind="node_changed", workflow_run_id=str(run_id), node_id="agent-1", status="succeeded"),
InspectorMessage(kind="workflow_completed", workflow_run_id=str(run_id), node_id=None, status="succeeded"),
]
patch_subscribe(msgs)
events = [_parse(r)[0] for r in _drain(_stream(app_model, run_id))]
assert events == ["snapshot", "node_changed", "node_changed", "workflow_run_completed"]
# node_detail should be called once per delta (not once per heartbeat)
assert patch_service.node_detail.call_count == 2
def test_stream_emits_heartbeat_after_n_idle_ticks(
patch_service, patch_subscribe, monkeypatch: pytest.MonkeyPatch, app_model, run_id
):
"""When pub/sub returns the heartbeat sentinel ``_HEARTBEAT_EVERY_TICKS``
times in a row, the generator emits a ``:keepalive`` SSE comment."""
monkeypatch.setattr(ctrl, "_HEARTBEAT_EVERY_TICKS", 2)
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
patch_service.node_detail.return_value = _node_view()
# 2 heartbeats → keepalive, then real message + completion.
patch_subscribe(
[
None,
None,
InspectorMessage(kind="workflow_completed", workflow_run_id=str(run_id), node_id=None, status="failed"),
]
)
records = _drain(_stream(app_model, run_id))
raw = "".join(records)
assert ":keepalive\n\n" in raw
assert "workflow_run_completed" in raw
def test_stream_hard_timeout_force_closes_without_terminal(
patch_service, patch_subscribe, monkeypatch: pytest.MonkeyPatch, app_model, run_id
):
"""If the engine crashes / drops the terminal event, the generator force-
closes after ``_STREAM_HARD_TIMEOUT_TICKS`` ticks rather than hanging."""
monkeypatch.setattr(ctrl, "_STREAM_HARD_TIMEOUT_TICKS", 3)
monkeypatch.setattr(ctrl, "_HEARTBEAT_EVERY_TICKS", 100) # avoid keepalive noise
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
# 5 heartbeats, no terminal → generator should bail after 3 ticks.
patch_subscribe([None] * 10)
records = _drain(_stream(app_model, run_id))
events = [_parse(r)[0] for r in records]
assert events == ["snapshot"] # only snapshot, then forced close
def test_stream_skips_messages_with_missing_node_id(patch_service, patch_subscribe, app_model, run_id):
"""Defensive: malformed node_changed without node_id is silently dropped."""
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
patch_subscribe(
[
InspectorMessage(kind="node_changed", workflow_run_id=str(run_id), node_id="", status="running"),
InspectorMessage(kind="workflow_completed", workflow_run_id=str(run_id), node_id=None, status="succeeded"),
]
)
events = [_parse(r)[0] for r in _drain(_stream(app_model, run_id))]
assert events == ["snapshot", "workflow_run_completed"]
assert patch_service.node_detail.call_count == 0
def test_stream_skips_node_detail_404_without_breaking_stream(patch_service, patch_subscribe, app_model, run_id):
"""When node_detail 404s mid-stream (node still being persisted), the
generator just drops that delta and keeps streaming."""
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
patch_service.node_detail.side_effect = NodeOutputInspectorError("node_not_in_workflow_run", "transient")
patch_subscribe(
[
InspectorMessage(kind="node_changed", workflow_run_id=str(run_id), node_id="agent-1", status="running"),
InspectorMessage(kind="workflow_completed", workflow_run_id=str(run_id), node_id=None, status="succeeded"),
]
)
events = [_parse(r)[0] for r in _drain(_stream(app_model, run_id))]
assert events == ["snapshot", "workflow_run_completed"]
def test_stream_emits_error_event_on_node_detail_unexpected_exception(
patch_service, patch_subscribe, app_model, run_id
):
"""Any non-Inspector exception (DB outage, JSON decode error) becomes a
user-visible ``error`` SSE record; the stream keeps running."""
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
patch_service.node_detail.side_effect = RuntimeError("db gone")
patch_subscribe(
[
InspectorMessage(kind="node_changed", workflow_run_id=str(run_id), node_id="agent-1", status="running"),
InspectorMessage(kind="workflow_completed", workflow_run_id=str(run_id), node_id=None, status="succeeded"),
]
)
records = _drain(_stream(app_model, run_id))
events = [_parse(r) for r in records]
kinds = [e for e, _ in events]
assert kinds == ["snapshot", "error", "workflow_run_completed"]
err_event, err_data = events[1]
assert err_data is not None
assert err_data["node_id"] == "agent-1"
assert "failed" in err_data["message"]
def test_stream_workflow_completed_status_falls_back_to_unknown(patch_service, patch_subscribe, app_model, run_id):
"""If the pub/sub message arrives with status=None (publish race), the SSE
payload still carries ``workflow_run_status`` with the ``unknown``
sentinel so the frontend never sees a missing field."""
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
patch_subscribe(
[InspectorMessage(kind="workflow_completed", workflow_run_id=str(run_id), node_id=None, status=None)]
)
records = _drain(_stream(app_model, run_id))
e, d = _parse(records[-1])
assert e == "workflow_run_completed"
assert d is not None
assert d["workflow_run_status"] == "unknown"
# ──────────────────────────────────────────────────────────────────────────────
# Resource classes — import-level smoke + service-method delegation
# ──────────────────────────────────────────────────────────────────────────────
def test_resource_classes_are_registered():
"""All 8 Inspector Resource classes must be importable from the module so
flask-restx can discover them via the namespace decorators."""
for name in (
"WorkflowDraftRunNodeOutputsApi",
"WorkflowDraftRunNodeOutputDetailApi",
"WorkflowDraftRunNodeOutputPreviewApi",
"WorkflowDraftRunNodeOutputEventsApi",
"WorkflowPublishedRunNodeOutputsApi",
"WorkflowPublishedRunNodeOutputDetailApi",
"WorkflowPublishedRunNodeOutputPreviewApi",
"WorkflowPublishedRunNodeOutputEventsApi",
):
assert hasattr(ctrl, name), name
def test_inspector_not_found_preserves_error_code():
"""Sanity: the controller's bespoke 404 wrapper hangs onto the
Inspector's specific error code rather than collapsing to a generic
``not_found``."""
err = NodeOutputInspectorError("node_not_in_workflow_run", "boom")
wrapped = ctrl._inspector_not_found(err)
assert isinstance(wrapped, ctrl.NodeNotInWorkflowRunError)
assert wrapped.error_code == "node_not_in_workflow_run"
assert wrapped.code == 404
assert wrapped.description == "boom"
def test_inspector_not_found_relays_codes_the_contract_does_not_know():
relayed = ctrl._inspector_not_found(NodeOutputInspectorError("inspector_offline", "later"))
assert relayed.code == 404
assert relayed.data == {"code": "inspector_offline", "message": "later", "status": 404}
# ──────────────────────────────────────────────────────────────────────────────
# _serve_* — shared REST handler bodies (covered by both draft + published)
# ──────────────────────────────────────────────────────────────────────────────
def test_serve_snapshot_happy_path(patch_service, app_model, run_id):
"""Returns the snapshot view as JSON-serialisable dict."""
patch_service.snapshot_workflow_run.return_value = _snapshot_view(status="running")
result = ctrl._serve_snapshot(app_model, run_id)
assert isinstance(result, dict)
assert result["workflow_run_id"] == "00000000-0000-0000-0000-0000000000aa"
patch_service.snapshot_workflow_run.assert_called_once_with(
app_model=app_model, workflow_run_id=str(run_id), session=ANY
)
def test_serve_snapshot_translates_inspector_error_to_404(patch_service, app_model, run_id):
"""``NodeOutputInspectorError`` becomes the controller's 404 wrapper with
the specific ``error_code`` preserved."""
patch_service.snapshot_workflow_run.side_effect = NodeOutputInspectorError("workflow_run_not_found", "no such run")
with pytest.raises(ctrl._InspectorNotFound) as exc:
ctrl._serve_snapshot(app_model, run_id)
assert exc.value.error_code == "workflow_run_not_found"
def test_serve_node_detail_happy_path(patch_service, app_model, run_id):
patch_service.node_detail.return_value = _node_view(node_id="agent-1")
result = ctrl._serve_node_detail(app_model, run_id, "agent-1")
assert result["node_id"] == "agent-1"
patch_service.node_detail.assert_called_once_with(
app_model=app_model, workflow_run_id=str(run_id), node_id="agent-1", session=ANY
)
def test_serve_node_detail_translates_inspector_error(patch_service, app_model, run_id):
patch_service.node_detail.side_effect = NodeOutputInspectorError("node_not_in_workflow_run", "missing")
with pytest.raises(ctrl._InspectorNotFound) as exc:
ctrl._serve_node_detail(app_model, run_id, "ghost")
assert exc.value.error_code == "node_not_in_workflow_run"
def test_serve_output_preview_happy_path(patch_service, app_model, run_id):
from services.workflow.node_output_inspector_service import (
DeclaredOutputType,
OutputPreviewView,
)
patch_service.output_preview.return_value = OutputPreviewView(
node_id="agent-1",
output_name="text",
type=DeclaredOutputType.STRING,
status=NodeOutputStatus.READY,
value="Hello",
)
result = ctrl._serve_output_preview(app_model, run_id, "agent-1", "text")
assert result["value"] == "Hello"
assert result["status"] == "ready"
patch_service.output_preview.assert_called_once_with(
app_model=app_model,
workflow_run_id=str(run_id),
node_id="agent-1",
output_name="text",
session=ANY,
)
def test_serve_output_preview_translates_inspector_error(patch_service, app_model, run_id):
patch_service.output_preview.side_effect = NodeOutputInspectorError("node_output_not_declared", "no such output")
with pytest.raises(ctrl._InspectorNotFound) as exc:
ctrl._serve_output_preview(app_model, run_id, "agent-1", "phantom")
assert exc.value.error_code == "node_output_not_declared"
# ──────────────────────────────────────────────────────────────────────────────
# Note: the Resource ``.get`` methods themselves (6 REST + 2 SSE) are
# 1-line delegators to the helpers above. They can't be called directly in a
# unit test because their decorator stack (``@setup_required`` /
# ``@login_required`` / ``@account_initialization_required`` /
# ``@get_app_model``) needs a real Flask request context + DB-backed account.
# The integration test in
# ``tests/e2e_tests/middleware/services/test_node_output_inspector_service.py``
# (and the E2E driver in /tmp/e2e_inspector_sse_published.py) exercise them
# through the HTTP stack.
# ──────────────────────────────────────────────────────────────────────────────
@@ -0,0 +1,638 @@
from __future__ import annotations
import json
from collections.abc import Callable
from datetime import UTC, datetime
from inspect import unwrap
from types import SimpleNamespace
from typing import Any, Literal
from unittest.mock import Mock
import pytest
from flask import Flask, request
from flask_restx import marshal
from pytest_mock import MockerFixture
from sqlalchemy.orm import Session, sessionmaker
from werkzeug.exceptions import Forbidden
from controllers.common.errors import NotFoundError
from controllers.common.rbac import locators as rbac_locators
from controllers.console.app import workflow_run as workflow_run_module
from core.rbac import RBACPermission, RBACResourceScope
from extensions.ext_database import db
from fields.workflow_run_fields import node_execution_response_source
from graphon.enums import WorkflowExecutionStatus, WorkflowNodeExecutionStatus
from machinery.context import RequestContext
from models import Account, App, AppMode
from models.enums import CreatorUserRole, WorkflowRunTriggeredFrom
from models.workflow import (
WorkflowNodeExecutionModel,
WorkflowNodeExecutionTriggeredFrom,
WorkflowRun,
WorkflowType,
)
from repositories.sqlalchemy_api_workflow_node_execution_repository import (
DifyAPISQLAlchemyWorkflowNodeExecutionRepository,
)
from repositories.sqlalchemy_api_workflow_run_repository import DifyAPISQLAlchemyWorkflowRunRepository
from services.enterprise.rbac_service import RBACService
from services.workflow_node_execution_trace_service import WorkflowNodeExecutionTrace
from services.workflow_run_service import WorkflowRunPauseDetails, WorkflowRunPausedNode, WorkflowRunService
from tests.helpers.unit.config_override import apply_config_overrides
from tests.helpers.unit.model_factories import make_account, make_app
from tests.helpers.unit.rbac_fakes import RBACDomain
"""Controller tests for Console workflow pause details."""
def _workflow_pause_details_api_request_context(*, workspace_id: str = "tenant-1") -> RequestContext:
return RequestContext(
request_id="request-1",
trace_id="trace-1",
account_id="account-1",
active_workspace_id=workspace_id,
)
def _workflow_pause_details_api_mock_application_services(monkeypatch: pytest.MonkeyPatch, workflow_runs: Mock) -> None:
monkeypatch.setattr(
workflow_run_module,
"application_services",
lambda: SimpleNamespace(workflow_runs=workflow_runs),
)
class TestWorkflowPauseDetailsApiCases:
@staticmethod
@pytest.mark.parametrize("form_version", ["1", "2"])
def test_pause_details_returns_backstage_input_url(
app: Flask, monkeypatch: pytest.MonkeyPatch, form_version: Literal["1", "2"]
) -> None:
apply_config_overrides(monkeypatch, APP_WEB_URL="https://web.example.com/")
workflow_runs = Mock()
workflow_runs.get_pause_details.return_value = WorkflowRunPauseDetails(
paused_at=datetime(2024, 1, 1, 12, 0, 0),
paused_nodes=(
WorkflowRunPausedNode(
node_id="node-1",
node_title="Ask Name",
form_id="form-1",
form_version=form_version,
form_token="backstage-token",
),
),
)
_workflow_pause_details_api_mock_application_services(monkeypatch, workflow_runs)
request_context = _workflow_pause_details_api_request_context()
api = workflow_run_module.ConsoleWorkflowPauseDetailsApi()
handler = unwrap(api.get)
with app.test_request_context("/console/api/workflow/run-1/pause-details", method="GET"):
response, status = handler(api, request_context, workflow_run_id="run-1")
assert status == 200
assert response == {
"paused_at": "2024-01-01T12:00:00Z",
"paused_nodes": [
{
"node_id": "node-1",
"node_title": "Ask Name",
"pause_type": {
"type": "human_input",
"form_id": "form-1",
"form_version": form_version,
"backstage_input_url": "https://web.example.com/form/backstage-token",
},
}
],
}
workflow_runs.get_pause_details.assert_called_once_with(
request_context,
workflow_run_id="run-1",
)
@staticmethod
def test_pause_details_maps_missing_or_inaccessible_run_to_not_found(
app: Flask, monkeypatch: pytest.MonkeyPatch
) -> None:
workflow_runs = Mock()
workflow_runs.get_pause_details.return_value = None
_workflow_pause_details_api_mock_application_services(monkeypatch, workflow_runs)
request_context = _workflow_pause_details_api_request_context(workspace_id="other-tenant")
api = workflow_run_module.ConsoleWorkflowPauseDetailsApi()
handler = unwrap(api.get)
with app.test_request_context("/console/api/workflow/run-1/pause-details", method="GET"):
with pytest.raises(NotFoundError, match="Workflow run not found"):
handler(api, request_context, workflow_run_id="run-1")
workflow_runs.get_pause_details.assert_called_once_with(
request_context,
workflow_run_id="run-1",
)
@staticmethod
def test_pause_details_returns_empty_response_for_non_paused_run(
app: Flask, monkeypatch: pytest.MonkeyPatch
) -> None:
workflow_runs = Mock()
workflow_runs.get_pause_details.return_value = WorkflowRunPauseDetails(paused_at=None, paused_nodes=())
_workflow_pause_details_api_mock_application_services(monkeypatch, workflow_runs)
api = workflow_run_module.ConsoleWorkflowPauseDetailsApi()
handler = unwrap(api.get)
with app.test_request_context("/console/api/workflow/run-1/pause-details", method="GET"):
response, status = handler(api, _workflow_pause_details_api_request_context(), workflow_run_id="run-1")
assert status == 200
assert response == {"paused_at": None, "paused_nodes": []}
@staticmethod
def test_pause_details_response_schema_is_registered() -> None:
assert workflow_run_module.WorkflowPauseDetailsResponse.__name__ in workflow_run_module.console_ns.models
def _serialize_200_response(handler, payload: Any) -> Any:
response_doc = getattr(handler, "__apidoc__", {}).get("responses", {}).get("200")
if response_doc is None:
return payload
response_model = response_doc[1]
if isinstance(response_model, dict):
return marshal(payload, response_model)
return payload
def _account(session: Session) -> Account:
account = make_account(name="Alice", email="alice@example.com")
session.add(account)
session.commit()
return account
def _app() -> App:
return make_app(name="Workflow run app", mode=AppMode.WORKFLOW)
def _workflow_run_api_request_context(*, workspace_id: str = "tenant-1") -> RequestContext:
return RequestContext(
request_id="request-1",
trace_id="trace-1",
account_id="account-1",
active_workspace_id=workspace_id,
)
def _workflow_run_api_mock_application_services(
monkeypatch: pytest.MonkeyPatch, workflow_runs: Mock | WorkflowRunService
) -> None:
monkeypatch.setattr(
workflow_run_module,
"application_services",
lambda: SimpleNamespace(workflow_runs=workflow_runs),
)
def _workflow_run_summary(session: Session, **overrides: object) -> WorkflowRun:
created_at = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
workflow_run = WorkflowRun(
id="run-1",
tenant_id="tenant-1",
app_id="app-1",
workflow_id="workflow-1",
type=WorkflowType.WORKFLOW,
triggered_from=WorkflowRunTriggeredFrom.DEBUGGING,
version="v1",
graph='{"nodes": []}',
inputs='{"query": "hello"}',
status=WorkflowExecutionStatus.SUCCEEDED,
outputs='{"answer": "world"}',
error=None,
elapsed_time=1.5,
total_tokens=10,
total_steps=2,
created_by_role=CreatorUserRole.ACCOUNT,
created_by="account-1",
finished_at=created_at,
exceptions_count=0,
)
workflow_run.created_at = created_at
for name, value in overrides.items():
setattr(workflow_run, name, value)
workflow_run.retry_index = 0
session.add(workflow_run)
session.commit()
return workflow_run
def _workflow_run_node_execution(session: Session) -> WorkflowNodeExecutionModel:
created_at = datetime(2026, 1, 2, 3, 4, 5, tzinfo=UTC)
execution = WorkflowNodeExecutionModel(
id="node-exec-1",
tenant_id="tenant-1",
app_id="app-1",
workflow_id="workflow-1",
triggered_from=WorkflowNodeExecutionTriggeredFrom.WORKFLOW_RUN,
workflow_run_id="run-1",
index=1,
predecessor_node_id=None,
node_execution_id="node-execution-1",
node_id="node-1",
node_type="start",
title="Start",
agent_workspace_binding_id=None,
inputs=json.dumps({"query": "hello"}),
process_data=json.dumps({"step": "prepared"}),
outputs=json.dumps({"answer": "world"}),
status=WorkflowNodeExecutionStatus.SUCCEEDED,
error=None,
elapsed_time=1.0,
execution_metadata=json.dumps({"total_tokens": 3}),
created_by_role=CreatorUserRole.ACCOUNT,
created_by="account-1",
finished_at=created_at,
)
execution.created_at = created_at
execution.offload_data = []
session.add(execution)
session.commit()
return execution
class TestWorkflowRunApiCases:
@staticmethod
def test_workflow_run_list_returns_frontend_history_contract(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
_account(sqlite_session)
workflow_run = _workflow_run_summary(sqlite_session)
workflow_runs = Mock()
workflow_runs.get_paginate_workflow_runs.return_value = SimpleNamespace(
limit=10,
has_more=False,
data=[workflow_run],
)
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
request_context = _workflow_run_api_request_context()
api = workflow_run_module.WorkflowRunListApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/workflow-runs?limit=10", method="GET"):
payload = handler(
api,
sqlite_session,
workflow_run_module.WorkflowRunListQuery(limit=10),
request_context,
app_model=_app(),
)
response = _serialize_200_response(api.get, payload)
assert response["limit"] == 10
assert response["has_more"] is False
assert response["data"][0] == {
"id": "run-1",
"version": "v1",
"status": "succeeded",
"elapsed_time": 1.5,
"total_tokens": 10,
"total_steps": 2,
"created_by_account": {"id": "account-1", "name": "Alice", "email": "alice@example.com"},
"created_at": 1767323045,
"finished_at": 1767323045,
"exceptions_count": 0,
"retry_index": 0,
}
workflow_runs.get_paginate_workflow_runs.assert_called_once_with(
request_context,
app_id="app-1",
args={"limit": 10},
triggered_from=WorkflowRunTriggeredFrom.DEBUGGING,
)
@staticmethod
def test_advanced_chat_workflow_run_list_keeps_message_fields(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
_account(sqlite_session)
workflow_run = _workflow_run_summary(
sqlite_session,
conversation_id="conversation-1",
message_id="message-1",
)
workflow_runs = Mock()
workflow_runs.get_paginate_advanced_chat_workflow_runs.return_value = SimpleNamespace(
limit=1,
has_more=True,
data=[workflow_run],
)
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
request_context = _workflow_run_api_request_context()
api = workflow_run_module.AdvancedChatAppWorkflowRunListApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/advanced-chat/workflow-runs?limit=1", method="GET"):
payload = handler(
api,
sqlite_session,
workflow_run_module.WorkflowRunListQuery(limit=1),
request_context,
app_model=_app(),
)
response = _serialize_200_response(api.get, payload)
assert response["data"][0]["conversation_id"] == "conversation-1"
assert response["data"][0]["message_id"] == "message-1"
workflow_runs.get_paginate_advanced_chat_workflow_runs.assert_called_once_with(
request_context,
app_id="app-1",
args={"limit": 1},
triggered_from=WorkflowRunTriggeredFrom.DEBUGGING,
)
@staticmethod
def test_workflow_run_count_passes_filters_to_application_service(
app: Flask, monkeypatch: pytest.MonkeyPatch
) -> None:
workflow_runs = Mock()
workflow_runs.get_workflow_runs_count.return_value = {
"total": 2,
"running": 0,
"succeeded": 2,
"failed": 0,
"stopped": 0,
"partial-succeeded": 0,
}
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
request_context = _workflow_run_api_request_context()
query = workflow_run_module.WorkflowRunCountQuery(
status="succeeded",
time_range="7d",
triggered_from="app-run",
)
api = workflow_run_module.WorkflowRunCountApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/workflow-runs/count", method="GET"):
payload = handler(api, query, request_context, app_model=_app())
assert payload == {
"total": 2,
"running": 0,
"succeeded": 2,
"failed": 0,
"stopped": 0,
"partial_succeeded": 0,
}
workflow_runs.get_workflow_runs_count.assert_called_once_with(
request_context,
app_id="app-1",
status="succeeded",
time_range="7d",
triggered_from=WorkflowRunTriggeredFrom.APP_RUN,
)
@staticmethod
def test_workflow_run_detail_returns_frontend_detail_contract(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
_account(sqlite_session)
workflow_run = _workflow_run_summary(sqlite_session)
workflow_runs = Mock()
workflow_runs.get_workflow_run.return_value = workflow_run
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
request_context = _workflow_run_api_request_context()
api = workflow_run_module.WorkflowRunDetailApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/workflow-runs/run-1", method="GET"):
payload = handler(api, sqlite_session, request_context, app_model=_app(), run_id="run-1")
response = _serialize_200_response(api.get, payload)
assert response == {
"id": "run-1",
"version": "v1",
"graph": {"nodes": []},
"inputs": {"query": "hello"},
"status": "succeeded",
"outputs": {"answer": "world"},
"error": None,
"elapsed_time": 1.5,
"total_tokens": 10,
"total_steps": 2,
"created_by_role": "account",
"created_by_account": {"id": "account-1", "name": "Alice", "email": "alice@example.com"},
"created_by_end_user": None,
"created_at": 1767323045,
"finished_at": 1767323045,
"exceptions_count": 0,
}
workflow_runs.get_workflow_run.assert_called_once_with(
request_context,
app_id="app-1",
run_id="run-1",
)
@staticmethod
def test_workflow_run_detail_maps_missing_run_to_not_found(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
workflow_runs = Mock()
workflow_runs.get_workflow_run.return_value = None
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
request_context = _workflow_run_api_request_context(workspace_id="tenant-2")
api = workflow_run_module.WorkflowRunDetailApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/workflow-runs/run-1", method="GET"):
with pytest.raises(NotFoundError, match="Workflow run not found"):
handler(api, sqlite_session, request_context, app_model=_app(), run_id="run-1")
workflow_runs.get_workflow_run.assert_called_once_with(
request_context,
app_id="app-1",
run_id="run-1",
)
@staticmethod
def test_workflow_run_node_executions_return_frontend_trace_contract(
app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
_account(sqlite_session)
execution = _workflow_run_node_execution(sqlite_session)
workflow_runs = Mock()
workflow_runs.get_workflow_run_node_executions.return_value = [
node_execution_response_source(execution, session=sqlite_session)
]
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
monkeypatch.setattr(db, "session", lambda: sqlite_session)
request_context = _workflow_run_api_request_context()
api = workflow_run_module.WorkflowRunNodeExecutionListApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/workflow-runs/run-1/node-executions", method="GET"):
payload = handler(api, request_context, app_model=_app(), run_id="run-1")
response = _serialize_200_response(api.get, payload)
assert response == {
"data": [
{
"id": "node-exec-1",
"index": 1,
"predecessor_node_id": None,
"node_id": "node-1",
"node_type": "start",
"title": "Start",
"inputs": {"query": "hello"},
"process_data": {"step": "prepared"},
"outputs": {"answer": "world"},
"status": "succeeded",
"error": None,
"elapsed_time": 1.0,
"execution_metadata": {"total_tokens": 3},
"extras": {},
"created_at": 1767323045,
"created_by_role": "account",
"created_by_account": {"id": "account-1", "name": "Alice", "email": "alice@example.com"},
"created_by_end_user": None,
"finished_at": 1767323045,
"inputs_truncated": False,
"outputs_truncated": False,
"process_data_truncated": False,
}
]
}
workflow_runs.get_workflow_run_node_executions.assert_called_once_with(
request_context,
app_id="app-1",
run_id="run-1",
)
@staticmethod
@pytest.fixture
def workflow_run_service(sqlite_session_factory: sessionmaker[Session]) -> WorkflowRunService:
return WorkflowRunService(
session_factory=sqlite_session_factory,
workflow_runs=DifyAPISQLAlchemyWorkflowRunRepository(sqlite_session_factory),
node_executions=DifyAPISQLAlchemyWorkflowNodeExecutionRepository(sqlite_session_factory),
)
@staticmethod
@pytest.mark.parametrize("source_access", ["granted", "maintainer", "rbac-disabled"])
def test_workflow_tool_children_preserve_source_identity(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
rbac_domain: RBACDomain,
config_overrides: Callable[..., None],
source_access: str,
workflow_run_service: WorkflowRunService,
mocker: MockerFixture,
) -> None:
config_overrides(RBAC_ENABLED=source_access != "rbac-disabled")
monkeypatch.setattr(rbac_locators, "application_services", lambda: rbac_domain)
sqlite_session.add(
make_app(app_id="source-app", maintainer="account-1" if source_access == "maintainer" else None)
)
sqlite_session.commit()
monkeypatch.setattr(db, "session", sqlite_session)
check_access = mocker.patch.object(RBACService.CheckAccess, "check", return_value=source_access == "granted")
workflow_runs = workflow_run_service
child_traces = [
WorkflowNodeExecutionTrace(
id="child-row",
tenant_id="tenant-1",
app_id="source-app",
workflow_id="source-workflow",
triggered_from="workflow-tool",
node_execution_id="source-execution",
created_by="account-1",
outputs={"answer": "world"},
)
]
get_children = mocker.patch.object(
workflow_runs, "get_workflow_tool_node_executions", return_value=child_traces
)
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
context = _workflow_run_api_request_context()
api = workflow_run_module.WorkflowToolNodeExecutionListApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/workflow-runs/run-1/node-executions/parent/children"):
response = handler(api, context, app_model=_app(), run_id="run-1", node_execution_id="parent")
get_children.return_value = None
with pytest.raises(NotFoundError, match="Workflow run not found"):
handler(api, context, app_model=_app(), run_id="run-1", node_execution_id="parent")
assert response["data"][0]["node_execution_id"] == "source-execution"
assert response["data"][0]["outputs"] == {"answer": "world"}
if source_access == "granted":
check_access.assert_called_once_with(
"tenant-1",
"account-1",
scene=RBACPermission.APP_CREATE_AND_MANAGEMENT,
resource_type=RBACResourceScope.APP,
resource_id="source-app",
)
else:
check_access.assert_not_called()
get_children.assert_called_with(context, app_id="app-1", run_id="run-1", node_execution_id="parent")
@staticmethod
@pytest.mark.parametrize("source_app_ids", [("source-app",), ("allowed-source", "source-app")])
def test_workflow_tool_children_deny_any_unauthorized_source(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
rbac_domain: RBACDomain,
config_overrides: Callable[..., None],
source_app_ids: tuple[str, ...],
workflow_run_service: WorkflowRunService,
mocker: MockerFixture,
) -> None:
config_overrides(RBAC_ENABLED=True)
monkeypatch.setattr(rbac_locators, "application_services", lambda: rbac_domain)
sqlite_session.add_all(make_app(app_id=app_id) for app_id in ("app-1", "allowed-source", "source-app"))
sqlite_session.commit()
monkeypatch.setattr(db, "session", sqlite_session)
check_access = mocker.patch.object(
RBACService.CheckAccess,
"check",
side_effect=lambda *_args, resource_id, **_kwargs: resource_id != "source-app",
)
workflow_runs = workflow_run_service
child_traces = [
WorkflowNodeExecutionTrace(
id=f"{app_id}-row",
tenant_id="tenant-1",
app_id=app_id,
workflow_id=f"{app_id}-workflow",
triggered_from="workflow-tool",
created_by="account-1",
inputs={"secret": "source input"},
process_data={"secret": "source internals"},
outputs={"secret": "source output"},
)
for app_id in source_app_ids
]
get_children = mocker.patch.object(
workflow_runs, "get_workflow_tool_node_executions", return_value=child_traces
)
_workflow_run_api_mock_application_services(monkeypatch, workflow_runs)
context = _workflow_run_api_request_context()
api = workflow_run_module.WorkflowToolNodeExecutionListApi()
handler = unwrap(api.get)
with app.test_request_context("/apps/app-1/workflow-runs/run-1/node-executions/parent/children"):
request.view_args = {"app_id": "app-1"}
with pytest.raises(Forbidden, match="permission to view this tool's internal execution details") as error:
handler(api, context, app_model=_app(), run_id="run-1", node_execution_id="parent")
assert error.value.code == 403
assert check_access.call_args.kwargs["resource_id"] == "source-app"
get_children.assert_called_once_with(context, app_id="app-1", run_id="run-1", node_execution_id="parent")
@@ -0,0 +1,459 @@
"""Workflow trigger routes use real admission, composition, and SQLite transactions."""
from collections.abc import Iterator
from dataclasses import dataclass
from datetime import datetime
from http import HTTPStatus
from uuid import uuid4
import pytest
from flask import Blueprint, Flask, Response
from flask.testing import FlaskClient
from flask_restx import Resource
from redis import Redis
from sqlalchemy import Connection, Engine, event, select, text
from sqlalchemy.orm import Session, SessionTransaction, sessionmaker
from werkzeug.test import TestResponse
from constants import HEADER_NAME_CSRF_TOKEN
from controllers.console.app import workflow_trigger
from controllers.console.wraps import _is_setup_completed
from core.trigger.utils.endpoint import base_url
from enums import DeploymentEdition
from extensions.ext_application_services import build_application_services
from extensions.ext_login import DifyLoginManager, bind_account_loader, load_user_from_request, unauthorized_handler
from extensions.ext_redis import RedisClientWrapper
from libs.datetime_utils import naive_utc_now
from libs.external_api import ExternalApi
from libs.passport import PassportService
from libs.token import _real_cookie_name, generate_csrf_token
from models import Account, DifySetup, Tenant, TenantAccountJoin
from models.account import AccountStatus, TenantAccountRole
from models.agent import Agent, AgentScope, AgentSource
from models.engine import db
from models.enums import AppTriggerStatus, AppTriggerType
from models.model import App, AppMode
from models.trigger import AppTrigger, WorkflowWebhookTrigger
from tests.helpers.unit.config_override import config_overrides_context
_CREATED_AT = datetime(2026, 1, 2, 3, 4, 5)
@dataclass(frozen=True)
class _Endpoint:
method: str
path: str
resource: type[Resource]
_ENDPOINTS = (
_Endpoint("GET", "workflows/triggers/webhook", workflow_trigger.WebhookTriggerApi),
_Endpoint("GET", "triggers", workflow_trigger.AppTriggersApi),
_Endpoint("POST", "trigger-enable", workflow_trigger.AppTriggerEnableApi),
)
@dataclass(frozen=True)
class _Harness:
client: FlaskClient
session_factory: sessionmaker[Session]
account_id: str
tenant_id: str
headers: dict[str, str]
sessions: list[Session]
def create_app(self, *, tenant_id: str | None = None, mode: AppMode = AppMode.WORKFLOW) -> str:
with self.session_factory.begin() as session:
app = App(
tenant_id=tenant_id or self.tenant_id,
name="Trigger app",
mode=mode,
created_by=self.account_id,
maintainer=self.account_id,
enable_api=True,
enable_site=True,
)
session.add(app)
session.flush()
return app.id
def create_trigger(
self,
app_id: str,
*,
tenant_id: str | None = None,
trigger_type: AppTriggerType = AppTriggerType.TRIGGER_PLUGIN,
status: AppTriggerStatus = AppTriggerStatus.ENABLED,
created_at: datetime = _CREATED_AT,
) -> str:
with self.session_factory.begin() as session:
trigger = AppTrigger(
tenant_id=tenant_id or self.tenant_id,
app_id=app_id,
node_id="node-1",
trigger_type=trigger_type,
title="Trigger",
provider_name="langgenius/github/github",
status=status,
)
trigger.created_at = created_at
trigger.updated_at = created_at
session.add(trigger)
session.flush()
return trigger.id
def create_webhook(self, app_id: str, *, tenant_id: str | None = None, node_id: str = "node-1") -> str:
with self.session_factory.begin() as session:
webhook = WorkflowWebhookTrigger(
app_id=app_id,
tenant_id=tenant_id or self.tenant_id,
node_id=node_id,
webhook_id=str(uuid4())[:24],
created_by=self.account_id,
)
webhook.created_at = _CREATED_AT
session.add(webhook)
session.flush()
return webhook.id
def set_role(self, role: TenantAccountRole) -> None:
with self.session_factory.begin() as session:
membership = session.scalar(
select(TenantAccountJoin).where(TenantAccountJoin.account_id == self.account_id)
)
assert membership is not None
membership.role = role
def call(self, endpoint: _Endpoint, app_id: str) -> TestResponse:
self.sessions.clear()
if endpoint.method == "POST":
return self.client.post(
f"/console/api/apps/{app_id}/{endpoint.path}",
headers=self.headers,
json={"trigger_id": str(uuid4()), "enable_trigger": True},
)
return self.client.get(
f"/console/api/apps/{app_id}/{endpoint.path}", headers=self.headers, query_string={"node_id": "node-1"}
)
def enable(self, app_id: str, payload: dict[str, object]) -> TestResponse:
self.sessions.clear()
return self.client.post(f"/console/api/apps/{app_id}/trigger-enable", headers=self.headers, json=payload)
@pytest.fixture
def harness(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]) -> Iterator[_Harness]:
with (
Redis() as redis_client,
config_overrides_context(
DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY,
RBAC_ENABLED=False,
LOGIN_DISABLED=False,
INIT_PASSWORD="",
SECRET_KEY="trigger-http-test-secret-at-least-32-bytes",
CONSOLE_API_URL="https://console.example.test",
),
):
app = Flask(__name__)
app.config.update(TESTING=True, SQLALCHEMY_DATABASE_URI=str(sqlite_engine.url))
db.init_app(app)
redis = RedisClientWrapper()
redis.initialize(redis_client)
services = build_application_services(
database_client=sqlite_session_factory,
deployment_edition=DeploymentEdition.COMMUNITY,
initialization_password="",
redis=redis,
)
app.extensions["application_services"] = services
bind_account_loader(app, services.accounts.identity.load_user)
login_manager = DifyLoginManager()
login_manager.request_loader(load_user_from_request)
login_manager.unauthorized_handler(unauthorized_handler)
login_manager.init_app(app)
blueprint = Blueprint("console", __name__, url_prefix="/console/api")
api = ExternalApi(blueprint)
for endpoint in _ENDPOINTS:
api.add_resource(endpoint.resource, f"/apps/<uuid:app_id>/{endpoint.path}")
app.register_blueprint(blueprint)
now = naive_utc_now()
with sqlite_session_factory.begin() as session:
account = Account(
email="triggers@example.com",
name="Trigger editor",
status=AccountStatus.ACTIVE,
initialized_at=now,
)
account.last_active_at = now
tenant = Tenant(name="Trigger workspace")
session.add_all([account, tenant, DifySetup(version="test")])
session.flush()
session.add(
TenantAccountJoin(
tenant_id=tenant.id,
account_id=account.id,
role=TenantAccountRole.OWNER,
current=True,
)
)
account_id, tenant_id = account.id, tenant.id
# The legacy setup cache has a separate scoped session. Warm and remove
# it before observing the transaction boundaries of each actual request.
with app.app_context():
_is_setup_completed.reset_success()
assert _is_setup_completed()
db.session.remove()
client = app.test_client()
csrf_token = generate_csrf_token(account_id)
client.set_cookie(_real_cookie_name("csrf_token"), csrf_token)
headers = {
"Authorization": f"Bearer {PassportService().issue({'user_id': account_id})}",
HEADER_NAME_CSRF_TOKEN: csrf_token,
}
sessions: list[Session] = []
def observe_session(session: Session, _transaction: SessionTransaction, _connection: Connection) -> None:
sessions.append(session)
@app.after_request
def assert_request_sessions_closed(response: Response) -> Response:
assert all(not session.in_transaction() and not session.identity_map for session in sessions)
return response
event.listen(Session, "after_begin", observe_session)
try:
yield _Harness(client, sqlite_session_factory, account_id, tenant_id, headers, sessions)
finally:
event.remove(Session, "after_begin", observe_session)
_is_setup_completed.reset_success()
with app.app_context():
db.session.remove()
db.engine.dispose()
@pytest.mark.parametrize("endpoint", _ENDPOINTS, ids=lambda endpoint: endpoint.path)
@pytest.mark.parametrize("visibility", ["missing", "different-workspace", "non-normal", "workflow-only", "wrong-mode"])
def test_triggers_reject_inaccessible_apps(harness: _Harness, endpoint: _Endpoint, visibility: str) -> None:
app_id = str(uuid4())
if visibility != "missing":
app_id = harness.create_app(tenant_id=str(uuid4()) if visibility == "different-workspace" else None)
with harness.session_factory.begin() as session:
app = session.get(App, app_id)
assert app is not None
if visibility == "non-normal":
session.execute(text("UPDATE apps SET status = 'archived' WHERE id = :app_id"), {"app_id": app_id})
elif visibility == "wrong-mode":
app.mode = AppMode.CHAT
elif visibility == "workflow-only":
app.mode = AppMode.AGENT
session.add(
Agent(
tenant_id=harness.tenant_id,
name="Hidden workflow agent",
scope=AgentScope.WORKFLOW_ONLY,
source=AgentSource.WORKFLOW,
app_id=str(uuid4()),
backing_app_id=app_id,
)
)
response = harness.call(endpoint, app_id)
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "app_not_found"
assert response.content_type == "application/json"
assert harness.sessions
def test_list_empty_triggers(harness: _Harness) -> None:
response = harness.call(_ENDPOINTS[1], harness.create_app())
assert response.status_code == HTTPStatus.OK
assert response.get_json() == {"data": []}
def test_list_orders_and_serializes_triggers_without_leaking_other_owners(harness: _Harness) -> None:
app_id = harness.create_app()
older = harness.create_trigger(app_id, created_at=datetime(2025, 1, 1))
same_time = [
harness.create_trigger(app_id, trigger_type=trigger_type, status=status)
for trigger_type, status in zip(AppTriggerType, AppTriggerStatus, strict=True)
]
expected_statuses = dict(zip(same_time, AppTriggerStatus, strict=True))
expected_statuses[older] = AppTriggerStatus.ENABLED
harness.create_trigger(app_id, tenant_id=str(uuid4()))
harness.create_trigger(harness.create_app())
response = harness.call(_ENDPOINTS[1], app_id)
assert response.status_code == HTTPStatus.OK
data = response.get_json()["data"]
assert [item["id"] for item in data] == sorted(same_time, reverse=True) + [older]
for item in data:
assert set(item) == {
"id",
"trigger_type",
"title",
"node_id",
"provider_name",
"icon",
"status",
"created_at",
"updated_at",
}
assert item["title"] == "Trigger"
assert item["node_id"] == "node-1"
assert item["provider_name"] == "langgenius/github/github"
assert item["status"] == expected_statuses[item["id"]].value
if item["trigger_type"] == AppTriggerType.TRIGGER_PLUGIN:
assert item["icon"] == (
"https://console.example.test/console/api/workspaces/current/tool-provider/builtin/"
"langgenius/github/github/icon"
)
else:
assert item["icon"] == ""
if item["id"] in same_time:
assert item["created_at"] == "2026-01-02T03:04:05"
assert item["updated_at"] == "2026-01-02T03:04:05"
@pytest.mark.parametrize("role", [TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR])
def test_editor_roles_can_disable_and_enable_with_committed_status(harness: _Harness, role: TenantAccountRole) -> None:
harness.set_role(role)
app_id = harness.create_app()
trigger_id = harness.create_trigger(app_id)
for enabled, expected in [(False, AppTriggerStatus.DISABLED), (True, AppTriggerStatus.ENABLED)]:
response = harness.enable(app_id, {"trigger_id": trigger_id, "enable_trigger": enabled})
assert response.status_code == HTTPStatus.OK
body = response.get_json()
assert body["id"] == trigger_id
assert body["status"] == expected.value
assert body["icon"].endswith("/langgenius/github/github/icon")
with harness.session_factory() as session:
persisted = session.get(AppTrigger, trigger_id)
assert persisted is not None
assert persisted.status == expected
@pytest.mark.parametrize("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])
def test_read_only_roles_cannot_update_trigger(harness: _Harness, role: TenantAccountRole) -> None:
harness.set_role(role)
app_id = harness.create_app()
trigger_id = harness.create_trigger(app_id)
response = harness.enable(app_id, {"trigger_id": trigger_id, "enable_trigger": False})
assert response.status_code == HTTPStatus.FORBIDDEN
with harness.session_factory() as session:
persisted = session.get(AppTrigger, trigger_id)
assert persisted is not None
assert persisted.status == AppTriggerStatus.ENABLED
assert harness.call(_ENDPOINTS[1], app_id).status_code == HTTPStatus.OK
@pytest.mark.parametrize("missing_field", ["trigger_id", "enable_trigger"])
def test_invalid_update_payload_does_not_write(harness: _Harness, missing_field: str) -> None:
app_id = harness.create_app()
trigger_id = harness.create_trigger(app_id)
payload: dict[str, object] = {"trigger_id": trigger_id, "enable_trigger": False}
del payload[missing_field]
response = harness.enable(app_id, payload)
assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY
with harness.session_factory() as session:
persisted = session.get(AppTrigger, trigger_id)
assert persisted is not None
assert persisted.status == AppTriggerStatus.ENABLED
@pytest.mark.parametrize("target", ["missing", "other-app", "other-tenant"])
def test_update_rejects_trigger_outside_requested_owner_chain(harness: _Harness, target: str) -> None:
app_id = harness.create_app()
trigger_id = str(uuid4())
if target == "other-app":
trigger_id = harness.create_trigger(harness.create_app())
elif target == "other-tenant":
trigger_id = harness.create_trigger(app_id, tenant_id=str(uuid4()))
response = harness.enable(app_id, {"trigger_id": trigger_id, "enable_trigger": False})
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "app_trigger_not_found"
if target != "missing":
with harness.session_factory() as session:
persisted = session.get(AppTrigger, trigger_id)
assert persisted is not None
assert persisted.status == AppTriggerStatus.ENABLED
def test_webhook_returns_detached_configuration_and_urls(harness: _Harness) -> None:
app_id = harness.create_app()
webhook_id = harness.create_webhook(app_id)
with harness.session_factory() as session:
webhook = session.get(WorkflowWebhookTrigger, webhook_id)
assert webhook is not None
external_id = webhook.webhook_id
response = harness.call(_ENDPOINTS[0], app_id)
assert response.status_code == HTTPStatus.OK
assert response.get_json() == {
"id": webhook_id,
"webhook_id": external_id,
"node_id": "node-1",
"webhook_url": f"{str(base_url).rstrip('/')}/triggers/webhook/{external_id}",
"webhook_debug_url": f"{str(base_url).rstrip('/')}/triggers/webhook-debug/{external_id}",
"created_at": "2026-01-02T03:04:05",
}
@pytest.mark.parametrize("target", ["missing", "other-app", "other-tenant", "other-node"])
def test_webhook_rejects_references_outside_requested_owner_chain(harness: _Harness, target: str) -> None:
app_id = harness.create_app()
if target == "other-app":
harness.create_webhook(harness.create_app())
elif target == "other-tenant":
harness.create_webhook(app_id, tenant_id=str(uuid4()))
elif target == "other-node":
harness.create_webhook(app_id, node_id="node-2")
response = harness.call(_ENDPOINTS[0], app_id)
assert response.status_code == HTTPStatus.NOT_FOUND
assert response.get_json()["code"] == "webhook_trigger_not_found"
def test_app_owner_with_rbac_enabled_uses_real_owner_admission(harness: _Harness) -> None:
harness.set_role(TenantAccountRole.NORMAL)
app_id = harness.create_app()
trigger_id = harness.create_trigger(app_id)
with config_overrides_context(RBAC_ENABLED=True):
response = harness.enable(app_id, {"trigger_id": trigger_id, "enable_trigger": False})
assert response.status_code == HTTPStatus.OK
assert response.get_json()["status"] == AppTriggerStatus.DISABLED
def test_update_requires_csrf_before_persistence(harness: _Harness) -> None:
app_id = harness.create_app()
trigger_id = harness.create_trigger(app_id)
harness.sessions.clear()
response = harness.client.post(
f"/console/api/apps/{app_id}/trigger-enable",
headers={"Authorization": harness.headers["Authorization"]},
json={"trigger_id": trigger_id, "enable_trigger": False},
)
assert response.status_code == HTTPStatus.UNAUTHORIZED
with harness.session_factory() as session:
persisted = session.get(AppTrigger, trigger_id)
assert persisted is not None
assert persisted.status == AppTriggerStatus.ENABLED
@@ -0,0 +1,141 @@
from __future__ import annotations
from inspect import getsource
from uuid import uuid4
import pytest
from sqlalchemy.orm import Session
from controllers.common.session import with_session
from controllers.console.app import completion as completion_module
from controllers.console.app import workflow as workflow_module
from controllers.console.app import wraps as wraps_module
from controllers.console.app.error import AppNotFoundError
from models.agent import Agent, AgentScope, AgentSource, AgentStatus
from models.model import App, AppMode
def _persist_app(sqlite_session: Session, *, mode: AppMode = AppMode.CHAT) -> App:
app_model = App(
tenant_id=str(uuid4()),
name="Test App",
mode=mode,
enable_site=True,
enable_api=True,
)
app_model.id = str(uuid4())
sqlite_session.add(app_model)
sqlite_session.commit()
return app_model
def test_get_app_model_injects_model(monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:
app_model = _persist_app(sqlite_session)
monkeypatch.setattr(wraps_module, "current_account_with_tenant", lambda: (None, app_model.tenant_id))
monkeypatch.setattr(wraps_module.db, "session", sqlite_session)
@wraps_module.get_app_model
def handler(app_model):
return app_model.id
assert handler(app_id=app_model.id) == app_model.id
def test_get_app_model_rejects_wrong_mode(monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:
app_model = _persist_app(sqlite_session)
monkeypatch.setattr(wraps_module, "current_account_with_tenant", lambda: (None, app_model.tenant_id))
monkeypatch.setattr(wraps_module.db, "session", sqlite_session)
@wraps_module.get_app_model(mode=[AppMode.COMPLETION])
def handler(app_model):
return app_model.id
with pytest.raises(AppNotFoundError):
handler(app_id=app_model.id)
def test_get_app_model_requires_app_id() -> None:
@wraps_module.get_app_model
def handler(app_model):
return app_model.id
with pytest.raises(ValueError, match="missing app_id in path parameters"):
handler()
def test_wraps_with_session_reexports_common_session_decorator() -> None:
assert wraps_module.with_session is with_session
def test_get_app_model_prefers_injected_session(
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
) -> None:
app_model = _persist_app(sqlite_session)
monkeypatch.setattr(wraps_module, "current_account_with_tenant", lambda: (None, app_model.tenant_id))
class Handler:
@wraps_module.get_app_model
def get(self, _injected_session, app_model):
return app_model.id
# An unbound real Session fails on query, so success proves the injected
# request Session was preferred over the legacy scoped-session fallback.
with Session() as scoped_session:
monkeypatch.setattr(wraps_module.db, "session", scoped_session)
assert Handler().get(sqlite_session, app_id=app_model.id) == app_model.id
@pytest.mark.parametrize("scope", [AgentScope.ROSTER, AgentScope.WORKFLOW_ONLY])
@pytest.mark.parametrize("status", [AgentStatus.ACTIVE, AgentStatus.ARCHIVED])
@pytest.mark.parametrize("inject_session", [False, True])
def test_get_app_model_hides_only_workflow_backing_apps(
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
scope: AgentScope,
status: AgentStatus,
inject_session: bool,
) -> None:
app_model = _persist_app(sqlite_session, mode=AppMode.AGENT)
workflow_only = scope == AgentScope.WORKFLOW_ONLY
sqlite_session.add(
Agent(
tenant_id=app_model.tenant_id,
name="Bound agent",
scope=scope,
source=AgentSource.WORKFLOW if workflow_only else AgentSource.AGENT_APP,
status=status,
app_id=None if workflow_only else app_model.id,
backing_app_id=app_model.id if workflow_only else None,
)
)
sqlite_session.commit()
monkeypatch.setattr(wraps_module, "current_account_with_tenant", lambda: (None, app_model.tenant_id))
monkeypatch.setattr(wraps_module.db, "session", sqlite_session)
class Handler:
@wraps_module.get_app_model
def get(self, *_args: object, app_model: App) -> str:
return app_model.id
args = (sqlite_session,) if inject_session else ()
if workflow_only:
with pytest.raises(AppNotFoundError):
Handler().get(*args, app_id=app_model.id)
else:
assert Handler().get(*args, app_id=app_model.id) == app_model.id
@pytest.mark.parametrize(
"resource",
[
completion_module.CompletionMessageApi,
completion_module.ChatMessageApi,
workflow_module.AdvancedChatDraftWorkflowRunApi,
workflow_module.DraftWorkflowRunApi,
workflow_module.DraftWorkflowTriggerRunApi,
workflow_module.DraftWorkflowTriggerRunAllApi,
],
)
def test_migrated_handlers_open_session_before_app_lookup(resource: type) -> None:
assert "@with_session\n @get_app_model" in getsource(resource)
@@ -0,0 +1,253 @@
"""Transport-boundary tests for account invitation activation."""
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
import pytest
from flask import Flask
from pytest_mock import MockerFixture
from sqlalchemy.orm import Session, sessionmaker
from werkzeug.exceptions import UnprocessableEntity
from controllers.console.auth.activate import ActivateApi, ActivateCheckApi
from controllers.console.auth.error import InvitationAccountMismatchError as InvitationAccountMismatchHTTPError
from controllers.console.error import (
AccountInFreezeError,
AlreadyActivateError,
)
from controllers.console.error import (
EmailDomainSuspendedError as EmailDomainSuspendedHTTPError,
)
from enums import DeploymentEdition
from extensions.ext_application_services import build_application_services
from extensions.ext_redis import RedisClientWrapper
from libs.login import AccountWithTenant
from models.account import Account
from services.account_activation_service import AccountActivationService
from services.account_errors import AccountEmailDomainSuspendedError as EmailDomainSuspendedRegistrationError
from services.account_errors import FrozenAccountError, InvalidInvitationError, InvitationAccountMismatchError
from services.entities.account_activation_entities import (
ActivationCheckData,
ActivationCheckResult,
ActivationCommand,
InvitationLookup,
)
@pytest.fixture
def app() -> Flask:
app = Flask(__name__)
app.config["TESTING"] = True
return app
@pytest.fixture
def activation_service(
sqlite_session_factory: sessionmaker[Session],
redis_transport: tuple[RedisClientWrapper, MagicMock],
mocker: MockerFixture,
) -> AccountActivationService:
service = build_application_services(
database_client=sqlite_session_factory,
deployment_edition=DeploymentEdition.COMMUNITY,
initialization_password="",
redis=redis_transport[0],
).accounts.activation
mocker.patch.object(service, "check")
mocker.patch.object(service, "activate")
return service
def _services(service: AccountActivationService) -> SimpleNamespace:
return SimpleNamespace(accounts=SimpleNamespace(activation=service))
class TestActivateCheckApi:
def test_serializes_valid_invitation(
self,
app: Flask,
activation_service: AccountActivationService,
) -> None:
activation_service.check.return_value = ActivationCheckResult(
is_valid=True,
data=ActivationCheckData(
workspace_name="Test Workspace",
workspace_id="workspace-123",
email="invitee@example.com",
account_status="pending",
requires_setup=True,
),
)
with (
app.test_request_context(
"/activate/check?workspace_id=workspace-123&email=invitee@example.com&token=valid-token"
),
patch(
"controllers.console.auth.activate.application_services",
return_value=_services(activation_service),
),
):
response = ActivateCheckApi().get()
assert response == {
"is_valid": True,
"data": {
"workspace_name": "Test Workspace",
"workspace_id": "workspace-123",
"email": "invitee@example.com",
"account_status": "pending",
"requires_setup": True,
},
}
activation_service.check.assert_called_once_with(
InvitationLookup(
workspace_id="workspace-123",
email="invitee@example.com",
token="valid-token",
),
)
def test_omits_data_for_invalid_invitation(self, app: Flask, activation_service: AccountActivationService) -> None:
activation_service.check.return_value = ActivationCheckResult(is_valid=False)
with (
app.test_request_context("/activate/check?token=invalid-token"),
patch(
"controllers.console.auth.activate.application_services",
return_value=_services(activation_service),
),
):
response = ActivateCheckApi().get()
assert response == {"is_valid": False}
def test_rejects_request_without_token(self, app: Flask, activation_service: AccountActivationService) -> None:
"""`token` is required, so a tokenless query must not reach the application service."""
with (
app.test_request_context("/activate/check?workspace_id=workspace-123"),
patch(
"controllers.console.auth.activate.application_services",
return_value=_services(activation_service),
),
pytest.raises(UnprocessableEntity),
):
ActivateCheckApi().get()
activation_service.check.assert_not_called()
class TestActivateApi:
def test_passes_parsed_command_to_application_service(
self,
app: Flask,
activation_service: AccountActivationService,
) -> None:
payload = {
"workspace_id": "workspace-123",
"email": "Invitee@Example.com",
"token": "valid-token",
"name": "John Doe",
"interface_language": "en-US",
"timezone": "UTC",
}
account = Account(name="User", email="user@example.com")
account.id = "account-123"
with (
app.test_request_context("/activate", method="POST", json=payload),
patch(
"controllers.console.auth.activate.application_services",
return_value=_services(activation_service),
),
patch("controllers.console.auth.activate.extract_access_token", return_value="access-token"),
patch(
"controllers.console.auth.activate.current_account_with_tenant",
return_value=AccountWithTenant(
account=account,
tenant_id="workspace-123",
),
),
):
response = ActivateApi().post()
assert response == {"result": "success"}
activation_service.activate.assert_called_once_with(
ActivationCommand(
invitation=InvitationLookup(
workspace_id="workspace-123",
email="Invitee@Example.com",
token="valid-token",
),
name="John Doe",
interface_language="en-US",
timezone="UTC",
),
authenticated_account_id="account-123",
)
def test_passes_no_authenticated_account_for_token_only_activation(
self,
app: Flask,
activation_service: AccountActivationService,
) -> None:
with (
app.test_request_context("/activate", method="POST", json={"token": "valid-token"}),
patch(
"controllers.console.auth.activate.application_services",
return_value=_services(activation_service),
),
patch("controllers.console.auth.activate.extract_access_token", return_value=None),
patch("controllers.console.auth.activate.current_account_with_tenant") as resolve_account,
):
response = ActivateApi().post()
assert response == {"result": "success"}
activation_service.activate.assert_called_once_with(
ActivationCommand(invitation=InvitationLookup(workspace_id=None, email=None, token="valid-token")),
authenticated_account_id=None,
)
resolve_account.assert_not_called()
@pytest.mark.parametrize(
("service_error", "http_error"),
[
(InvalidInvitationError(), AlreadyActivateError),
(InvitationAccountMismatchError(), InvitationAccountMismatchHTTPError),
(FrozenAccountError(), AccountInFreezeError),
(EmailDomainSuspendedRegistrationError(), EmailDomainSuspendedHTTPError),
],
)
def test_translates_application_errors(
self,
app: Flask,
activation_service: AccountActivationService,
service_error: Exception,
http_error: type[Exception],
) -> None:
activation_service.activate.side_effect = service_error
with (
app.test_request_context("/activate", method="POST", json={"token": "invalid-token"}),
patch(
"controllers.console.auth.activate.application_services",
return_value=_services(activation_service),
),
patch("controllers.console.auth.activate.extract_access_token", return_value=None),
pytest.raises(http_error),
):
ActivateApi().post()
def test_rejects_request_without_token(self, app: Flask, activation_service: AccountActivationService) -> None:
"""`token` is required, so a tokenless payload must not resolve the session or reach the service."""
with (
app.test_request_context("/activate", method="POST", json={"workspace_id": "workspace-123"}),
patch(
"controllers.console.auth.activate.application_services",
return_value=_services(activation_service),
),
patch("controllers.console.auth.activate.extract_access_token") as extract_token,
pytest.raises(UnprocessableEntity),
):
ActivateApi().post()
extract_token.assert_not_called()
activation_service.activate.assert_not_called()
@@ -0,0 +1,239 @@
from __future__ import annotations
from dataclasses import dataclass
from datetime import UTC, datetime
from inspect import unwrap
from unittest.mock import create_autospec, patch
from uuid import UUID
import pytest
from pydantic import ValidationError
from controllers.console.auth.data_source_bearer_auth import (
ApiKeyAuthBindingPayload,
ApiKeyAuthDataSource,
ApiKeyAuthDataSourceBinding,
ApiKeyAuthDataSourceBindingDelete,
)
from controllers.console.auth.error import (
DataSourceApiKeyAuthCredentialsRejectedRequestError,
DataSourceApiKeyAuthProviderNotSupportedError,
DataSourceApiKeyAuthProviderUnavailableRequestError,
InvalidDataSourceApiKeyAuthCredentialsRequestError,
)
from libs.exception import BaseHTTPException
from machinery.context import RequestContext
from services.auth.errors import (
DataSourceApiKeyAuthCredentialValidationError,
DataSourceApiKeyAuthProviderUnavailableError,
InvalidDataSourceApiKeyAuthCredentialsError,
UnsupportedDataSourceApiKeyAuthProviderError,
)
from services.data_source.auth.api_key_service import DataSourceApiKeyAuthService
from services.data_source.entities.api_key_auth import (
DataSourceApiKeyAuthBindingCreate,
DataSourceApiKeyAuthBindingRecord,
DataSourceApiKeyAuthCredentials,
)
def _request_context() -> RequestContext:
return RequestContext(
request_id="request-1",
trace_id="trace-1",
account_id="account-1",
active_workspace_id="tenant-1",
)
@dataclass(frozen=True)
class _DataSources:
api_key_auth: DataSourceApiKeyAuthService
@dataclass(frozen=True)
class _ApplicationServices:
data_sources: _DataSources
def _application_services(service: DataSourceApiKeyAuthService) -> _ApplicationServices:
return _ApplicationServices(data_sources=_DataSources(api_key_auth=service))
def test_list_data_source_auth_passes_context_and_serializes_application_result() -> None:
api = ApiKeyAuthDataSource()
method = unwrap(api.get)
request_context = _request_context()
service = create_autospec(DataSourceApiKeyAuthService, instance=True, spec_set=True)
service.list_bindings.return_value = (
DataSourceApiKeyAuthBindingRecord(
id="binding-1",
category="api_key",
provider="custom",
disabled=False,
created_at=datetime(2026, 1, 1, tzinfo=UTC),
updated_at=datetime(2026, 1, 2, tzinfo=UTC),
),
)
with patch(
"controllers.console.auth.data_source_bearer_auth.application_services",
return_value=_application_services(service),
):
result = method(api, request_context)
service.list_bindings.assert_called_once_with(request_context)
assert result == {
"sources": [
{
"id": "binding-1",
"category": "api_key",
"provider": "custom",
"disabled": False,
"created_at": 1767225600,
"updated_at": 1767312000,
}
]
}
def test_create_data_source_auth_binding_passes_context_and_command() -> None:
api = ApiKeyAuthDataSourceBinding()
method = unwrap(api.post)
payload = {
"category": "api_key",
"provider": "custom",
"credentials": {
"auth_type": "api_key",
"config": {"api_key": "secret", "base_url": "https://example.com"},
},
}
request_context = _request_context()
req_data = ApiKeyAuthBindingPayload.model_validate(payload)
service = create_autospec(DataSourceApiKeyAuthService, instance=True, spec_set=True)
with patch(
"controllers.console.auth.data_source_bearer_auth.application_services",
return_value=_application_services(service),
):
result, status = method(api, req_data, request_context)
service.create_binding.assert_called_once_with(
request_context,
DataSourceApiKeyAuthBindingCreate(
category="api_key",
provider="custom",
credentials=DataSourceApiKeyAuthCredentials(
"api_key",
"secret",
{"base_url": "https://example.com"},
),
),
)
assert result == {"result": "success"}
assert status == 200
def test_create_data_source_auth_binding_maps_unsupported_provider_to_bad_request() -> None:
api = ApiKeyAuthDataSourceBinding()
method = unwrap(api.post)
request_context = _request_context()
req_data = ApiKeyAuthBindingPayload(
category="api_key",
provider="unsupported",
credentials={"auth_type": "api_key", "config": {"api_key": "secret"}},
)
service = create_autospec(DataSourceApiKeyAuthService, instance=True, spec_set=True)
service.create_binding.side_effect = UnsupportedDataSourceApiKeyAuthProviderError(req_data.provider)
with (
patch(
"controllers.console.auth.data_source_bearer_auth.application_services",
return_value=_application_services(service),
),
pytest.raises(DataSourceApiKeyAuthProviderNotSupportedError) as exc_info,
):
method(api, req_data, request_context)
assert exc_info.value.code == 400
@pytest.mark.parametrize(
("service_error", "request_error", "expected_status"),
[
(
InvalidDataSourceApiKeyAuthCredentialsError("Invalid auth type"),
InvalidDataSourceApiKeyAuthCredentialsRequestError,
400,
),
(
DataSourceApiKeyAuthCredentialValidationError("Credentials rejected"),
DataSourceApiKeyAuthCredentialsRejectedRequestError,
400,
),
(
DataSourceApiKeyAuthProviderUnavailableError("firecrawl"),
DataSourceApiKeyAuthProviderUnavailableRequestError,
502,
),
],
)
def test_create_data_source_auth_binding_maps_domain_errors(
service_error: Exception,
request_error: type[BaseHTTPException],
expected_status: int,
) -> None:
api = ApiKeyAuthDataSourceBinding()
method = unwrap(api.post)
request_context = _request_context()
req_data = ApiKeyAuthBindingPayload(
category="api_key",
provider="firecrawl",
credentials={"auth_type": "bearer", "config": {"api_key": "secret"}},
)
service = create_autospec(DataSourceApiKeyAuthService, instance=True, spec_set=True)
service.create_binding.side_effect = service_error
with (
patch(
"controllers.console.auth.data_source_bearer_auth.application_services",
return_value=_application_services(service),
),
pytest.raises(request_error) as exc_info,
):
method(api, req_data, request_context)
assert exc_info.value.code == expected_status
@pytest.mark.parametrize(
"payload",
[
{"category": "", "provider": "firecrawl", "credentials": {"auth_type": "bearer", "config": {"api_key": "key"}}},
{"category": "api_key", "provider": "", "credentials": {"auth_type": "bearer", "config": {"api_key": "key"}}},
{"category": "api_key", "provider": "firecrawl", "credentials": {"config": {"api_key": "key"}}},
{"category": "api_key", "provider": "firecrawl", "credentials": {"auth_type": "bearer", "config": {}}},
{"category": "api_key", "provider": "firecrawl", "credentials": {"auth_type": "bearer", "config": "invalid"}},
],
)
def test_api_key_auth_binding_payload_rejects_invalid_structure(payload: dict[str, object]) -> None:
with pytest.raises(ValidationError):
ApiKeyAuthBindingPayload.model_validate(payload)
def test_delete_data_source_auth_binding_passes_context_and_binding_id() -> None:
api = ApiKeyAuthDataSourceBindingDelete()
method = unwrap(api.delete)
request_context = _request_context()
binding_id = UUID("31a00aeb-0865-4dd2-952a-5e0de34c57cc")
service = create_autospec(DataSourceApiKeyAuthService, instance=True, spec_set=True)
with patch(
"controllers.console.auth.data_source_bearer_auth.application_services",
return_value=_application_services(service),
):
result, status = method(api, request_context, binding_id)
service.delete_binding.assert_called_once_with(request_context, str(binding_id))
assert result == ""
assert status == 204
@@ -0,0 +1,172 @@
from http import HTTPStatus
from inspect import unwrap
from unittest.mock import MagicMock, create_autospec, patch
from uuid import UUID
from flask import Flask, Response
from controllers.console.auth.data_source_oauth import (
OAuthDataSource,
OAuthDataSourceBinding,
OAuthDataSourceCallback,
OAuthDataSourceSync,
)
from extensions.ext_application_services import ApplicationServices
from machinery.context import RequestContext
from services.data_source.entities.oauth import DataSourceOAuthCallback
from services.data_source.oauth_service import (
DataSourceOAuthError,
InvalidDataSourceOAuthCodeError,
InvalidDataSourceOAuthProviderError,
)
from tests.helpers.unit.config_override import config_overrides_context
def _request_context() -> RequestContext:
return RequestContext(
request_id="request-1",
trace_id=None,
account_id="account-1",
active_workspace_id="workspace-1",
)
def _services(service: MagicMock) -> MagicMock:
services = create_autospec(ApplicationServices, instance=True, spec_set=True)
services.data_sources.resolve_oauth.return_value = service
return services
def test_get_delegates_to_application_service_and_serializes_response() -> None:
service = MagicMock()
service.start_authorization.return_value = "https://notion.example/authorize"
context = _request_context()
with patch(
"controllers.console.auth.data_source_oauth.application_services",
return_value=_services(service),
):
result = unwrap(OAuthDataSource.get)(OAuthDataSource(), context, "notion")
assert result == ({"data": "https://notion.example/authorize"}, HTTPStatus.OK)
service.start_authorization.assert_called_once_with(context)
def test_get_maps_unknown_provider_to_bad_request() -> None:
service = MagicMock()
services = _services(service)
services.data_sources.resolve_oauth.side_effect = InvalidDataSourceOAuthProviderError
with patch(
"controllers.console.auth.data_source_oauth.application_services",
return_value=services,
):
result = unwrap(OAuthDataSource.get)(OAuthDataSource(), _request_context(), "unknown")
assert result == ({"error": "Invalid provider"}, HTTPStatus.BAD_REQUEST)
def test_callback_parses_query_and_returns_flask_redirect() -> None:
app = Flask(__name__)
service = MagicMock()
service.complete_callback.return_value = DataSourceOAuthCallback(provider="notion", code="code-1", error=None)
with (
app.test_request_context("/?code=code-1"),
config_overrides_context(CONSOLE_WEB_URL="https://console.example/root?lang=en#top"),
patch(
"controllers.console.auth.data_source_oauth.application_services",
return_value=_services(service),
),
):
response = OAuthDataSourceCallback().get("notion")
assert isinstance(response, Response)
assert response.status_code == HTTPStatus.FOUND
assert response.location == "https://console.example/root?lang=en&type=notion&code=code-1#top"
service.complete_callback.assert_called_once_with(code="code-1", error=None)
def test_binding_parses_query_and_delegates_with_request_context() -> None:
app = Flask(__name__)
service = MagicMock()
context = _request_context()
with (
app.test_request_context("/?code=code-1"),
patch(
"controllers.console.auth.data_source_oauth.application_services",
return_value=_services(service),
),
):
result = unwrap(OAuthDataSourceBinding.get)(OAuthDataSourceBinding(), context, "notion")
assert result == ({"result": "success"}, HTTPStatus.OK)
service.bind.assert_called_once_with(context, code="code-1")
def test_binding_maps_invalid_code_to_bad_request() -> None:
app = Flask(__name__)
service = MagicMock()
with (
app.test_request_context("/?code="),
patch(
"controllers.console.auth.data_source_oauth.application_services",
return_value=_services(service),
),
):
result = unwrap(OAuthDataSourceBinding.get)(OAuthDataSourceBinding(), _request_context(), "notion")
assert result == ({"error": "Invalid code"}, HTTPStatus.BAD_REQUEST)
service.bind.assert_not_called()
def test_binding_maps_application_code_error_to_bad_request() -> None:
app = Flask(__name__)
service = MagicMock()
service.bind.side_effect = InvalidDataSourceOAuthCodeError
with (
app.test_request_context("/?code=code-1"),
patch(
"controllers.console.auth.data_source_oauth.application_services",
return_value=_services(service),
),
):
result = unwrap(OAuthDataSourceBinding.get)(OAuthDataSourceBinding(), _request_context(), "notion")
assert result == ({"error": "Invalid code"}, HTTPStatus.BAD_REQUEST)
def test_sync_converts_route_uuid_and_delegates() -> None:
service = MagicMock()
context = _request_context()
binding_id = UUID("11111111-1111-1111-1111-111111111111")
with patch(
"controllers.console.auth.data_source_oauth.application_services",
return_value=_services(service),
):
result = unwrap(OAuthDataSourceSync.get)(OAuthDataSourceSync(), context, "notion", binding_id)
assert result == ({"result": "success"}, HTTPStatus.OK)
service.sync.assert_called_once_with(context, binding_id=str(binding_id))
def test_sync_hides_provider_failure_details() -> None:
service = MagicMock()
service.sync.side_effect = DataSourceOAuthError("provider details")
binding_id = UUID("11111111-1111-1111-1111-111111111111")
with (
patch(
"controllers.console.auth.data_source_oauth.application_services",
return_value=_services(service),
),
patch("controllers.console.auth.data_source_oauth.logger.exception") as log_exception,
):
result = unwrap(OAuthDataSourceSync.get)(OAuthDataSourceSync(), _request_context(), "notion", binding_id)
assert result == ({"error": "OAuth data source process failed"}, HTTPStatus.BAD_REQUEST)
log_exception.assert_called_once()
@@ -0,0 +1,323 @@
"""Unit tests for the email-registration Flask adapter."""
from __future__ import annotations
from collections.abc import Callable, Generator
from contextlib import contextmanager
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
import pytest
from flask import Flask
from pydantic import ValidationError
from pytest_mock import MockerFixture
from sqlalchemy.orm import Session, sessionmaker
from controllers.console import bp as console_bp
from controllers.console.auth.email_register import (
EmailRegisterCheckApi,
EmailRegisterResetApi,
EmailRegisterResetPayload,
EmailRegisterSendEmailApi,
)
from controllers.console.auth.error import (
EmailAlreadyInUseError,
EmailCodeError,
EmailRegisterLimitError,
EmailRegisterRateLimitExceededError,
InvalidEmailError,
InvalidTokenError,
NormalizedEmailAlreadyInUseError,
PasswordMismatchError,
)
from controllers.console.error import (
AccountInFreezeError,
EmailDomainSuspendedError,
EmailSendIpLimitError,
SeatsLimitExceeded,
)
from enums import DeploymentEdition
from extensions.ext_application_services import build_application_services
from extensions.ext_redis import RedisClientWrapper
from services.account.email_registration_service import AccountEmailRegistrationService
from services.account_errors import (
AccountEmailAlreadyInUseError,
AccountEmailDomainSuspendedError,
AccountEmailFrozenError,
AccountNormalizedEmailAlreadyInUseError,
EmailRegistrationPasswordMismatchError,
EmailRegistrationSeatsLimitError,
EmailRegistrationSendIPLimitedError,
EmailRegistrationSendRateLimitError,
EmailRegistrationVerificationLimitError,
InvalidEmailRegistrationAddressError,
InvalidEmailRegistrationCodeError,
InvalidEmailRegistrationTokenError,
)
from services.entities.account_entities import AccountEmailRegistrationVerification, AccountSessionTokens
@pytest.fixture(autouse=True)
def _cloud_edition(config_overrides: Callable[..., None]) -> None:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
@contextmanager
def _request(
app: Flask,
service: AccountEmailRegistrationService,
*,
path: str,
payload: dict[str, str],
) -> Generator[None]:
services = SimpleNamespace(accounts=SimpleNamespace(email_registration=service))
with (
patch("controllers.console.auth.email_register.application_services", return_value=services),
patch(
"controllers.console.flask_admission.SystemFeatureService.is_email_password_login_enabled",
return_value=True,
),
patch(
"controllers.console.flask_admission.SystemFeatureService.is_registration_allowed",
return_value=True,
),
patch("controllers.console.auth.email_register.extract_remote_ip", return_value="127.0.0.1"),
app.test_request_context(path, method="POST", json=payload),
):
yield
@pytest.fixture
def service(
sqlite_session_factory: sessionmaker[Session],
redis_transport: tuple[RedisClientWrapper, MagicMock],
mocker: MockerFixture,
) -> AccountEmailRegistrationService:
service = build_application_services(
database_client=sqlite_session_factory,
deployment_edition=DeploymentEdition.COMMUNITY,
initialization_password="",
redis=redis_transport[0],
).accounts.email_registration
mocker.patch.object(service, "send_code")
mocker.patch.object(service, "verify_code")
mocker.patch.object(service, "register")
return service
def test_normalized_email_conflict_exposes_a_distinct_error_code() -> None:
error = NormalizedEmailAlreadyInUseError()
assert error.code == 400
assert error.data is not None
assert error.data["code"] == "normalized_email_already_in_use"
def test_send_email_delegates_with_remote_ip(app: Flask, service: AccountEmailRegistrationService) -> None:
service.send_code.return_value = "token-123"
with _request(
app,
service,
path="/email-register/send-email",
payload={"email": "Invitee@Example.com", "language": "zh-Hans"},
):
response = EmailRegisterSendEmailApi().post()
assert response == {"result": "success", "data": "token-123"}
assert service.send_code.call_args.kwargs == {
"remote_ip": "127.0.0.1",
"requested_email": "Invitee@Example.com",
"requested_language": "zh-Hans",
}
@pytest.mark.parametrize(
("service_error", "http_error"),
[
pytest.param(EmailRegistrationSendIPLimitedError(), EmailSendIpLimitError, id="ip-limit"),
pytest.param(EmailRegistrationSendRateLimitError(1), EmailRegisterRateLimitExceededError, id="send-limit"),
pytest.param(AccountEmailFrozenError(), AccountInFreezeError, id="frozen"),
pytest.param(AccountEmailDomainSuspendedError(), EmailDomainSuspendedError, id="suspended-domain"),
],
)
def test_send_email_translates_application_errors(
app: Flask,
service: AccountEmailRegistrationService,
service_error: Exception,
http_error: type[Exception],
) -> None:
service.send_code.side_effect = service_error
with _request(
app,
service,
path="/email-register/send-email",
payload={"email": "invitee@example.com"},
):
with pytest.raises(http_error):
EmailRegisterSendEmailApi().post()
def test_verify_email_code_serializes_application_result(app: Flask, service: AccountEmailRegistrationService) -> None:
service.verify_code.return_value = AccountEmailRegistrationVerification(
email="user@example.com",
token="verified-token",
)
with _request(
app,
service,
path="/email-register/validity",
payload={"email": "User@Example.com", "code": "123456", "token": "pending-token"},
):
response = EmailRegisterCheckApi().post()
assert response == {"is_valid": True, "email": "user@example.com", "token": "verified-token"}
service.verify_code.assert_called_once_with(
email="User@Example.com",
code="123456",
token="pending-token",
)
@pytest.mark.parametrize(
("service_error", "http_error"),
[
pytest.param(EmailRegistrationVerificationLimitError(), EmailRegisterLimitError, id="attempt-limit"),
pytest.param(InvalidEmailRegistrationTokenError(), InvalidTokenError, id="token"),
pytest.param(InvalidEmailRegistrationAddressError(), InvalidEmailError, id="email"),
pytest.param(InvalidEmailRegistrationCodeError(), EmailCodeError, id="code"),
],
)
def test_verify_email_code_translates_application_errors(
app: Flask,
service: AccountEmailRegistrationService,
service_error: Exception,
http_error: type[Exception],
) -> None:
service.verify_code.side_effect = service_error
with _request(
app,
service,
path="/email-register/validity",
payload={"email": "user@example.com", "code": "wrong", "token": "pending-token"},
):
with pytest.raises(http_error):
EmailRegisterCheckApi().post()
def test_register_delegates_and_serializes_tokens(app: Flask, service: AccountEmailRegistrationService) -> None:
service.register.return_value = AccountSessionTokens(
access_token="access",
refresh_token="refresh",
csrf_token="csrf",
)
with _request(
app,
service,
path="/email-register",
payload={
"token": "verified-token",
"new_password": "ValidPass123!",
"password_confirm": "ValidPass123!",
"language": "zh-Hans",
"timezone": "Asia/Shanghai",
},
):
response = EmailRegisterResetApi().post()
assert response == {
"result": "success",
"data": {"access_token": "access", "refresh_token": "refresh", "csrf_token": "csrf"},
}
assert service.register.call_args.kwargs == {
"remote_ip": "127.0.0.1",
"token": "verified-token",
"new_password": "ValidPass123!",
"password_confirm": "ValidPass123!",
"language": "zh-Hans",
"timezone": "Asia/Shanghai",
}
@pytest.mark.parametrize(
("service_error", "http_error"),
[
pytest.param(EmailRegistrationPasswordMismatchError(), PasswordMismatchError, id="password"),
pytest.param(InvalidEmailRegistrationTokenError(), InvalidTokenError, id="token"),
pytest.param(
AccountNormalizedEmailAlreadyInUseError(),
NormalizedEmailAlreadyInUseError,
id="normalized-email-in-use",
),
pytest.param(AccountEmailAlreadyInUseError(), EmailAlreadyInUseError, id="email-in-use"),
pytest.param(EmailRegistrationSeatsLimitError(), SeatsLimitExceeded, id="seat-limit"),
pytest.param(AccountEmailFrozenError(), AccountInFreezeError, id="frozen"),
pytest.param(AccountEmailDomainSuspendedError(), EmailDomainSuspendedError, id="suspended-domain"),
],
)
def test_register_translates_application_errors(
app: Flask,
service: AccountEmailRegistrationService,
service_error: Exception,
http_error: type[Exception],
) -> None:
service.register.side_effect = service_error
with _request(
app,
service,
path="/email-register",
payload={
"token": "verified-token",
"new_password": "ValidPass123!",
"password_confirm": "ValidPass123!",
},
):
with pytest.raises(http_error):
EmailRegisterResetApi().post()
def test_reset_payload_rejects_invalid_timezone() -> None:
with pytest.raises(ValidationError):
EmailRegisterResetPayload.model_validate(
{
"token": "token-123",
"new_password": "ValidPass123!",
"password_confirm": "ValidPass123!",
"timezone": "",
}
)
def test_invalid_password_is_sanitized_by_real_error_handler(caplog: pytest.LogCaptureFixture) -> None:
app = Flask(__name__)
app.config["TESTING"] = True
app.register_blueprint(console_bp)
password_marker = "SecretMarker"
with (
patch(
"controllers.console.flask_admission.SystemFeatureService.is_email_password_login_enabled",
return_value=True,
),
patch(
"controllers.console.flask_admission.SystemFeatureService.is_registration_allowed",
return_value=True,
),
):
response = app.test_client().post(
"/console/api/email-register",
json={
"token": "verified-token",
"new_password": password_marker,
"password_confirm": password_marker,
},
)
assert response.status_code == 422
assert password_marker not in response.get_data(as_text=True)
assert password_marker not in caplog.text
@@ -0,0 +1,235 @@
"""Transport-boundary tests for Console forgot-password endpoints."""
from __future__ import annotations
from types import SimpleNamespace
import pytest
from flask import Flask
from controllers.console.auth import forgot_password
from controllers.console.auth.error import (
EmailCodeError,
EmailPasswordResetLimitError,
InvalidEmailError,
InvalidTokenError,
PasswordMismatchError,
PasswordResetRateLimitExceededError,
)
from controllers.console.error import AccountNotFound, EmailSendIpLimitError
from enums import DeploymentEdition
from services import account_errors
from services.entities.account_entities import ForgotPasswordVerification
from tests.helpers.unit.config_override import apply_config_overrides
class FakeForgotPasswordService:
def __init__(self) -> None:
self.error: Exception | None = None
self.send_arguments: dict[str, str] | None = None
self.verify_arguments: dict[str, str] | None = None
self.reset_arguments: dict[str, str] | None = None
def _raise_if_needed(self) -> None:
if self.error is not None:
raise self.error
def send_code(
self,
*,
email: str,
language: str,
ip_address: str,
) -> str:
self.send_arguments = {"email": email, "language": language, "ip_address": ip_address}
self._raise_if_needed()
return "reset-token"
def verify_code(
self,
*,
email: str,
code: str,
token: str,
) -> ForgotPasswordVerification:
self.verify_arguments = {"email": email, "code": code, "token": token}
self._raise_if_needed()
return ForgotPasswordVerification(email="user@example.com", token="promoted-token")
def reset(
self,
*,
token: str,
new_password: str,
password_confirm: str,
) -> None:
self.reset_arguments = {
"token": token,
"new_password": new_password,
"password_confirm": password_confirm,
}
self._raise_if_needed()
@pytest.fixture(autouse=True)
def admit_forgot_password_requests(monkeypatch: pytest.MonkeyPatch) -> None:
apply_config_overrides(
monkeypatch,
DEPLOYMENT_EDITION=DeploymentEdition.CLOUD,
ENABLE_EMAIL_PASSWORD_LOGIN=True,
)
@pytest.fixture
def service(monkeypatch: pytest.MonkeyPatch) -> FakeForgotPasswordService:
service = FakeForgotPasswordService()
services = SimpleNamespace(accounts=SimpleNamespace(forgot_password=service))
monkeypatch.setattr(forgot_password, "application_services", lambda: services)
monkeypatch.setattr(forgot_password, "extract_remote_ip", lambda _request: "127.0.0.1")
return service
def test_send_parses_input_and_serializes_service_result(app: Flask, service: FakeForgotPasswordService) -> None:
with app.test_request_context(
"/forgot-password",
method="POST",
json={"email": "User@Example.com", "language": "zh-Hans"},
):
response = forgot_password.ForgotPasswordSendEmailApi().post()
assert response == {"result": "success", "data": "reset-token"}
assert service.send_arguments == {
"email": "User@Example.com",
"language": "zh-Hans",
"ip_address": "127.0.0.1",
}
def test_send_defaults_unsupported_language(app: Flask, service: FakeForgotPasswordService) -> None:
with app.test_request_context(
"/forgot-password",
method="POST",
json={"email": "user@example.com", "language": "fr-FR"},
):
forgot_password.ForgotPasswordSendEmailApi().post()
assert service.send_arguments is not None
assert service.send_arguments["language"] == "en-US"
@pytest.mark.parametrize(
("service_error", "request_error"),
[
(account_errors.ForgotPasswordSendIPLimitedError(), EmailSendIpLimitError),
(account_errors.ForgotPasswordSendRateLimitError(2), PasswordResetRateLimitExceededError),
],
)
def test_send_maps_application_errors(
app: Flask,
service: FakeForgotPasswordService,
service_error: Exception,
request_error: type[Exception],
) -> None:
service.error = service_error
with (
app.test_request_context(
"/forgot-password",
method="POST",
json={"email": "user@example.com"},
),
pytest.raises(request_error),
):
forgot_password.ForgotPasswordSendEmailApi().post()
def test_verify_serializes_promoted_token(app: Flask, service: FakeForgotPasswordService) -> None:
with app.test_request_context(
"/forgot-password/validity",
method="POST",
json={"email": "USER@example.com", "code": "123456", "token": "verification-token"},
):
response = forgot_password.ForgotPasswordCheckApi().post()
assert response == {"is_valid": True, "email": "user@example.com", "token": "promoted-token"}
assert service.verify_arguments == {
"email": "USER@example.com",
"code": "123456",
"token": "verification-token",
}
@pytest.mark.parametrize(
("service_error", "request_error"),
[
(account_errors.ForgotPasswordVerificationLimitError(), EmailPasswordResetLimitError),
(account_errors.InvalidForgotPasswordTokenError(), InvalidTokenError),
(account_errors.InvalidForgotPasswordEmailError(), InvalidEmailError),
(account_errors.InvalidForgotPasswordCodeError(), EmailCodeError),
],
)
def test_verify_maps_application_errors(
app: Flask,
service: FakeForgotPasswordService,
service_error: Exception,
request_error: type[Exception],
) -> None:
service.error = service_error
with (
app.test_request_context(
"/forgot-password/validity",
method="POST",
json={"email": "user@example.com", "code": "123456", "token": "token"},
),
pytest.raises(request_error),
):
forgot_password.ForgotPasswordCheckApi().post()
def test_reset_delegates_and_serializes_result(app: Flask, service: FakeForgotPasswordService) -> None:
with app.test_request_context(
"/forgot-password/resets",
method="POST",
json={
"token": "reset-token",
"new_password": "ValidPass123!",
"password_confirm": "ValidPass123!",
},
):
response = forgot_password.ForgotPasswordResetApi().post()
assert response == {"result": "success"}
assert service.reset_arguments == {
"token": "reset-token",
"new_password": "ValidPass123!",
"password_confirm": "ValidPass123!",
}
@pytest.mark.parametrize(
("service_error", "request_error"),
[
(account_errors.ForgotPasswordMismatchError(), PasswordMismatchError),
(account_errors.InvalidForgotPasswordTokenError(), InvalidTokenError),
(account_errors.AccountNotFoundError(), AccountNotFound),
],
)
def test_reset_maps_application_errors(
app: Flask,
service: FakeForgotPasswordService,
service_error: Exception,
request_error: type[Exception],
) -> None:
service.error = service_error
with (
app.test_request_context(
"/forgot-password/resets",
method="POST",
json={
"token": "reset-token",
"new_password": "ValidPass123!",
"password_confirm": "ValidPass123!",
},
),
pytest.raises(request_error),
):
forgot_password.ForgotPasswordResetApi().post()
@@ -0,0 +1,447 @@
"""Transport-boundary tests for Console authentication endpoints."""
from __future__ import annotations
import base64
from collections.abc import Callable
from dataclasses import dataclass, field
from types import SimpleNamespace
from typing import Never
import pytest
from flask import Flask, Response
from controllers.console import wraps
from controllers.console.auth import login
from controllers.console.auth.error import (
AuthenticationFailedError,
EmailCodeError,
EmailCodeLoginRateLimitExceededError,
EmailCodeLoginServiceUnavailableError,
EmailPasswordLoginLimitError,
InvalidEmailError,
InvalidTokenError,
NormalizedEmailAlreadyInUseError,
PasswordResetRateLimitExceededError,
TurnstileServiceUnavailableError,
TurnstileVerificationFailedError,
)
from controllers.console.error import (
AccountBannedError,
AccountInFreezeError,
AccountNotFound,
EmailDomainSuspendedError,
EmailSendIpLimitError,
InvalidAccountPasswordRequestError,
NotAllowedCreateWorkspace,
SeatsLimitExceeded,
WorkspacesLimitExceeded,
)
from enums import DeploymentEdition
from services import account_errors
from services.entities.account_entities import AccountSessionTokens
from services.entities.account_login_entities import (
EmailCodeLoginCommand,
EmailCodeSendCommand,
PasswordLoginCommand,
PasswordLoginResult,
)
from tests.helpers.unit.controllers.knowledge_fs_controller_fakes import narrowed
TEST_TOKEN = "00000000-0000-4000-8000-000000000001"
TOKENS = AccountSessionTokens(access_token="access-token", refresh_token="refresh-token", csrf_token="csrf-token")
@dataclass
class FakeAuthenticationService:
error: account_errors.AccountApplicationError | None = None
password_commands: list[PasswordLoginCommand] = field(default_factory=list)
email_code_send_commands: list[EmailCodeSendCommand] = field(default_factory=list)
email_code_login_commands: list[EmailCodeLoginCommand] = field(default_factory=list)
reset_arguments: list[tuple[str, str | None, str]] = field(default_factory=list)
logout_account_ids: list[str] = field(default_factory=list)
refresh_tokens: list[str] = field(default_factory=list)
workspace_found: bool = True
def _raise_if_needed(self) -> None:
if self.error is not None:
raise self.error
def login_with_password(self, command: PasswordLoginCommand) -> PasswordLoginResult:
self.password_commands.append(command)
self._raise_if_needed()
return PasswordLoginResult(
tokens=TOKENS if self.workspace_found else None,
workspace_found=self.workspace_found,
)
def logout(self, account_id: str) -> None:
self.logout_account_ids.append(account_id)
def send_reset_password_email(self, *, email: str, language: str | None, ip_address: str) -> str:
self.reset_arguments.append((email, language, ip_address))
self._raise_if_needed()
return "reset-token"
def send_email_code(self, command: EmailCodeSendCommand) -> str:
self.email_code_send_commands.append(command)
self._raise_if_needed()
return "email-code-token"
def login_with_email_code(self, command: EmailCodeLoginCommand) -> AccountSessionTokens:
self.email_code_login_commands.append(command)
self._raise_if_needed()
return TOKENS
def refresh(self, refresh_token: str) -> AccountSessionTokens:
self.refresh_tokens.append(refresh_token)
self._raise_if_needed()
return TOKENS
@pytest.fixture(autouse=True)
def admit_authentication_requests(
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
) -> None:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.CLOUD)
monkeypatch.setattr(wraps.SystemFeatureService, "is_email_password_login_enabled", lambda: True)
@pytest.fixture
def service(monkeypatch: pytest.MonkeyPatch) -> FakeAuthenticationService:
service = FakeAuthenticationService()
services = SimpleNamespace(accounts=SimpleNamespace(authentication=service))
monkeypatch.setattr(login, "application_services", lambda: services)
monkeypatch.setattr(login, "extract_remote_ip", lambda _request: "127.0.0.1")
return service
def _encode(value: str) -> str:
return base64.b64encode(value.encode()).decode()
def test_password_login_parses_input_and_serializes_cookies(
app: Flask,
service: FakeAuthenticationService,
) -> None:
with app.test_request_context(
"/login",
method="POST",
json={
"email": "User@Example.com",
"password": _encode("password"),
"invite_token": "invite-token",
},
):
response = narrowed(login.LoginApi().post(), Response)
assert response.json == {"result": "success", "data": None}
assert service.password_commands == [
PasswordLoginCommand(
email="User@Example.com",
password="password",
invite_token="invite-token",
ip_address="127.0.0.1",
)
]
cookies = response.headers.getlist("Set-Cookie")
assert any("access_token=" in cookie for cookie in cookies)
assert any("refresh_token=" in cookie for cookie in cookies)
assert any("csrf_token=" in cookie for cookie in cookies)
def test_password_login_serializes_missing_workspace(
app: Flask,
service: FakeAuthenticationService,
) -> None:
service.workspace_found = False
with app.test_request_context(
"/login",
method="POST",
json={"email": "user@example.com", "password": _encode("password")},
):
response = narrowed(login.LoginApi().post(), dict)
assert response["result"] == "fail"
assert "workspace not found" in response["data"]
def test_invitation_login_with_empty_password_returns_authentication_failure(
app: Flask,
service: FakeAuthenticationService,
) -> None:
service.error = account_errors.InvalidLoginCredentialsError()
with app.test_request_context(
"/login",
method="POST",
json={"email": "user@example.com", "password": _encode(""), "invite_token": "invite-token"},
):
with pytest.raises(AuthenticationFailedError):
login.LoginApi().post()
assert service.password_commands == [
PasswordLoginCommand(
email="user@example.com",
password="",
invite_token="invite-token",
ip_address="127.0.0.1",
)
]
def test_invitation_login_with_weak_password_returns_policy_failure(
app: Flask,
service: FakeAuthenticationService,
) -> None:
service.error = account_errors.InvalidAccountPasswordError("Password must contain letters and numbers")
with app.test_request_context(
"/login",
method="POST",
json={"email": "user@example.com", "password": _encode("letters-only"), "invite_token": "invite-token"},
):
with pytest.raises(InvalidAccountPasswordRequestError, match="letters and numbers"):
login.LoginApi().post()
def test_reset_password_delegates_transport_values(app: Flask, service: FakeAuthenticationService) -> None:
with app.test_request_context(
"/reset-password",
method="POST",
json={"email": "User@Example.com", "language": "zh-Hans"},
):
response = login.ResetPasswordSendEmailApi().post()
assert response == {"result": "success", "data": "reset-token"}
assert service.reset_arguments == [("User@Example.com", "zh-Hans", "127.0.0.1")]
def test_email_code_send_delegates_validated_command(app: Flask, service: FakeAuthenticationService) -> None:
with app.test_request_context(
"/email-code-login",
method="POST",
json={"email": "user@example.com", "turnstile_token": "challenge"},
):
response = login.EmailCodeLoginSendEmailApi().post()
assert response == {"result": "success", "data": "email-code-token"}
assert service.email_code_send_commands == [
EmailCodeSendCommand(
email="user@example.com",
language=None,
turnstile_token="challenge",
ip_address="127.0.0.1",
)
]
def test_email_code_login_decodes_code_and_serializes_tokens(
app: Flask,
service: FakeAuthenticationService,
) -> None:
with app.test_request_context(
"/email-code-login/validity",
method="POST",
json={
"email": "User@Example.com",
"code": _encode("123456"),
"token": TEST_TOKEN,
"timezone": "Asia/Singapore",
},
):
response = login.EmailCodeLoginApi().post()
assert response.json == {"result": "success"}
assert service.email_code_login_commands == [
EmailCodeLoginCommand(
email="User@Example.com",
code="123456",
token=TEST_TOKEN,
turnstile_token=None,
language=None,
timezone="Asia/Singapore",
ip_address="127.0.0.1",
)
]
def test_logout_uses_optional_current_account(
app: Flask,
service: FakeAuthenticationService,
monkeypatch: pytest.MonkeyPatch,
) -> None:
logout_calls: list[bool] = []
monkeypatch.setattr(login.flask_login, "logout_user", lambda: logout_calls.append(True))
monkeypatch.setattr(
login,
"current_account_with_tenant_optional",
lambda: (SimpleNamespace(id="account-1"), "workspace-1"),
)
with app.test_request_context("/logout", method="POST"):
response = login.LogoutApi().post()
assert response.json == {"result": "success"}
assert service.logout_account_ids == ["account-1"]
assert logout_calls == [True]
def test_logout_clears_cookies_without_current_account(
app: Flask,
service: FakeAuthenticationService,
monkeypatch: pytest.MonkeyPatch,
) -> None:
logout_calls: list[bool] = []
monkeypatch.setattr(login.flask_login, "logout_user", lambda: logout_calls.append(True))
monkeypatch.setattr(login, "current_account_with_tenant_optional", lambda: (None, None))
with app.test_request_context("/logout", method="POST"):
response = login.LogoutApi().post()
assert response.json == {"result": "success"}
assert service.logout_account_ids == []
assert logout_calls == []
cookies = response.headers.getlist("Set-Cookie")
assert any("access_token=" in cookie for cookie in cookies)
assert any("refresh_token=" in cookie for cookie in cookies)
assert any("csrf_token=" in cookie for cookie in cookies)
def test_refresh_maps_invalid_session_to_unauthorized(
app: Flask,
service: FakeAuthenticationService,
monkeypatch: pytest.MonkeyPatch,
) -> None:
service.error = account_errors.InvalidRefreshTokenError("Invalid refresh token")
monkeypatch.setattr(login, "extract_refresh_token", lambda _request: "bad-token")
with app.test_request_context("/refresh-token", method="POST"):
response, status = narrowed(login.RefreshTokenApi().post(), tuple)
assert status == 401
assert response == {"result": "fail", "message": "Invalid refresh token"}
def test_refresh_rejects_missing_cookie(
app: Flask,
service: FakeAuthenticationService,
monkeypatch: pytest.MonkeyPatch,
) -> None:
monkeypatch.setattr(login, "extract_refresh_token", lambda _request: None)
with app.test_request_context("/refresh-token", method="POST"):
response, status = narrowed(login.RefreshTokenApi().post(), tuple)
assert status == 401
assert response["message"] == "No refresh token provided"
assert service.refresh_tokens == []
def test_refresh_does_not_require_completed_setup(
app: Flask,
service: FakeAuthenticationService,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
) -> None:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.COMMUNITY)
monkeypatch.setattr(wraps, "_is_setup_completed", lambda: False)
monkeypatch.setattr(login, "extract_refresh_token", lambda _request: "old-refresh")
with app.test_request_context("/refresh-token", method="POST"):
response = narrowed(login.RefreshTokenApi().post(), Response)
assert response.json == {"result": "success"}
assert service.refresh_tokens == ["old-refresh"]
@pytest.mark.parametrize(
("translate", "application_error", "request_error"),
[
(
login._raise_account_state_error,
account_errors.AccountEmailDomainSuspendedError(),
EmailDomainSuspendedError,
),
(login._raise_account_state_error, account_errors.AccountEmailFrozenError(), AccountInFreezeError),
(login._raise_account_state_error, account_errors.LoginAccountBannedError(), AccountBannedError),
(login._raise_password_login_error, account_errors.LoginRateLimitError(), EmailPasswordLoginLimitError),
(login._raise_password_login_error, account_errors.InvalidLoginCredentialsError(), AuthenticationFailedError),
(
login._raise_password_login_error,
account_errors.InvalidAccountPasswordError("invalid password"),
InvalidAccountPasswordRequestError,
),
(login._raise_password_login_error, account_errors.InvalidLoginInvitationEmailError(), InvalidEmailError),
(login._raise_password_login_error, account_errors.LoginWorkspaceLimitError(), WorkspacesLimitExceeded),
(login._raise_password_login_error, account_errors.AccountNotFoundError(), AccountNotFound),
(
login._raise_reset_password_email_error,
account_errors.ResetPasswordEmailRateLimitError(1),
PasswordResetRateLimitExceededError,
),
(login._raise_email_code_send_error, account_errors.EmailCodeSendIPLimitedError(), EmailSendIpLimitError),
(
login._raise_email_code_send_error,
account_errors.EmailCodeSendRateLimitError(5),
EmailCodeLoginRateLimitExceededError,
),
(
login._raise_email_code_send_error,
account_errors.HumanVerificationRejectedError(),
TurnstileVerificationFailedError,
),
(
login._raise_email_code_send_error,
account_errors.HumanVerificationUnavailableError(),
TurnstileServiceUnavailableError,
),
(
login._raise_email_code_send_error,
account_errors.EmailCodeLoginUnavailableError(),
EmailCodeLoginServiceUnavailableError,
),
(login._raise_email_code_login_error, account_errors.InvalidEmailCodeTokenError(), InvalidTokenError),
(login._raise_email_code_login_error, account_errors.EmailCodeEmailMismatchError(), InvalidEmailError),
(login._raise_email_code_login_error, account_errors.InvalidEmailCodeError(), EmailCodeError),
(
login._raise_email_code_login_error,
account_errors.HumanVerificationRejectedError(),
TurnstileVerificationFailedError,
),
(
login._raise_email_code_login_error,
account_errors.EmailCodeLoginUnavailableError(),
EmailCodeLoginServiceUnavailableError,
),
(login._raise_email_code_login_error, account_errors.AccountNotFoundError(), AccountNotFound),
(login._raise_email_code_login_error, account_errors.LoginWorkspaceLimitError(), WorkspacesLimitExceeded),
(
login._raise_email_code_login_error,
account_errors.LoginWorkspaceCreationNotAllowedError(),
NotAllowedCreateWorkspace,
),
(login._raise_email_code_login_error, account_errors.LoginSeatLimitError(), SeatsLimitExceeded),
(
login._raise_email_code_login_error,
account_errors.AccountNormalizedEmailAlreadyInUseError(),
NormalizedEmailAlreadyInUseError,
),
# Every flow-specific translator falls back to the shared account-state mapping.
(login._raise_email_code_login_error, account_errors.AccountEmailFrozenError(), AccountInFreezeError),
],
)
def test_maps_application_errors_to_transport_errors(
translate: Callable[[account_errors.AccountApplicationError], Never],
application_error: account_errors.AccountApplicationError,
request_error: type[Exception],
) -> None:
with pytest.raises(request_error):
translate(application_error)
def test_flow_translators_only_map_what_their_flow_raises() -> None:
"""A reset-password error cannot reach the password login flow, so it passes through unmapped."""
error = account_errors.ResetPasswordEmailRateLimitError(1)
with pytest.raises(account_errors.ResetPasswordEmailRateLimitError) as raised:
login._raise_password_login_error(error)
assert raised.value is error
@@ -0,0 +1,305 @@
from collections.abc import Callable
from dataclasses import dataclass, field
from types import SimpleNamespace
from typing import NoReturn
import pytest
from flask import Flask
from werkzeug.exceptions import Forbidden, UnprocessableEntity
from werkzeug.wrappers import Response
from controllers.console import wraps as console_wraps
from controllers.console.auth import oauth as oauth_controller
from controllers.console.auth.oauth import OAuthCallback, OAuthLogin
from enums import DeploymentEdition
from libs.oauth import encode_oauth_state
from services.account_errors import (
InvalidOAuthProviderError,
OAuthIdentityLockUnavailableError,
OAuthInvitationAccountMismatchError,
OAuthProviderRequestError,
OAuthRegistrationError,
)
from services.entities.account_entities import AccountSessionTokens
from services.entities.account_oauth_entities import (
OAuthAuthorizationRequest,
OAuthCallbackCommand,
OAuthCallbackResult,
OAuthInvitationResult,
OAuthSignInResult,
)
from services.system_feature_service import SystemFeatureService
from tests.helpers.unit.controllers.knowledge_fs_controller_fakes import narrowed
CONSOLE_WEB_URL = "https://console.example.com"
@dataclass
class FakeOAuthService:
authorization_url: str = "https://provider.example/authorize"
callback_result: OAuthCallbackResult = OAuthSignInResult(
tokens=AccountSessionTokens("access-token", "refresh-token", "csrf-token"),
oauth_new_user=False,
)
authorization_error: Exception | None = None
callback_error: Exception | None = None
authorization_calls: list[tuple[str, OAuthAuthorizationRequest]] = field(default_factory=list)
callback_calls: list[OAuthCallbackCommand] = field(default_factory=list)
def start_authorization(self, provider: str, request: OAuthAuthorizationRequest) -> str:
self.authorization_calls.append((provider, request))
if self.authorization_error is not None:
raise self.authorization_error
return self.authorization_url
def complete_authorization(self, command: OAuthCallbackCommand) -> OAuthCallbackResult:
self.callback_calls.append(command)
if self.callback_error is not None:
raise self.callback_error
return self.callback_result
@pytest.fixture(autouse=True)
def _oauth_admission(
config_overrides: Callable[..., None],
) -> None:
config_overrides(
DEPLOYMENT_EDITION=DeploymentEdition.CLOUD,
ENABLE_SOCIAL_OAUTH_LOGIN=True,
CONSOLE_WEB_URL=CONSOLE_WEB_URL,
)
def _install_service(monkeypatch: pytest.MonkeyPatch, service: FakeOAuthService) -> None:
services = SimpleNamespace(accounts=SimpleNamespace(oauth=service))
monkeypatch.setattr(oauth_controller, "application_services", lambda: services)
def test_login_parses_input_and_delegates_to_application_service(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
) -> None:
service = FakeOAuthService()
_install_service(monkeypatch, service)
with app.test_request_context(
"/oauth/login/github?invite_token=invite&timezone=Asia%2FShanghai&language=zh-Hans&redirect_url=%2Fapps"
):
response = narrowed(OAuthLogin().get("github"), Response)
assert response.status_code == 302
assert response.headers["Location"] == "https://provider.example/authorize"
assert service.authorization_calls == [
(
"github",
OAuthAuthorizationRequest(
invite_token="invite",
timezone="Asia/Shanghai",
language="zh-Hans",
redirect_url="/apps",
),
)
]
def test_login_returns_adapter_error_for_unknown_provider(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
) -> None:
service = FakeOAuthService(authorization_error=InvalidOAuthProviderError())
_install_service(monkeypatch, service)
with app.test_request_context("/oauth/login/unknown"):
payload, status = narrowed(OAuthLogin().get("unknown"), tuple)
assert status == 400
assert payload == {"error": "Invalid provider"}
def test_oauth_admission_does_not_query_enterprise_features(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
) -> None:
config_overrides(DEPLOYMENT_EDITION=DeploymentEdition.ENTERPRISE)
monkeypatch.setattr(console_wraps, "_is_setup_completed", lambda: True)
service = FakeOAuthService()
_install_service(monkeypatch, service)
def unexpected_feature_query() -> NoReturn:
raise AssertionError("OAuth admission must not query Enterprise features")
monkeypatch.setattr(SystemFeatureService, "get_license", unexpected_feature_query)
with app.test_request_context("/oauth/login/github"):
response = narrowed(OAuthLogin().get("github"), Response)
assert response.status_code == 302
assert service.authorization_calls
def test_callback_passes_stable_values_and_serializes_session_cookies(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
) -> None:
service = FakeOAuthService()
_install_service(monkeypatch, service)
cookie_calls: list[tuple[str, str]] = []
monkeypatch.setattr(oauth_controller, "extract_remote_ip", lambda _request: "203.0.113.10")
monkeypatch.setattr(
oauth_controller,
"set_access_token_to_cookie",
lambda _request, _response, token: cookie_calls.append(("access", token)),
)
monkeypatch.setattr(
oauth_controller,
"set_refresh_token_to_cookie",
lambda _request, _response, token: cookie_calls.append(("refresh", token)),
)
monkeypatch.setattr(
oauth_controller,
"set_csrf_token_to_cookie",
lambda _request, _response, token: cookie_calls.append(("csrf", token)),
)
state = encode_oauth_state(
invite_token="invite",
timezone="Asia/Shanghai",
language="zh-Hans",
redirect_url="/apps",
)
with app.test_request_context(
f"/oauth/authorize/github?code=code-1&state={state}",
headers={"Accept-Language": "en-US,en;q=0.9"},
):
response = narrowed(OAuthCallback().get("github"), Response)
assert response.status_code == 302
assert response.headers["Location"] == "/apps?oauth_new_user=false"
assert service.callback_calls == [
OAuthCallbackCommand(
provider="github",
code="code-1",
invite_token="invite",
timezone="Asia/Shanghai",
language="zh-Hans",
browser_language="en-US",
ip_address="203.0.113.10",
)
]
assert cookie_calls == [
("access", "access-token"),
("refresh", "refresh-token"),
("csrf", "csrf-token"),
]
@pytest.mark.parametrize(
("redirect_url", "expected"),
[
("https://console.example.com/apps", "https://console.example.com/apps?oauth_new_user=false"),
("https://console.example.com.malicious.example/apps", f"{CONSOLE_WEB_URL}?oauth_new_user=false"),
("//malicious.example.com/apps", f"{CONSOLE_WEB_URL}?oauth_new_user=false"),
("///malicious.example.com/apps", f"{CONSOLE_WEB_URL}?oauth_new_user=false"),
(r"\\malicious.example.com/apps", f"{CONSOLE_WEB_URL}?oauth_new_user=false"),
],
)
def test_callback_serializes_safe_redirect_target(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
redirect_url: str,
expected: str,
) -> None:
service = FakeOAuthService()
_install_service(monkeypatch, service)
state = encode_oauth_state(redirect_url=redirect_url)
with app.test_request_context(f"/oauth/authorize/github?code=code-1&state={state}"):
response = narrowed(OAuthCallback().get("github"), Response)
assert response.headers["Location"] == expected
def test_callback_serializes_invitation_completion_target(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
) -> None:
tokens = AccountSessionTokens("access-token", "refresh-token", "csrf-token")
service = FakeOAuthService(callback_result=OAuthInvitationResult(tokens=tokens, invite_token="invite token"))
_install_service(monkeypatch, service)
with app.test_request_context("/oauth/authorize/github?code=code-1"):
response = narrowed(OAuthCallback().get("github"), Response)
assert response.headers["Location"] == f"{CONSOLE_WEB_URL}/signin/invite-settings?invite_token=invite+token"
def test_callback_rejects_missing_code_before_service_call(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
) -> None:
service = FakeOAuthService()
_install_service(monkeypatch, service)
with app.test_request_context("/oauth/authorize/github"), pytest.raises(UnprocessableEntity):
OAuthCallback().get("github")
assert service.callback_calls == []
@pytest.mark.parametrize("error", [OAuthProviderRequestError(), OAuthIdentityLockUnavailableError()])
def test_callback_maps_oauth_processing_error_to_bad_request(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
error: Exception,
) -> None:
service = FakeOAuthService(callback_error=error)
_install_service(monkeypatch, service)
with app.test_request_context("/oauth/authorize/github?code=code-1"):
payload, status = narrowed(OAuthCallback().get("github"), tuple)
assert status == 400
assert payload == {"error": "OAuth process failed"}
@pytest.mark.parametrize(
("error", "expected_query"),
[
(
OAuthInvitationAccountMismatchError("invite-token"),
"message=This+invitation+was+sent+to+another+account.+Please+sign+in+with+the+invited+account."
"&invite_token=invite-token",
),
(OAuthRegistrationError("Registration failed"), "message=Registration+failed"),
],
)
def test_callback_serializes_application_errors_as_signin_redirects(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
error: Exception,
expected_query: str,
) -> None:
service = FakeOAuthService(callback_error=error)
_install_service(monkeypatch, service)
with app.test_request_context("/oauth/authorize/github?code=code-1"):
response = narrowed(OAuthCallback().get("github"), Response)
assert response.status_code == 302
assert response.headers["Location"] == f"{CONSOLE_WEB_URL}/signin?{expected_query}"
def test_oauth_admission_rejects_disabled_social_login(
app: Flask,
monkeypatch: pytest.MonkeyPatch,
config_overrides: Callable[..., None],
) -> None:
service = FakeOAuthService()
_install_service(monkeypatch, service)
config_overrides(ENABLE_SOCIAL_OAUTH_LOGIN=False)
with app.test_request_context("/oauth/login/github"), pytest.raises(Forbidden):
OAuthLogin().get("github")
assert service.authorization_calls == []
@@ -0,0 +1,233 @@
from datetime import UTC, datetime
from http import HTTPStatus
from inspect import unwrap
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
import pytest
from flask import Flask
from werkzeug.exceptions import NotFound
from controllers.console.auth.oauth_server import (
OAuthProviderAppResponse,
OAuthServerAppApi,
OAuthServerUserAccountApi,
OAuthServerUserAuthorizeApi,
OAuthServerUserTokenApi,
)
from machinery.context import RequestContext
from services.entities.oauth_server_entities import (
OAuthAuthorizationCode,
OAuthProviderAccount,
OAuthProviderAppPresentation,
OAuthTokenSet,
)
from services.oauth_server_service import OAuthServerClientNotFoundError, OAuthServerUnauthorizedError
def _context() -> RequestContext:
return RequestContext("request-1", "trace-1", "account-1", "workspace-1")
def _services(service: MagicMock) -> SimpleNamespace:
return SimpleNamespace(oauth_server=service)
def test_provider_parses_payload_delegates_and_serializes() -> None:
app = Flask(__name__)
service = MagicMock()
service.get_provider.return_value = OAuthProviderAppPresentation(
app_icon="icon",
app_label={"en-US": "Test App"},
scope="read",
auto_authorize=True,
)
with (
app.test_request_context(json={"client_id": "client-1", "redirect_uri": "https://example.com/callback"}),
patch("controllers.console.auth.oauth_server.application_services", return_value=_services(service)),
):
result = unwrap(OAuthServerAppApi.post)(OAuthServerAppApi())
assert result == (
{
"app_icon": "icon",
"app_label": {"en-US": "Test App"},
"scope": "read",
"auto_authorize": True,
},
HTTPStatus.OK,
)
service.get_provider.assert_called_once_with(
client_id="client-1",
redirect_uri="https://example.com/callback",
)
def test_authorize_uses_admission_request_context() -> None:
app = Flask(__name__)
service = MagicMock()
service.authorize.return_value = OAuthAuthorizationCode(code="authorization-code")
context = _context()
with (
app.test_request_context(json={"client_id": "client-1"}),
patch("controllers.console.auth.oauth_server.application_services", return_value=_services(service)),
):
result = unwrap(OAuthServerUserAuthorizeApi.post)(OAuthServerUserAuthorizeApi(), context)
assert result == ({"code": "authorization-code"}, HTTPStatus.OK)
service.authorize.assert_called_once_with(context, client_id="client-1")
def test_token_endpoint_delegates_grant_data() -> None:
app = Flask(__name__)
service = MagicMock()
service.exchange_token.return_value = OAuthTokenSet(
access_token="access-1",
token_type="Bearer",
expires_in=43200,
refresh_token="refresh-1",
)
with (
app.test_request_context(
json={
"client_id": "client-1",
"grant_type": "authorization_code",
"code": "code-1",
"client_secret": "secret",
"redirect_uri": "https://example.com/callback",
}
),
patch("controllers.console.auth.oauth_server.application_services", return_value=_services(service)),
):
result = unwrap(OAuthServerUserTokenApi.post)(OAuthServerUserTokenApi())
assert result == (
{
"access_token": "access-1",
"token_type": "Bearer",
"expires_in": 43200,
"refresh_token": "refresh-1",
},
HTTPStatus.OK,
)
service.exchange_token.assert_called_once_with(
client_id="client-1",
grant_type="authorization_code",
code="code-1",
client_secret="secret",
redirect_uri="https://example.com/callback",
refresh_token=None,
)
def test_account_endpoint_parses_bearer_token_and_serializes_account() -> None:
app = Flask(__name__)
service = MagicMock()
service.get_account.return_value = OAuthProviderAccount(
id="account-1",
name="Test User",
email="test@example.com",
avatar="avatar",
interface_language="en-US",
timezone="UTC",
created_at=datetime(2024, 1, 2, 3, 4, 5, tzinfo=UTC),
)
with (
app.test_request_context(
json={"client_id": "client-1"},
headers={"Authorization": "Bearer access-1"},
),
patch("controllers.console.auth.oauth_server.application_services", return_value=_services(service)),
):
result = unwrap(OAuthServerUserAccountApi.post)(OAuthServerUserAccountApi())
assert result == (
{
"id": "account-1",
"name": "Test User",
"email": "test@example.com",
"avatar": "avatar",
"interface_language": "en-US",
"timezone": "UTC",
"created_at": 1704164645,
},
HTTPStatus.OK,
)
service.get_account.assert_called_once_with(client_id="client-1", access_token="access-1")
def test_account_endpoint_serializes_nullable_account_preferences() -> None:
app = Flask(__name__)
service = MagicMock()
service.get_account.return_value = OAuthProviderAccount(
id="account-1",
name="Test User",
email="test@example.com",
avatar=None,
interface_language=None,
timezone=None,
created_at=datetime(2024, 1, 2, 3, 4, 5, tzinfo=UTC),
)
with (
app.test_request_context(
json={"client_id": "client-1"},
headers={"Authorization": "Bearer access-1"},
),
patch("controllers.console.auth.oauth_server.application_services", return_value=_services(service)),
):
result = unwrap(OAuthServerUserAccountApi.post)(OAuthServerUserAccountApi())
assert result == (
{
"id": "account-1",
"name": "Test User",
"email": "test@example.com",
"avatar": None,
"interface_language": None,
"timezone": None,
"created_at": 1704164645,
},
HTTPStatus.OK,
)
def test_account_endpoint_returns_bearer_challenge_for_missing_header() -> None:
app = Flask(__name__)
service = MagicMock()
service.get_account.side_effect = OAuthServerUnauthorizedError("access_token is required")
with (
app.test_request_context(json={"client_id": "client-1"}),
patch("controllers.console.auth.oauth_server.application_services", return_value=_services(service)),
):
response = unwrap(OAuthServerUserAccountApi.post)(OAuthServerUserAccountApi())
assert response.status_code == HTTPStatus.UNAUTHORIZED
assert response.get_json() == {"error": "Authorization header is required"}
assert response.headers["WWW-Authenticate"] == "Bearer"
service.get_account.assert_called_once_with(client_id="client-1", access_token=None)
def test_account_endpoint_preserves_client_validation_before_bearer_challenge() -> None:
app = Flask(__name__)
service = MagicMock()
service.get_account.side_effect = OAuthServerClientNotFoundError("client_id is invalid")
with (
app.test_request_context(json={"client_id": "missing"}),
patch("controllers.console.auth.oauth_server.application_services", return_value=_services(service)),
):
with pytest.raises(NotFound, match="client_id is invalid"):
unwrap(OAuthServerUserAccountApi.post)(OAuthServerUserAccountApi())
def test_oauth_provider_app_response_requires_auto_authorize() -> None:
# A missing field must fail validation instead of silently defaulting:
# an optional field would surface as `undefined` in the generated TS
# contract and silently disable silent authorization.
assert "auto_authorize" in OAuthProviderAppResponse.model_json_schema()["required"]
@@ -0,0 +1,215 @@
from collections.abc import Iterator
from inspect import unwrap
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
import pytest
from flask import Flask
from controllers.console.billing.billing import Invoices, Subscription, SubscriptionQuery
from controllers.console.billing.error import (
BillingOperationFailedError,
BillingUnavailableError,
)
from enums import CloudPlan
from machinery.context import RequestContext
from services.billing_client import billing
from services.errors.billing import (
UnknownErrorReason,
)
class TestBillingPortal:
@pytest.fixture
def app(self) -> Flask:
app = Flask(__name__)
app.config["TESTING"] = True
return app
@pytest.fixture
def request_context(self) -> RequestContext:
return RequestContext(
request_id="request-1",
trace_id="trace-1",
account_id="account-1",
active_workspace_id="tenant-1",
)
@pytest.fixture
def billing_portal(self) -> MagicMock:
return MagicMock()
@pytest.fixture(autouse=True)
def mock_application_services(self, billing_portal: MagicMock) -> Iterator[None]:
with patch(
"controllers.console.billing.billing.application_services",
return_value=SimpleNamespace(billing_portal=billing_portal),
):
yield
def test_get_subscription_uses_admission_context_and_response_contract(
self,
app: Flask,
request_context: RequestContext,
billing_portal: MagicMock,
) -> None:
resource = Subscription()
method = unwrap(resource.get)
query = SubscriptionQuery(plan=CloudPlan.PROFESSIONAL, interval="month")
billing_portal.get_subscription.return_value = billing.GetSubscriptionPaymentLinkReply(
url="https://billing.example.com/checkout"
)
with app.test_request_context("/billing/subscription"):
result = method(resource, query, request_context)
billing_portal.get_subscription.assert_called_once_with(
request_context,
plan=CloudPlan.PROFESSIONAL,
interval="month",
)
assert result == {"url": "https://billing.example.com/checkout"}
def test_get_invoices_uses_admission_context_and_response_contract(
self,
app: Flask,
request_context: RequestContext,
billing_portal: MagicMock,
) -> None:
resource = Invoices()
method = unwrap(resource.get)
billing_portal.get_invoices.return_value = billing.GetInvoicesReply(url="https://billing.example.com/portal")
with app.test_request_context("/billing/invoices"):
result = method(resource, request_context)
billing_portal.get_invoices.assert_called_once_with(request_context)
assert result == {"url": "https://billing.example.com/portal"}
def test_get_invoices_translates_unavailable_operation(
self,
app: Flask,
request_context: RequestContext,
billing_portal: MagicMock,
) -> None:
resource = Invoices()
method = unwrap(resource.get)
billing_portal.get_invoices.side_effect = billing.BillingInvoiceUpstreamUnavailableError
with app.test_request_context("/billing/invoices"):
with pytest.raises(BillingUnavailableError) as exc_info:
method(resource, request_context)
assert exc_info.value.data == {
"code": "billing_unavailable",
"message": "This operation is temporarily unavailable. Please try again later.",
"status": 503,
}
def test_get_subscription_translates_invalid_upstream_response(
self,
app: Flask,
request_context: RequestContext,
billing_portal: MagicMock,
) -> None:
resource = Subscription()
method = unwrap(resource.get)
query = SubscriptionQuery(plan=CloudPlan.PROFESSIONAL, interval="month")
billing_portal.get_subscription.side_effect = billing.BillingSubscriptionUpstreamInvalidResponseError
with app.test_request_context("/billing/subscription"):
with pytest.raises(BillingOperationFailedError) as exc_info:
method(resource, query, request_context)
assert exc_info.value.data == {
"code": "billing_operation_failed",
"message": "We couldn't complete this request. Please try again. If the problem persists, contact support.",
"status": 502,
}
@pytest.mark.parametrize(
("error", "expected"),
[
(
billing.BillingSubscriptionUpstreamInvalidResponseError(status_code=400, reason="MISSING_PLAN"),
BillingOperationFailedError,
),
(
billing.BillingSubscriptionUpstreamUnavailableError(
status_code=500, reason="CREATE_SUBSCRIPTION_PAYMENT_LINK_FAILED"
),
BillingUnavailableError,
),
(
billing.BillingSubscriptionUpstreamUnavailableError(status_code=429, reason="REQUEST_IN_PROGRESS"),
BillingUnavailableError,
),
(
billing.BillingSubscriptionUpstreamInvalidResponseError(
status_code=409, reason=UnknownErrorReason("PLAN_SHIPPED_LATER")
),
BillingOperationFailedError,
),
(
billing.BillingSubscriptionUpstreamUnavailableError(
status_code=503, reason=UnknownErrorReason("PLAN_SHIPPED_LATER")
),
BillingUnavailableError,
),
(billing.BillingSubscriptionUpstreamInvalidResponseError(status_code=400), BillingOperationFailedError),
(billing.BillingSubscriptionUpstreamUnavailableError(), BillingUnavailableError),
],
)
def test_get_subscription_maps_every_reason_to_a_generic_billing_error(
self,
app: Flask,
request_context: RequestContext,
billing_portal: MagicMock,
error: billing.BillingSubscriptionUpstreamError,
expected: type[Exception],
) -> None:
resource = Subscription()
billing_portal.get_subscription.side_effect = error
with app.test_request_context("/billing/subscription"), pytest.raises(expected) as exc_info:
unwrap(resource.get)(
resource, SubscriptionQuery(plan=CloudPlan.PROFESSIONAL, interval="month"), request_context
)
assert exc_info.value.__cause__ is error
@pytest.mark.parametrize(
("error", "expected"),
[
(
billing.BillingInvoiceUpstreamInvalidResponseError(status_code=400, reason="INVALID_INVOICE_REQUEST"),
BillingOperationFailedError,
),
(
billing.BillingInvoiceUpstreamUnavailableError(status_code=500, reason="CREATE_INVOICE_PORTAL_FAILED"),
BillingUnavailableError,
),
(
billing.BillingInvoiceUpstreamInvalidResponseError(
status_code=409, reason=UnknownErrorReason("INVOICE_SHIPPED_LATER")
),
BillingOperationFailedError,
),
(billing.BillingInvoiceUpstreamUnavailableError(status_code=502), BillingUnavailableError),
],
)
def test_get_invoices_maps_every_reason_to_a_generic_billing_error(
self,
app: Flask,
request_context: RequestContext,
billing_portal: MagicMock,
error: billing.BillingInvoiceUpstreamError,
expected: type[Exception],
) -> None:
resource = Invoices()
billing_portal.get_invoices.side_effect = error
with app.test_request_context("/billing/invoices"), pytest.raises(expected) as exc_info:
unwrap(resource.get)(resource, request_context)
assert exc_info.value.__cause__ is error
@@ -0,0 +1,172 @@
from collections.abc import Iterator
from inspect import unwrap
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
import pytest
from flask import Flask
from controllers.console.billing.compliance import ComplianceApi, ComplianceDownloadQuery
from controllers.console.billing.error import ComplianceRateLimitError
from libs.exception import BaseHTTPException
from machinery.context import RequestContext
from services.billing_client import billing
from services.errors.billing import (
ComplianceRateLimitExceededError,
UnknownErrorReason,
)
@pytest.fixture
def app() -> Flask:
app = Flask(__name__)
app.config["TESTING"] = True
return app
@pytest.fixture
def request_context() -> RequestContext:
return RequestContext(
request_id="request-1",
trace_id="trace-1",
account_id="account-1",
active_workspace_id="tenant-1",
)
@pytest.fixture
def compliance_downloads() -> MagicMock:
return MagicMock()
@pytest.fixture(autouse=True)
def mock_application_services(compliance_downloads: MagicMock) -> Iterator[None]:
with patch(
"controllers.console.billing.compliance.application_services",
return_value=SimpleNamespace(compliance_downloads=compliance_downloads),
):
yield
def test_get_compliance_download_link(
app: Flask,
request_context: RequestContext,
compliance_downloads: MagicMock,
) -> None:
resource = ComplianceApi()
method = unwrap(resource.get)
query = ComplianceDownloadQuery(doc_name="SOC2_Type_II")
compliance_downloads.get_link.return_value = billing.DownloadComplianceDocumentReply(
url="https://example.com/report"
)
with (
app.test_request_context("/compliance/download", headers={"User-Agent": "test-agent"}),
patch("controllers.console.billing.compliance.extract_remote_ip", return_value="127.0.0.1"),
):
result = method(resource, query, request_context)
assert result == {"url": "https://example.com/report"}
compliance_downloads.get_link.assert_called_once_with(
request_context=request_context,
document_name="SOC2_Type_II",
ip_address="127.0.0.1",
device_info="test-agent",
)
def test_get_compliance_download_translates_rate_limit(
app: Flask,
request_context: RequestContext,
compliance_downloads: MagicMock,
) -> None:
resource = ComplianceApi()
method = unwrap(resource.get)
query = ComplianceDownloadQuery(doc_name="SOC2_Type_II")
compliance_downloads.get_link.side_effect = ComplianceRateLimitExceededError
with (
app.test_request_context("/compliance/download"),
patch("controllers.console.billing.compliance.extract_remote_ip", return_value="127.0.0.1"),
):
with pytest.raises(ComplianceRateLimitError) as exc_info:
method(resource, query, request_context)
assert exc_info.value.data == {
"code": "compliance_rate_limit",
"message": "Rate limit exceeded for downloading compliance report.",
"status": 429,
}
@pytest.mark.parametrize(
("error", "expected_code", "expected_status"),
[
(
billing.BillingComplianceUpstreamInvalidResponseError(
status_code=404, reason="COMPLIANCE_DOCUMENT_NOT_FOUND"
),
"compliance_document_not_found",
404,
),
(
billing.BillingComplianceUpstreamInvalidResponseError(
status_code=403, reason="COMPLIANCE_DOWNLOAD_FORBIDDEN"
),
"compliance_download_forbidden",
403,
),
(
billing.BillingComplianceUpstreamUnavailableError(status_code=429, reason="REQUEST_IN_PROGRESS"),
"billing_request_in_progress",
429,
),
(
billing.BillingComplianceUpstreamUnavailableError(status_code=500, reason="COMPLIANCE_DOWNLOAD_FAILED"),
"billing_unavailable",
503,
),
(
billing.BillingComplianceUpstreamInvalidResponseError(status_code=400, reason="MISSING_DOC_NAME"),
"billing_operation_failed",
502,
),
(
billing.BillingComplianceUpstreamInvalidResponseError(
status_code=403, reason=UnknownErrorReason("COMPLIANCE_SHIPPED_LATER")
),
"billing_operation_failed",
502,
),
(
billing.BillingComplianceUpstreamUnavailableError(
status_code=503, reason=UnknownErrorReason("COMPLIANCE_SHIPPED_LATER")
),
"billing_unavailable",
503,
),
(billing.BillingComplianceUpstreamInvalidResponseError(status_code=404), "billing_operation_failed", 502),
(billing.BillingComplianceUpstreamUnavailableError(), "billing_unavailable", 503),
],
)
def test_get_compliance_download_maps_billing_reason(
app: Flask,
request_context: RequestContext,
compliance_downloads: MagicMock,
error: billing.BillingComplianceUpstreamError,
expected_code: str,
expected_status: int,
) -> None:
resource = ComplianceApi()
compliance_downloads.get_link.side_effect = error
with (
app.test_request_context("/compliance/download"),
patch("controllers.console.billing.compliance.extract_remote_ip", return_value="127.0.0.1"),
pytest.raises(BaseHTTPException) as exc_info,
):
unwrap(resource.get)(resource, ComplianceDownloadQuery(doc_name="SOC2_Type_II"), request_context)
assert exc_info.value.error_code == expected_code
assert exc_info.value.code == expected_status
assert exc_info.value.__cause__ is error
@@ -0,0 +1,9 @@
import pytest
from controllers.console.billing.error import to_billing_request_error
from services.errors.billing import BillingError
def test_to_billing_request_error_rejects_unknown_error() -> None:
with pytest.raises(TypeError, match="Unsupported billing error"):
to_billing_request_error(BillingError())
@@ -0,0 +1 @@
"""Unit tests for `controllers.console.datasets` controllers."""
@@ -0,0 +1,988 @@
import inspect
from datetime import UTC, datetime
from importlib import import_module
from types import SimpleNamespace
from unittest.mock import ANY, MagicMock, patch
import pytest
from flask import Flask
from sqlalchemy.orm import Session, sessionmaker
from werkzeug.exceptions import Forbidden, NotFound
from controllers.console import console_ns
from controllers.console.datasets.rag_pipeline.datasource_auth import (
DatasourceAuth,
DatasourceAuthDefaultApi,
DatasourceAuthDeleteApi,
DatasourceAuthListApi,
DatasourceAuthOauthCustomClient,
DatasourceAuthUpdateApi,
DatasourceCredentialDeletePayload,
DatasourceCredentialPayload,
DatasourceCredentialUpdatePayload,
DatasourceCustomClientPayload,
DatasourceDefaultPayload,
DatasourceHardCodeAuthListApi,
DatasourceOAuthCallback,
DatasourcePluginOAuthAuthorizationUrl,
DatasourceUpdateNamePayload,
DatasourceUpdateProviderNameApi,
)
from core.plugin.impl.oauth import OAuthHandler
from extensions.application_services.data_sources import build_data_source_credentials
from graphon.model_runtime.errors.validate import CredentialsValidateFailedError
from models.account import Account
from repositories.credentials.query_repository import CredentialQueryRepository
from services.data_source.provider_service import DatasourceProviderService
from services.plugin.dispatch_identity import PluginOAuthClientConfig
from services.plugin.oauth_service import OAuthProxyService
from tests.helpers.unit.model_factories import make_account
_PROVIDER_ID = "langgenius/notion_datasource/notion"
@pytest.fixture(autouse=True)
def credential_query_dependency(monkeypatch: pytest.MonkeyPatch, sqlite_session_factory: sessionmaker[Session]) -> None:
query = CredentialQueryRepository(session_factory=sqlite_session_factory)
providers = build_data_source_credentials(database_client=sqlite_session_factory).providers
monkeypatch.setattr(
import_module("controllers.console.datasets.rag_pipeline.datasource_auth"),
"application_services",
lambda: SimpleNamespace(credential_queries=query, data_sources=SimpleNamespace(providers=providers)),
)
def _account() -> Account:
return make_account(account_id="user-1", name="Datasource Auth Tester", email="datasource-auth@example.com")
def _i18n(text: str) -> dict[str, str]:
return {"en_US": text, "zh_Hans": text, "pt_BR": text, "ja_JP": text}
def _provider_config(name: str, type_: str, label: str, *, required: bool = True) -> dict:
return {
"type": type_,
"name": name,
"scope": None,
"required": required,
"default": None,
"options": None,
"multiple": False,
"label": _i18n(label),
"help": None,
"url": None,
"placeholder": None,
}
def _datasource_credential(credential_id: str = "cred-1", *, is_default: bool = True) -> dict:
return {
"credential": {
"api_key": "******",
"workspace": "engineering",
"database_id": "db-123",
},
"type": "api-key",
"name": "API Key",
"avatar_url": "https://cdn.example.com/notion.png",
"id": credential_id,
"is_default": is_default,
}
def _datasource_auth() -> dict:
return {
"author": "Dify",
"provider": "notion",
"plugin_id": "langgenius/notion_datasource",
"plugin_unique_identifier": "langgenius/notion_datasource:0.0.1",
"icon": "icon.svg",
"name": "notion",
"label": _i18n("Notion"),
"description": _i18n("Notion datasource"),
"credential_schema": [
_provider_config("api_key", "secret-input", "API key"),
],
"oauth_schema": {
"client_schema": [
_provider_config("client_id", "text-input", "Client ID"),
],
"credentials_schema": [
_provider_config("access_token", "secret-input", "Access token"),
],
"oauth_custom_client_params": {"client_id": "masked-client", "client_secret": "********"},
"is_oauth_custom_client_enabled": True,
"is_system_oauth_params_exists": True,
"redirect_uri": "https://api.example.com/oauth/callback",
},
"credentials_list": [_datasource_credential(), _datasource_credential("cred-2", is_default=False)],
}
def _success_response() -> dict[str, str]:
return {"result": "success"}
class TestDatasourcePluginOAuthAuthorizationUrl:
def test_get_success(self, app: Flask):
api = DatasourcePluginOAuthAuthorizationUrl()
method = inspect.unwrap(api.get)
user = _account()
oauth_client = {"client_id": "abc", "client_secret": "shh", "scopes": ["read", "write"]}
auth_url_payload = {
"authorization_url": "https://auth.example.com/oauth?client_id=abc&state=xyz",
}
with (
app.test_request_context("/?credential_id=cred-1"),
patch.object(
DatasourceProviderService,
"get_oauth_client",
return_value=PluginOAuthClientConfig(
"langgenius/notion_datasource:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", oauth_client
),
) as get_oauth_client,
patch.object(
OAuthProxyService,
"create_proxy_context",
return_value="ctx-1",
) as create_proxy_context,
patch.object(
OAuthHandler,
"get_authorization_url",
return_value=auth_url_payload,
) as get_authorization_url,
):
response = method(api, "tenant-1", user, _PROVIDER_ID)
assert response.status_code == 200
assert response.get_json() == auth_url_payload
assert "context_id=ctx-1" in response.headers.get("Set-Cookie")
provider_id = get_oauth_client.call_args.kwargs["datasource_provider_id"]
assert str(provider_id) == _PROVIDER_ID
get_oauth_client.assert_called_once()
create_proxy_context.assert_called_once_with(
user_id="user-1",
tenant_id="tenant-1",
plugin_id="langgenius/notion_datasource",
provider="notion",
credential_id="cred-1",
extra_data={
"visibility": "only_me",
"plugin_unique_identifier": "langgenius/notion_datasource:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
},
)
get_authorization_url.assert_called_once()
assert get_authorization_url.call_args.kwargs["tenant_id"] == "tenant-1"
assert get_authorization_url.call_args.kwargs["user_id"] == "user-1"
assert get_authorization_url.call_args.kwargs["plugin_id"] == "langgenius/notion_datasource"
assert get_authorization_url.call_args.kwargs["provider"] == "notion"
assert get_authorization_url.call_args.kwargs["system_credentials"] == oauth_client
def test_get_no_oauth_config(self, app: Flask):
api = DatasourcePluginOAuthAuthorizationUrl()
method = inspect.unwrap(api.get)
user = _account()
with (
app.test_request_context("/"),
patch.object(
DatasourceProviderService,
"get_oauth_client",
return_value=None,
),
):
with pytest.raises(ValueError, match="No OAuth Client Config for notion"):
method(api, "tenant-1", user, "notion")
def test_get_without_credential_id_sets_cookie(self, app: Flask):
api = DatasourcePluginOAuthAuthorizationUrl()
method = inspect.unwrap(api.get)
user = _account()
with (
app.test_request_context("/"),
patch.object(
DatasourceProviderService,
"get_oauth_client",
return_value=PluginOAuthClientConfig(
"langgenius/notion_datasource:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", {"client_id": "abc"}
),
),
patch.object(
OAuthProxyService,
"create_proxy_context",
return_value="ctx-123",
),
patch.object(
OAuthHandler,
"get_authorization_url",
return_value={"authorization_url": "http://auth"},
),
):
response = method(api, "tenant-1", user, _PROVIDER_ID)
assert response.status_code == 200
assert "context_id" in response.headers.get("Set-Cookie")
class TestDatasourceOAuthCallback:
def test_callback_rejects_replaced_package_before_dispatch(
self, app: Flask, monkeypatch: pytest.MonkeyPatch
) -> None:
plugin_id = "langgenius/notion_datasource"
context = {
"user_id": "user-1",
"tenant_id": "tenant-1",
"plugin_id": plugin_id,
"provider": "notion",
"plugin_unique_identifier": f"{plugin_id}:1.0.0@{'a' * 64}",
}
config = PluginOAuthClientConfig(f"{plugin_id}:2.0.0@{'b' * 64}", {"client_secret": "test-secret"})
monkeypatch.setattr(OAuthProxyService, "use_proxy_context", lambda _context_id: context)
monkeypatch.setattr(DatasourceProviderService, "get_oauth_client", lambda *_args, **_kwargs: config)
def unexpected_dispatch(*_args: object, **_kwargs: object) -> None:
raise AssertionError("Changed packages must not receive OAuth credentials")
monkeypatch.setattr(OAuthHandler, "get_credentials", unexpected_dispatch)
api = DatasourceOAuthCallback()
with app.test_request_context("/?context_id=ctx"):
with pytest.raises(Forbidden, match="Plugin changed"):
inspect.unwrap(api.get)(api, _PROVIDER_ID)
def test_callback_success_new_credential(self, app: Flask):
api = DatasourceOAuthCallback()
method = inspect.unwrap(api.get)
oauth_response = MagicMock()
oauth_response.credentials = {"token": "abc"}
expires_at = datetime(2024, 1, 2, 3, 4, 5, tzinfo=UTC)
oauth_response.expires_at = expires_at
oauth_response.metadata = {"name": "Workspace Bot", "avatar_url": "https://avatar.example.com/bot.png"}
context = {
"user_id": "user-1",
"tenant_id": "tenant-1",
"plugin_id": "langgenius/notion_datasource",
"provider": "notion",
"credential_id": None,
}
with (
app.test_request_context("/?context_id=ctx"),
patch.object(
OAuthProxyService,
"use_proxy_context",
return_value=context,
),
patch.object(
DatasourceProviderService,
"get_oauth_client",
return_value=PluginOAuthClientConfig(
"langgenius/notion_datasource:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
{"client_id": "abc", "client_secret": "secret"},
),
),
patch.object(
OAuthHandler,
"get_credentials",
return_value=oauth_response,
),
patch.object(
DatasourceProviderService,
"add_datasource_oauth_provider",
return_value=None,
) as add_oauth_provider,
):
response = method(api, _PROVIDER_ID)
assert response.status_code == 302
assert "/oauth-callback" in response.location
add_oauth_provider.assert_called_once()
# Legacy context without a visibility key falls back to ONLY_ME, and
# the callback now also propagates the creator's user_id.
from models.enums import PermissionEnum
assert add_oauth_provider.call_args.kwargs == {
"tenant_id": "tenant-1",
"provider_id": add_oauth_provider.call_args.kwargs["provider_id"],
"avatar_url": "https://avatar.example.com/bot.png",
"name": "Workspace Bot",
"expire_at": expires_at,
"credentials": {"token": "abc"},
"user_id": "user-1",
"visibility": PermissionEnum.ONLY_ME,
}
assert str(add_oauth_provider.call_args.kwargs["provider_id"]) == _PROVIDER_ID
def test_callback_missing_context(self, app: Flask):
api = DatasourceOAuthCallback()
method = inspect.unwrap(api.get)
with app.test_request_context("/"):
with pytest.raises(Forbidden):
method(api, "notion")
def test_callback_invalid_context(self, app: Flask):
api = DatasourceOAuthCallback()
method = inspect.unwrap(api.get)
with (
app.test_request_context("/?context_id=bad"),
patch.object(
OAuthProxyService,
"use_proxy_context",
return_value=None,
),
):
with pytest.raises(Forbidden):
method(api, "notion")
def test_callback_oauth_config_not_found(self, app: Flask):
api = DatasourceOAuthCallback()
method = inspect.unwrap(api.get)
context = {"user_id": "u", "tenant_id": "t"}
with (
app.test_request_context("/?context_id=ctx"),
patch.object(
OAuthProxyService,
"use_proxy_context",
return_value=context,
),
patch.object(
DatasourceProviderService,
"get_oauth_client",
return_value=None,
),
):
with pytest.raises(NotFound):
method(api, "notion")
def test_callback_reauthorize_existing_credential(self, app: Flask):
api = DatasourceOAuthCallback()
method = inspect.unwrap(api.get)
oauth_response = MagicMock()
oauth_response.credentials = {"token": "abc"}
oauth_response.expires_at = None
oauth_response.metadata = {} # avatar + name missing
context = {
"user_id": "user-1",
"tenant_id": "tenant-1",
"plugin_id": "langgenius/notion_datasource",
"provider": "notion",
"credential_id": "cred-1",
}
with (
app.test_request_context("/?context_id=ctx"),
patch.object(
OAuthProxyService,
"use_proxy_context",
return_value=context,
),
patch.object(
DatasourceProviderService,
"get_oauth_client",
return_value=PluginOAuthClientConfig(
"langgenius/notion_datasource:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", {"client_id": "abc"}
),
),
patch.object(
OAuthHandler,
"get_credentials",
return_value=oauth_response,
),
patch.object(
DatasourceProviderService,
"reauthorize_datasource_oauth_provider",
return_value=None,
) as reauthorize_provider,
):
response = method(api, _PROVIDER_ID)
assert response.status_code == 302
assert "/oauth-callback" in response.location
reauthorize_provider.assert_called_once()
assert str(reauthorize_provider.call_args.kwargs["provider_id"]) == _PROVIDER_ID
assert reauthorize_provider.call_args.kwargs["credential_id"] == "cred-1"
assert reauthorize_provider.call_args.kwargs["credentials"] == {"token": "abc"}
def test_callback_context_id_from_cookie(self, app: Flask):
api = DatasourceOAuthCallback()
method = inspect.unwrap(api.get)
oauth_response = MagicMock()
oauth_response.credentials = {"token": "abc"}
oauth_response.expires_at = None
oauth_response.metadata = {}
context = {
"user_id": "user-1",
"tenant_id": "tenant-1",
"plugin_id": "langgenius/notion_datasource",
"provider": "notion",
"credential_id": None,
}
with (
app.test_request_context("/", headers={"Cookie": "context_id=ctx"}),
patch.object(
OAuthProxyService,
"use_proxy_context",
return_value=context,
),
patch.object(
DatasourceProviderService,
"get_oauth_client",
return_value=PluginOAuthClientConfig(
"langgenius/notion_datasource:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", {"client_id": "abc"}
),
),
patch.object(
OAuthHandler,
"get_credentials",
return_value=oauth_response,
),
patch.object(
DatasourceProviderService,
"add_datasource_oauth_provider",
return_value=None,
),
):
response = method(api, _PROVIDER_ID)
assert response.status_code == 302
class TestDatasourceAuth:
def test_post_success(self, app: Flask):
api = DatasourceAuth()
method = inspect.unwrap(api.post)
payload = {
"name": "Engineering Notion",
"credentials": {
"api_key": "secret-token",
"workspace": "engineering",
"database_id": "db-123",
},
}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch.object(
DatasourceProviderService,
"add_datasource_api_key_provider",
return_value=None,
) as add_api_key_provider,
):
req_data = DatasourceCredentialPayload.model_validate(payload)
response, status = method(api, req_data, "tenant-1", _PROVIDER_ID)
assert response == _success_response()
assert status == 200
add_api_key_provider.assert_called_once()
assert add_api_key_provider.call_args.kwargs["tenant_id"] == "tenant-1"
assert str(add_api_key_provider.call_args.kwargs["provider_id"]) == _PROVIDER_ID
assert add_api_key_provider.call_args.kwargs["credentials"] == payload["credentials"]
assert add_api_key_provider.call_args.kwargs["name"] == "Engineering Notion"
def test_post_invalid_credentials(self, app: Flask):
api = DatasourceAuth()
method = inspect.unwrap(api.post)
payload = {"credentials": {"key": "bad"}}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch.object(
DatasourceProviderService,
"add_datasource_api_key_provider",
side_effect=CredentialsValidateFailedError("invalid"),
),
):
with pytest.raises(ValueError, match="invalid"):
method(api, DatasourceCredentialPayload.model_validate(payload), "tenant-1", "notion")
def test_get_success(self, app: Flask):
api = DatasourceAuth()
method = inspect.unwrap(api.get)
user = _account()
with (
app.test_request_context("/"),
patch.object(
DatasourceProviderService,
"list_datasource_credentials",
return_value=[_datasource_credential()],
),
):
response, status = method(api, "tenant-1", user, _PROVIDER_ID)
assert status == 200
assert response == {"result": [_datasource_credential()]}
def test_post_missing_credentials(self, app: Flask):
api = DatasourceAuth()
method = inspect.unwrap(api.post)
payload: dict[str, object] = {}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
):
with pytest.raises(ValueError, match="1 validation error for DatasourceCredentialPayload\\\ncredentials"):
method(api, DatasourceCredentialPayload.model_validate(payload), "tenant-1", "notion")
def test_get_empty_list(self, app: Flask):
api = DatasourceAuth()
method = inspect.unwrap(api.get)
user = _account()
with (
app.test_request_context("/"),
patch.object(
DatasourceProviderService,
"list_datasource_credentials",
return_value=[],
),
):
response, status = method(api, "tenant-1", user, "notion")
assert status == 200
assert response["result"] == []
class TestDatasourceAuthDeleteApi:
def test_delete_success(self, app: Flask):
api = DatasourceAuthDeleteApi()
method = inspect.unwrap(api.post)
payload = {"credential_id": "cred-1"}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch.object(
DatasourceProviderService,
"remove_datasource_credentials",
return_value=None,
) as remove_datasource_credentials,
):
req_data = DatasourceCredentialDeletePayload.model_validate(payload)
response, status = method(api, req_data, "tenant-1", _PROVIDER_ID)
assert response == _success_response()
assert status == 200
remove_datasource_credentials.assert_called_once_with(
tenant_id="tenant-1",
auth_id="cred-1",
provider="notion",
plugin_id="langgenius/notion_datasource",
session=ANY,
)
def test_delete_missing_credential_id(self, app: Flask):
api = DatasourceAuthDeleteApi()
method = inspect.unwrap(api.post)
payload: dict[str, object] = {}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
):
with pytest.raises(
ValueError, match="1 validation error for DatasourceCredentialDeletePayload\\\ncredential_id"
):
method(api, DatasourceCredentialDeletePayload.model_validate(payload), "tenant-1", "notion")
class TestDatasourceAuthUpdateApi:
def test_update_success(self, app: Flask):
api = DatasourceAuthUpdateApi()
method = inspect.unwrap(api.post)
payload = {
"credential_id": "cred-1",
"name": "Updated Notion",
"credentials": {"api_key": "new-secret", "database_id": "db-456"},
}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch.object(
DatasourceProviderService,
"update_datasource_credentials",
return_value=None,
) as update_datasource_credentials,
):
req_data = DatasourceCredentialUpdatePayload.model_validate(payload)
response, status = method(api, req_data, "tenant-1", _PROVIDER_ID)
assert response == _success_response()
assert status == 201
update_datasource_credentials.assert_called_once_with(
tenant_id="tenant-1",
auth_id="cred-1",
provider="notion",
plugin_id="langgenius/notion_datasource",
credentials=payload["credentials"],
name="Updated Notion",
)
def test_update_with_credentials_none(self, app: Flask):
api = DatasourceAuthUpdateApi()
method = inspect.unwrap(api.post)
payload = {"credential_id": "id", "credentials": None}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch.object(
DatasourceProviderService,
"update_datasource_credentials",
return_value=None,
) as update_mock,
):
req_data = DatasourceCredentialUpdatePayload.model_validate(payload)
response, status = method(api, req_data, "tenant-1", "notion")
assert response == _success_response()
update_mock.assert_called_once()
assert update_mock.call_args.kwargs["credentials"] == {}
assert status == 201
def test_update_name_only(self, app: Flask):
api = DatasourceAuthUpdateApi()
method = inspect.unwrap(api.post)
payload = {"credential_id": "id", "name": "New Name"}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch.object(
DatasourceProviderService,
"update_datasource_credentials",
return_value=None,
),
):
req_data = DatasourceCredentialUpdatePayload.model_validate(payload)
response, status = method(api, req_data, "tenant-1", "notion")
assert response == _success_response()
assert status == 201
def test_update_with_empty_credentials_dict(self, app: Flask):
api = DatasourceAuthUpdateApi()
method = inspect.unwrap(api.post)
payload = {"credential_id": "id", "credentials": {}}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch.object(
DatasourceProviderService,
"update_datasource_credentials",
return_value=None,
) as update_mock,
):
req_data = DatasourceCredentialUpdatePayload.model_validate(payload)
response, status = method(api, req_data, "tenant-1", "notion")
assert response == _success_response()
update_mock.assert_called_once()
assert status == 201
class TestDatasourceAuthListApi:
def test_list_success(self, app: Flask):
api = DatasourceAuthListApi()
method = inspect.unwrap(api.get)
user = MagicMock(id="user-1")
with (
app.test_request_context("/"),
patch.object(
DatasourceProviderService,
"get_all_datasource_credentials",
return_value=[_datasource_auth()],
) as get_all,
):
response, status = method(api, "tenant-1", user)
assert status == 200
assert response == {"result": [_datasource_auth()]}
# user is threaded through so list_datasource_credentials applies the
# visibility filter for the current viewer.
assert get_all.call_args.kwargs["user"] is user
def test_auth_list_empty(self, app: Flask):
api = DatasourceAuthListApi()
method = inspect.unwrap(api.get)
user = MagicMock(id="user-1")
with (
app.test_request_context("/"),
patch.object(
DatasourceProviderService,
"get_all_datasource_credentials",
return_value=[],
),
):
response, status = method(api, "tenant-1", user)
assert status == 200
assert response["result"] == []
def test_hardcode_list_empty(self, app: Flask):
api = DatasourceHardCodeAuthListApi()
method = inspect.unwrap(api.get)
user = MagicMock(id="user-1")
with (
app.test_request_context("/"),
patch.object(
DatasourceProviderService,
"get_hard_code_datasource_credentials",
return_value=[],
),
):
response, status = method(api, "tenant-1", user)
assert status == 200
assert response["result"] == []
class TestDatasourceHardCodeAuthListApi:
def test_list_success(self, app: Flask):
api = DatasourceHardCodeAuthListApi()
method = inspect.unwrap(api.get)
user = MagicMock(id="user-1")
with (
app.test_request_context("/"),
patch.object(
DatasourceProviderService,
"get_hard_code_datasource_credentials",
return_value=[_datasource_auth()],
) as get_hardcode,
):
response, status = method(api, "tenant-1", user)
assert status == 200
assert get_hardcode.call_args.kwargs["user"] is user
class TestDatasourceAuthOauthCustomClient:
def test_post_success(self, app: Flask):
api = DatasourceAuthOauthCustomClient()
method = inspect.unwrap(api.post)
payload = {
"client_params": {
"client_id": "custom-client",
"client_secret": "custom-secret",
"authorize_url": "https://auth.example.com/authorize",
},
"enable_oauth_custom_client": True,
}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch.object(
DatasourceProviderService,
"setup_oauth_custom_client_params",
return_value=None,
) as setup_custom_client,
):
req_data = DatasourceCustomClientPayload.model_validate(payload)
response, status = method(api, req_data, "tenant-1", _PROVIDER_ID)
assert response == _success_response()
assert status == 200
setup_custom_client.assert_called_once()
assert setup_custom_client.call_args.kwargs["tenant_id"] == "tenant-1"
assert str(setup_custom_client.call_args.kwargs["datasource_provider_id"]) == _PROVIDER_ID
assert setup_custom_client.call_args.kwargs["client_params"] == payload["client_params"]
assert setup_custom_client.call_args.kwargs["enabled"] is True
def test_delete_success(self, app: Flask):
api = DatasourceAuthOauthCustomClient()
method = inspect.unwrap(api.delete)
with (
app.test_request_context("/"),
patch.object(
DatasourceProviderService,
"remove_oauth_custom_client_params",
return_value=None,
) as remove_custom_client,
):
response, status = method(api, "tenant-1", _PROVIDER_ID)
assert response == _success_response()
assert status == 200
remove_custom_client.assert_called_once()
assert str(remove_custom_client.call_args.kwargs["datasource_provider_id"]) == _PROVIDER_ID
def test_post_empty_payload(self, app: Flask):
api = DatasourceAuthOauthCustomClient()
method = inspect.unwrap(api.post)
payload: dict[str, object] = {}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch.object(
DatasourceProviderService,
"setup_oauth_custom_client_params",
return_value=None,
),
):
req_data = DatasourceCustomClientPayload.model_validate(payload)
response, status = method(api, req_data, "tenant-1", "notion")
assert response == _success_response()
assert status == 200
def test_post_disabled_flag(self, app: Flask):
api = DatasourceAuthOauthCustomClient()
method = inspect.unwrap(api.post)
payload = {
"client_params": {"a": 1},
"enable_oauth_custom_client": False,
}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch.object(
DatasourceProviderService,
"setup_oauth_custom_client_params",
return_value=None,
) as setup_mock,
):
req_data = DatasourceCustomClientPayload.model_validate(payload)
response, status = method(api, req_data, "tenant-1", "notion")
assert response == _success_response()
setup_mock.assert_called_once()
assert setup_mock.call_args.kwargs["client_params"] == {"a": 1}
assert setup_mock.call_args.kwargs["enabled"] is False
assert status == 200
class TestDatasourceAuthDefaultApi:
def test_set_default_success(self, app: Flask):
api = DatasourceAuthDefaultApi()
method = inspect.unwrap(api.post)
payload = {"id": "cred-1"}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch.object(
DatasourceProviderService,
"set_default_datasource_provider",
return_value=None,
) as set_default_datasource_provider,
):
req_data = DatasourceDefaultPayload.model_validate(payload)
response, status = method(api, req_data, "tenant-1", _PROVIDER_ID)
assert response == _success_response()
assert status == 200
set_default_datasource_provider.assert_called_once()
assert set_default_datasource_provider.call_args.kwargs["tenant_id"] == "tenant-1"
assert str(set_default_datasource_provider.call_args.kwargs["datasource_provider_id"]) == _PROVIDER_ID
assert set_default_datasource_provider.call_args.kwargs["credential_id"] == "cred-1"
def test_default_missing_id(self, app: Flask):
api = DatasourceAuthDefaultApi()
method = inspect.unwrap(api.post)
payload: dict[str, object] = {}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
):
with pytest.raises(ValueError, match="1 validation error for DatasourceDefaultPayload\\\nid"):
method(api, DatasourceDefaultPayload.model_validate(payload), "tenant-1", "notion")
class TestDatasourceUpdateProviderNameApi:
def test_update_name_success(self, app: Flask):
api = DatasourceUpdateProviderNameApi()
method = inspect.unwrap(api.post)
payload = {"credential_id": "cred-1", "name": "New Name"}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch.object(
DatasourceProviderService,
"update_datasource_provider_name",
return_value=None,
) as update_datasource_provider_name,
):
req_data = DatasourceUpdateNamePayload.model_validate(payload)
response, status = method(api, req_data, "tenant-1", _PROVIDER_ID)
assert response == _success_response()
assert status == 200
update_datasource_provider_name.assert_called_once()
assert update_datasource_provider_name.call_args.kwargs["tenant_id"] == "tenant-1"
assert str(update_datasource_provider_name.call_args.kwargs["datasource_provider_id"]) == _PROVIDER_ID
assert update_datasource_provider_name.call_args.kwargs["name"] == "New Name"
assert update_datasource_provider_name.call_args.kwargs["credential_id"] == "cred-1"
def test_update_name_too_long(self, app: Flask):
api = DatasourceUpdateProviderNameApi()
method = inspect.unwrap(api.post)
payload = {
"credential_id": "id",
"name": "x" * 101,
}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
):
with pytest.raises(ValueError, match="1 validation error for DatasourceUpdateNamePayload\\\nname"):
method(api, DatasourceUpdateNamePayload.model_validate(payload), "tenant-1", "notion")
def test_update_name_missing_credential_id(self, app: Flask):
api = DatasourceUpdateProviderNameApi()
method = inspect.unwrap(api.post)
payload = {"name": "Valid"}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
):
with pytest.raises(ValueError, match="1 validation error for DatasourceUpdateNamePayload\\\ncredential_id"):
method(api, DatasourceUpdateNamePayload.model_validate(payload), "tenant-1", "notion")
@@ -0,0 +1,117 @@
from inspect import unwrap
from unittest.mock import ANY, MagicMock, patch
import pytest
from flask import Flask
from controllers.console import console_ns
from controllers.console.datasets.rag_pipeline.datasource_content_preview import (
DataSourceContentPreviewApi,
DatasourceContentPreviewPayload,
)
from models import Account
from models.dataset import Pipeline
def make_account() -> Account:
account = Account(name="Test User", email="user@example.com")
account.id = "account-1"
return account
class TestDataSourceContentPreviewApi:
def _valid_payload(self) -> dict[str, object]:
return {
"inputs": {"query": "hello"},
"datasource_type": "notion",
"credential_id": "cred-1",
}
def test_post_success(self, app: Flask) -> None:
api = DataSourceContentPreviewApi()
method = unwrap(api.post)
payload = self._valid_payload()
pipeline = Pipeline(tenant_id="tenant-id", name="Test Pipeline")
node_id = "node-1"
account = make_account()
preview_result = {"content": "preview data"}
service_instance = MagicMock()
service_instance.run_datasource_node_preview.return_value = preview_result
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch(
"controllers.console.datasets.rag_pipeline.datasource_content_preview.RagPipelineService",
return_value=service_instance,
),
):
req_data = DatasourceContentPreviewPayload.model_validate(payload)
response, status = method(api, req_data, account, pipeline, node_id)
service_instance.run_datasource_node_preview.assert_called_once_with(
pipeline=pipeline,
node_id=node_id,
user_inputs=payload["inputs"],
account=account,
datasource_type=payload["datasource_type"],
is_published=True,
credential_id=payload["credential_id"],
datasource_providers=ANY,
)
assert status == 200
assert response == preview_result
def test_post_invalid_payload(self, app: Flask) -> None:
api = DataSourceContentPreviewApi()
method = unwrap(api.post)
payload = {
"inputs": {"query": "hello"},
# datasource_type missing
}
pipeline = Pipeline(tenant_id="tenant-id", name="Test Pipeline")
account = make_account()
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
):
with pytest.raises(ValueError, match=r"datasource_type\n\s+Field required"):
method(api, DatasourceContentPreviewPayload.model_validate(payload), account, pipeline, "node-1")
def test_post_without_credential_id(self, app: Flask) -> None:
api = DataSourceContentPreviewApi()
method = unwrap(api.post)
payload = {
"inputs": {"query": "hello"},
"datasource_type": "notion",
"credential_id": None,
}
pipeline = Pipeline(tenant_id="tenant-id", name="Test Pipeline")
account = make_account()
service_instance = MagicMock()
service_instance.run_datasource_node_preview.return_value = {"ok": True}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch(
"controllers.console.datasets.rag_pipeline.datasource_content_preview.RagPipelineService",
return_value=service_instance,
),
):
req_data = DatasourceContentPreviewPayload.model_validate(payload)
response, status = method(api, req_data, account, pipeline, "node-1")
service_instance.run_datasource_node_preview.assert_called_once()
assert status == 200
assert response == {"ok": True}
@@ -0,0 +1,513 @@
from __future__ import annotations
from collections.abc import Iterator
from inspect import unwrap
from unittest.mock import ANY, PropertyMock, patch
import pytest
from flask import Flask
from sqlalchemy import Engine
from sqlalchemy.orm import Session
from werkzeug.exceptions import Forbidden, NotFound
from controllers.console import console_ns
from controllers.console.datasets.rag_pipeline import rag_pipeline as module
from controllers.console.datasets.rag_pipeline.rag_pipeline import (
CustomizedPipelineTemplateApi,
CustomizedPipelineTemplatePayload,
PipelineTemplateDetailApi,
PipelineTemplateDetailQuery,
PipelineTemplateListApi,
PipelineTemplateListQuery,
PublishCustomizedPipelineTemplateApi,
)
from models.account import Account, TenantAccountRole
from models.dataset import Pipeline, PipelineCustomizedTemplate
from models.engine import db
from services.entities.knowledge_entities.rag_pipeline_entities import PipelineTemplateInfoEntity
from services.errors.base import NoPermissionError
from services.errors.rag_pipeline import RagPipelineResourceNotFoundError
from tests.helpers.unit.config_override import config_overrides_context
from tests.helpers.unit.controllers.rbac_introspection import rbac_checks
from tests.helpers.unit.model_factories import make_account
def _template_item() -> dict[str, object]:
return {
"id": "template-1",
"name": "Template",
"icon": {"icon": "book", "icon_type": "emoji", "icon_background": "#fff"},
"description": "Description",
"position": 1,
"chunk_structure": "general",
}
def _template_detail() -> dict[str, object]:
return {
"id": "template-1",
"name": "Template",
"icon_info": {"icon": "book", "icon_type": "emoji", "icon_background": "#fff"},
"description": "Description",
"chunk_structure": "general",
"export_data": "dsl: value",
"graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 1}},
}
def _payload() -> dict[str, object]:
return {
"name": "Updated template",
"description": "Updated description",
"icon_info": {"icon": "book", "icon_type": "emoji", "icon_background": "#fff"},
}
def _account() -> Account:
return make_account(name="Test User", email="test@example.com")
def _pipeline() -> Pipeline:
pipeline = Pipeline(tenant_id="tenant-1", name="Pipeline")
pipeline.id = "pipeline-1"
return pipeline
@pytest.fixture
def database_app() -> Iterator[Flask]:
app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:"
db.init_app(app)
with app.app_context():
PipelineCustomizedTemplate.__table__.create(db.engine)
yield app
class TestPipelineTemplateListApi:
def test_get_uses_query_defaults_and_serializes_nullable_fields(self, app: Flask, sqlite_engine: Engine) -> None:
api = PipelineTemplateListApi()
method = unwrap(api.get)
tenant_id = "tenant-1"
service_calls: list[tuple[str, str, str]] = []
def get_pipeline_templates(*, type: str, language: str, current_tenant_id: str, session) -> dict[str, object]:
del session
service_calls.append((type, language, current_tenant_id))
return {"pipeline_templates": [_template_item()]}
with (
Session(sqlite_engine) as session,
app.test_request_context("/rag/pipeline/templates"),
patch.object(module.RagPipelineService, "get_pipeline_templates", side_effect=get_pipeline_templates),
):
response, status = method(api, PipelineTemplateListQuery(), session, tenant_id)
assert status == 200
assert service_calls == [("built-in", "en-US", tenant_id)]
assert response == {
"pipeline_templates": [
{
**_template_item(),
"copyright": None,
"privacy_policy": None,
}
]
}
def test_get_passes_explicit_query_to_service(self, app: Flask, sqlite_engine: Engine) -> None:
api = PipelineTemplateListApi()
method = unwrap(api.get)
tenant_id = "tenant-1"
service_calls: list[tuple[str, str, str]] = []
def get_pipeline_templates(*, type: str, language: str, current_tenant_id: str, session) -> dict[str, object]:
del session
service_calls.append((type, language, current_tenant_id))
return {"pipeline_templates": []}
with (
Session(sqlite_engine) as session,
app.test_request_context("/rag/pipeline/templates?type=customized&language=ja-JP"),
patch.object(module.RagPipelineService, "get_pipeline_templates", side_effect=get_pipeline_templates),
):
response, status = method(
api, PipelineTemplateListQuery(type="customized", language="ja-JP"), session, tenant_id
)
assert status == 200
assert response == {"pipeline_templates": []}
assert service_calls == [("customized", "ja-JP", tenant_id)]
class TestPipelineTemplateDetailApi:
def test_get_serializes_template_detail(self, app: Flask, sqlite_engine: Engine) -> None:
api = PipelineTemplateDetailApi()
method = unwrap(api.get)
service_calls: list[tuple[str, str, str]] = []
def get_pipeline_template_detail(
template_id: str, current_tenant_id: str, type: str, *, session
) -> dict[str, object]:
del session
service_calls.append((template_id, current_tenant_id, type))
return _template_detail()
with (
Session(sqlite_engine) as session,
app.test_request_context("/rag/pipeline/templates/template-1?type=customized"),
patch.object(
module.RagPipelineService,
"get_pipeline_template_detail",
side_effect=get_pipeline_template_detail,
),
):
response, status = method(
api, PipelineTemplateDetailQuery(type="customized"), session, "tenant-1", "template-1"
)
assert status == 200
assert response == {**_template_detail(), "created_by": None}
assert service_calls == [("template-1", "tenant-1", "customized")]
def test_get_raises_not_found_without_custom_response_body(self, app: Flask, sqlite_engine: Engine) -> None:
api = PipelineTemplateDetailApi()
method = unwrap(api.get)
def get_pipeline_template_detail(template_id: str, current_tenant_id: str, type: str, *, session) -> None:
del template_id, current_tenant_id, type, session
with (
Session(sqlite_engine) as session,
app.test_request_context("/rag/pipeline/templates/missing"),
patch.object(
module.RagPipelineService,
"get_pipeline_template_detail",
side_effect=get_pipeline_template_detail,
),
pytest.raises(NotFound),
):
method(api, PipelineTemplateDetailQuery(), session, "tenant-1", "missing")
class TestCustomizedPipelineTemplateApi:
def test_patch_validates_payload_and_returns_empty_204(self, app: Flask) -> None:
api = CustomizedPipelineTemplateApi()
method = unwrap(api.patch)
payload = _payload()
account = _account()
tenant_id = "tenant-1"
service_calls: list[tuple[str, PipelineTemplateInfoEntity, Account, str]] = []
def update_template(
template_id: str,
template_info: PipelineTemplateInfoEntity,
current_user: Account,
current_tenant_id: str,
*,
session,
) -> None:
del session
service_calls.append((template_id, template_info, current_user, current_tenant_id))
with (
app.test_request_context("/rag/pipeline/customized/templates/template-1", method="PATCH", json=payload),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value=payload),
patch.object(module.RagPipelineService, "update_customized_pipeline_template", side_effect=update_template),
):
response, status = method(
api, CustomizedPipelineTemplatePayload.model_validate(payload), tenant_id, account, "template-1"
)
assert (response, status) == ("", 204)
assert len(service_calls) == 1
template_id, template_info, current_user, current_tenant_id = service_calls[0]
assert template_id == "template-1"
assert current_user is account
assert current_tenant_id == tenant_id
assert template_info.name == "Updated template"
assert template_info.description == "Updated description"
assert template_info.icon_info.model_dump() == {
"icon": "book",
"icon_background": "#fff",
"icon_type": "emoji",
"icon_url": None,
}
def test_patch_defaults_missing_icon_info_before_service_call(self, app: Flask) -> None:
api = CustomizedPipelineTemplateApi()
method = unwrap(api.patch)
payload: dict[str, object] = {
"name": "Updated template",
"description": "Updated description",
}
account = _account()
tenant_id = "tenant-1"
service_calls: list[tuple[str, PipelineTemplateInfoEntity, Account, str]] = []
def update_template(
template_id: str,
template_info: PipelineTemplateInfoEntity,
current_user: Account,
current_tenant_id: str,
*,
session,
) -> None:
del session
service_calls.append((template_id, template_info, current_user, current_tenant_id))
with (
app.test_request_context("/rag/pipeline/customized/templates/template-1", method="PATCH", json=payload),
patch.object(type(console_ns), "payload", new_callable=PropertyMock, return_value=payload),
patch.object(module.RagPipelineService, "update_customized_pipeline_template", side_effect=update_template),
):
response, status = method(
api, CustomizedPipelineTemplatePayload.model_validate(payload), tenant_id, account, "template-1"
)
assert (response, status) == ("", 204)
assert len(service_calls) == 1
template_id, template_info, current_user, current_tenant_id = service_calls[0]
assert template_id == "template-1"
assert current_user is account
assert current_tenant_id == tenant_id
assert template_info.icon_info.model_dump() == {
"icon": "",
"icon_background": None,
"icon_type": None,
"icon_url": None,
}
def test_delete_returns_empty_204(self, app: Flask) -> None:
api = CustomizedPipelineTemplateApi()
method = unwrap(api.delete)
tenant_id = "tenant-1"
deleted_templates: list[tuple[str, str]] = []
def delete_template(template_id: str, current_tenant_id: str, *, session) -> None:
del session
deleted_templates.append((template_id, current_tenant_id))
with (
app.test_request_context("/rag/pipeline/customized/templates/template-1", method="DELETE"),
patch.object(module.RagPipelineService, "delete_customized_pipeline_template", side_effect=delete_template),
):
response, status = method(api, tenant_id, "template-1")
assert (response, status) == ("", 204)
assert deleted_templates == [("template-1", tenant_id)]
@pytest.mark.parametrize("sqlite_session", [(PipelineCustomizedTemplate,)], indirect=True)
def test_post_exports_yaml_from_orm_template(self, app: Flask, sqlite_session: Session) -> None:
api = CustomizedPipelineTemplateApi()
method = unwrap(api.post)
template = PipelineCustomizedTemplate(
tenant_id="00000000-0000-0000-0000-000000000001",
name="Template",
description="Description",
chunk_structure="general",
icon={"icon": "book", "icon_type": "emoji", "icon_background": "#fff"},
position=1,
yaml_content="dsl: value",
install_count=0,
language="en-US",
created_by="00000000-0000-0000-0000-000000000002",
)
template.id = "template-1"
sqlite_session.add(template)
sqlite_session.commit()
with app.test_request_context("/rag/pipeline/customized/templates/template-1", method="POST"):
response, status = method(
api,
sqlite_session,
"00000000-0000-0000-0000-000000000001",
"template-1",
)
assert status == 200
assert response == {"data": "dsl: value"}
@pytest.mark.parametrize("sqlite_session", [(PipelineCustomizedTemplate,)], indirect=True)
def test_post_returns_not_found_for_other_tenant(self, app: Flask, sqlite_session: Session) -> None:
api = CustomizedPipelineTemplateApi()
method = unwrap(api.post)
template = PipelineCustomizedTemplate(
tenant_id="00000000-0000-0000-0000-000000000002",
name="Other tenant template",
description="Description",
chunk_structure="general",
icon={},
position=1,
yaml_content="secret: value",
install_count=0,
language="en-US",
created_by="00000000-0000-0000-0000-000000000003",
)
template.id = "template-1"
sqlite_session.add(template)
sqlite_session.commit()
with (
app.test_request_context("/rag/pipeline/customized/templates/template-1", method="POST"),
pytest.raises(NotFound, match="Customized pipeline template not found"),
):
method(
api,
sqlite_session,
"00000000-0000-0000-0000-000000000001",
"template-1",
)
class TestPublishCustomizedPipelineTemplateApi:
def test_post_uses_pipeline_release_rbac_scene(self) -> None:
[check] = rbac_checks(PublishCustomizedPipelineTemplateApi.post)
assert check.scene == module.RBACPermission.DATASET_PIPELINE_RELEASE
def test_post_validates_payload_and_returns_empty_204(self) -> None:
api = PublishCustomizedPipelineTemplateApi()
method = unwrap(api.post)
payload = _payload()
account = _account()
pipeline = _pipeline()
dataset = object()
with (
config_overrides_context(RBAC_ENABLED=True),
patch.object(module, "get_pipeline_dataset", return_value=dataset),
patch.object(module.DatasetService, "check_dataset_permission") as legacy_acl,
patch.object(module.RagPipelineService, "publish_customized_pipeline_template") as publish,
):
response, status = method(api, CustomizedPipelineTemplatePayload.model_validate(payload), account, pipeline)
assert (response, status) == ("", 204)
publish.assert_called_once_with(pipeline, dataset, payload, account, session=ANY)
legacy_acl.assert_not_called()
@pytest.mark.parametrize(
("payload", "expected_icon_info"),
[
(
{"name": "Published template", "description": "Description"},
{"icon": "", "icon_background": None, "icon_type": None, "icon_url": None},
),
({"name": "Published template", "description": "Description", "icon_info": {}}, {}),
],
)
def test_post_preserves_valid_icon_info(
self,
payload: dict[str, object],
expected_icon_info: dict[str, object | None],
) -> None:
api = PublishCustomizedPipelineTemplateApi()
method = unwrap(api.post)
account = _account()
pipeline = _pipeline()
dataset = object()
with (
config_overrides_context(RBAC_ENABLED=True),
patch.object(module, "get_pipeline_dataset", return_value=dataset),
patch.object(module.RagPipelineService, "publish_customized_pipeline_template") as publish,
):
response, status = method(api, CustomizedPipelineTemplatePayload.model_validate(payload), account, pipeline)
assert (response, status) == ("", 204)
publish.assert_called_once_with(pipeline, dataset, ANY, account, session=ANY)
assert publish.call_args.args[2]["icon_info"] == expected_icon_info
def test_post_translates_missing_owned_resource_to_not_found(self) -> None:
api = PublishCustomizedPipelineTemplateApi()
method = unwrap(api.post)
payload = _payload()
with (
config_overrides_context(RBAC_ENABLED=True),
patch.object(module, "get_pipeline_dataset", return_value=object()),
patch.object(
module.RagPipelineService,
"publish_customized_pipeline_template",
side_effect=RagPipelineResourceNotFoundError("Workflow not found"),
),
pytest.raises(NotFound, match="Workflow not found"),
):
method(api, CustomizedPipelineTemplatePayload.model_validate(payload), _account(), _pipeline())
def test_post_allows_legacy_dataset_operator_after_dataset_acl(self) -> None:
api = PublishCustomizedPipelineTemplateApi()
method = unwrap(api.post)
account = _account()
account.role = TenantAccountRole.DATASET_OPERATOR
pipeline = _pipeline()
dataset = object()
payload = _payload()
with (
config_overrides_context(RBAC_ENABLED=False),
patch.object(module, "get_pipeline_dataset", return_value=dataset),
patch.object(module.DatasetService, "check_dataset_permission") as check_permission,
patch.object(module.RagPipelineService, "publish_customized_pipeline_template") as publish,
):
response = method(api, CustomizedPipelineTemplatePayload.model_validate(payload), account, pipeline)
assert response == ("", 204)
assert check_permission.call_args.args[:2] == (dataset, account)
publish.assert_called_once_with(pipeline, dataset, payload, account, session=ANY)
def test_post_rejects_legacy_non_editor_before_dataset_acl(self) -> None:
api = PublishCustomizedPipelineTemplateApi()
method = unwrap(api.post)
account = _account()
account.role = TenantAccountRole.NORMAL
with (
config_overrides_context(RBAC_ENABLED=False),
patch.object(module, "get_pipeline_dataset", return_value=object()),
patch.object(module.DatasetService, "check_dataset_permission") as check_permission,
patch.object(module.RagPipelineService, "publish_customized_pipeline_template") as publish,
pytest.raises(Forbidden),
):
method(api, CustomizedPipelineTemplatePayload.model_validate(_payload()), account, _pipeline())
check_permission.assert_not_called()
publish.assert_not_called()
def test_post_rejects_legacy_dataset_acl_before_publish(self) -> None:
api = PublishCustomizedPipelineTemplateApi()
method = unwrap(api.post)
account = _account()
account.role = TenantAccountRole.EDITOR
with (
config_overrides_context(RBAC_ENABLED=False),
patch.object(module, "get_pipeline_dataset", return_value=object()),
patch.object(
module.DatasetService,
"check_dataset_permission",
side_effect=NoPermissionError("Dataset is private"),
),
patch.object(module.RagPipelineService, "publish_customized_pipeline_template") as publish,
pytest.raises(Forbidden, match="Dataset is private"),
):
method(api, CustomizedPipelineTemplatePayload.model_validate(_payload()), account, _pipeline())
publish.assert_not_called()
def test_post_rejects_missing_legacy_dataset_before_publish(self) -> None:
api = PublishCustomizedPipelineTemplateApi()
method = unwrap(api.post)
account = _account()
account.role = TenantAccountRole.EDITOR
with (
config_overrides_context(RBAC_ENABLED=False),
patch.object(module, "get_pipeline_dataset", return_value=None),
patch.object(module.DatasetService, "check_dataset_permission") as check_permission,
patch.object(module.RagPipelineService, "publish_customized_pipeline_template") as publish,
pytest.raises(NotFound, match="Dataset not found"),
):
method(api, CustomizedPipelineTemplatePayload.model_validate(_payload()), account, _pipeline())
check_permission.assert_not_called()
publish.assert_not_called()
@@ -0,0 +1,189 @@
"""Unit tests for rag_pipeline_datasets controller endpoints."""
from __future__ import annotations
from inspect import unwrap
from unittest.mock import MagicMock, patch
import pytest
from flask import Flask
from werkzeug.exceptions import Forbidden
import services
from controllers.console import console_ns
from controllers.console.datasets.error import DatasetNameDuplicateError
from controllers.console.datasets.rag_pipeline.rag_pipeline_datasets import (
CreateEmptyRagPipelineDatasetApi,
CreateRagPipelineDatasetApi,
RagPipelineDatasetImportPayload,
)
from models.account import Account, TenantAccountRole
from services.entities.dsl_entities import ImportStatus
from services.rbac import contracts as rbac_contracts
from tests.helpers.unit.config_override import config_overrides_context
from tests.helpers.unit.model_factories import make_account
def _account(*, editor: bool) -> Account:
return make_account(
account_id=None,
name="RAG Pipeline Tester",
email="rag-pipeline@example.com",
role=TenantAccountRole.EDITOR if editor else TenantAccountRole.NORMAL,
)
class TestCreateRagPipelineDatasetApi:
def _valid_payload(self) -> dict[str, str]:
return {"yaml_content": "name: test"}
def test_post_success(self, app: Flask) -> None:
api = CreateRagPipelineDatasetApi()
method = unwrap(api.post)
payload = self._valid_payload()
user = _account(editor=True)
import_info = {
"id": "import-1",
"status": ImportStatus.COMPLETED,
"dataset_id": "ds-1",
"pipeline_id": "pipeline-1",
"current_dsl_version": "0.1.0",
"imported_dsl_version": "0.1.0",
"error": "",
}
mock_service = MagicMock()
mock_service.create_rag_pipeline_dataset.return_value = import_info
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_datasets.RagPipelineDslService",
return_value=mock_service,
),
):
response, status = method(api, RagPipelineDatasetImportPayload.model_validate(payload), "tenant-1", user)
assert status == 201
assert response == {
"id": "import-1",
"status": "completed",
"dataset_id": "ds-1",
"pipeline_id": "pipeline-1",
"current_dsl_version": "0.1.0",
"imported_dsl_version": "0.1.0",
"error": "",
}
def test_post_success_syncs_creator_under_rbac(self, app: Flask) -> None:
"""RBAC: RAG-pipeline dataset create must keep the creator bound to their own dataset.
Regression guard for the #42430 flip to automatic_include_workspace_members=False:
this path bypasses DatasetService.create_empty_dataset (which syncs the creator
internally), so the controller has to sync the creator explicitly or the creator
gets 403 on their own dataset.
"""
api = CreateRagPipelineDatasetApi()
method = unwrap(api.post)
payload = self._valid_payload()
user = _account(editor=True)
import_info = {
"id": "import-1",
"status": ImportStatus.COMPLETED,
"dataset_id": "ds-1",
"pipeline_id": "pipeline-1",
"current_dsl_version": "0.1.0",
"imported_dsl_version": "0.1.0",
"error": "",
}
mock_service = MagicMock()
mock_service.create_rag_pipeline_dataset.return_value = import_info
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
config_overrides_context(RBAC_ENABLED=True),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_datasets.RagPipelineDslService",
return_value=mock_service,
),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_datasets.enterprise_rbac_service.RBACService.DatasetAccess.replace_whitelist"
),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_datasets.enterprise_rbac_service.try_sync_creator_access_policy_member_bindings"
) as sync_creator,
):
response, status = method(api, RagPipelineDatasetImportPayload.model_validate(payload), "tenant-1", user)
assert status == 201
assert sync_creator.called, "RAG pipeline create must sync the creator's own access"
sync_creator.assert_called_once_with("tenant-1", user.id, rbac_contracts.RBACResourceType.DATASET, "ds-1")
assert response["dataset_id"] == "ds-1"
def test_post_forbidden_non_editor(self, app: Flask) -> None:
api = CreateRagPipelineDatasetApi()
method = unwrap(api.post)
payload = self._valid_payload()
user = _account(editor=False)
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
):
with pytest.raises(Forbidden):
method(api, RagPipelineDatasetImportPayload.model_validate(payload), "tenant-1", user)
def test_post_dataset_name_duplicate(self, app: Flask) -> None:
api = CreateRagPipelineDatasetApi()
method = unwrap(api.post)
payload = self._valid_payload()
user = _account(editor=True)
mock_service = MagicMock()
mock_service.create_rag_pipeline_dataset.side_effect = services.errors.dataset.DatasetNameDuplicateError()
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_datasets.RagPipelineDslService",
return_value=mock_service,
),
):
with pytest.raises(DatasetNameDuplicateError):
method(api, RagPipelineDatasetImportPayload.model_validate(payload), "tenant-1", user)
def test_post_invalid_payload(self, app: Flask) -> None:
api = CreateRagPipelineDatasetApi()
method = unwrap(api.post)
payload: dict[str, str] = {}
user = _account(editor=True)
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
):
with pytest.raises(
ValueError, match="1 validation error for RagPipelineDatasetImportPayload\\\nyaml_content"
):
method(api, RagPipelineDatasetImportPayload.model_validate(payload), "tenant-1", user)
class TestCreateEmptyRagPipelineDatasetApi:
def test_post_forbidden_non_editor(self, app: Flask) -> None:
api = CreateEmptyRagPipelineDatasetApi()
method = unwrap(api.post)
user = _account(editor=False)
with app.test_request_context("/"):
with pytest.raises(Forbidden):
method(api, "tenant-1", user)
@@ -0,0 +1,470 @@
from collections.abc import Callable, Iterator
from inspect import unwrap
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
import pytest
from flask import Flask, Response
from sqlalchemy import Engine
from sqlalchemy.orm import Session, scoped_session, sessionmaker
from controllers.common.errors import InvalidArgumentError, NotFoundError
from controllers.common.rbac import RBACResourceScope
from controllers.console import console_ns
from controllers.console.app.error import DraftWorkflowNotExist
from controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable import (
PaginationQuery,
RagPipelineEnvironmentVariableCollectionApi,
RagPipelineNodeVariableCollectionApi,
RagPipelineSystemVariableCollectionApi,
RagPipelineVariableApi,
RagPipelineVariableCollectionApi,
RagPipelineVariableResetApi,
WorkflowDraftVariablePatchPayload,
)
from controllers.console.wraps import RBACPermission
from core.workflow.llm_environment_variable import LLMEnvironmentVariable
from core.workflow.variable_prefixes import SYSTEM_VARIABLE_NODE_ID
from factories.variable_factory import build_segment
from graphon.file import File, FileTransferMethod, FileType
from graphon.variables import IntegerVariable, StringVariable
from models.account import Account, TenantAccountRole
from models.dataset import Pipeline
from models.workflow import Workflow, WorkflowDraftVariable, WorkflowType
from tests.helpers.unit.controllers.rbac_introspection import rbac_checks
from tests.helpers.unit.model_factories import make_workflow
@pytest.fixture
def sqlite_db(sqlite_engine: Engine, sqlite_session_factory: sessionmaker[Session]) -> Iterator[SimpleNamespace]:
session = scoped_session(sqlite_session_factory)
yield SimpleNamespace(engine=sqlite_engine, session=session)
session.remove()
def _pipeline(*, pipeline_id: str = "p1", tenant_id: str = "t1") -> Pipeline:
pipeline = Pipeline(tenant_id=tenant_id, name="Pipeline")
pipeline.id = pipeline_id
return pipeline
def _workflow(pipeline: Pipeline, environment_variables=()) -> Workflow:
return make_workflow(
tenant_id=pipeline.tenant_id,
app_id=pipeline.id,
workflow_type=WorkflowType.RAG_PIPELINE,
graph="{}",
environment_variables=environment_variables,
)
def _variable(*, app_id: str = "p1", user_id: str = "account-1", file_value: bool = False) -> WorkflowDraftVariable:
if file_value:
value = build_segment(
File(
file_id="file-1",
file_type=FileType.IMAGE,
transfer_method=FileTransferMethod.REMOTE_URL,
remote_url="https://example.com/image.png",
filename="image.png",
extension=".png",
mime_type="image/png",
size=1,
)
)
else:
value = build_segment("value")
return WorkflowDraftVariable.new_node_variable(
app_id=app_id,
user_id=user_id,
node_id="node-1",
name="variable",
value=value,
node_execution_id="execution-1",
)
@pytest.fixture
def editor_user() -> Account:
user = Account(name="Test User", email="user@example.com")
user.id = "account-1"
user.role = TenantAccountRole.EDITOR
return user
@pytest.fixture
def restx_config(app):
return patch.dict(app.config, {"RESTX_MASK_HEADER": "X-Fields"})
def test_rag_draft_variable_routes_require_dataset_edit_permission() -> None:
route = RagPipelineVariableApi.get
legacy_gate = unwrap(route, stop=lambda decorator: "edit_permission_required" in decorator.__code__.co_qualname)
assert "edit_permission_required" in legacy_gate.__code__.co_qualname
[check] = rbac_checks(route)
assert check.locator.scope == RBACResourceScope.DATASET
assert check.scene == RBACPermission.DATASET_EDIT
class TestRagPipelineVariableCollectionApi:
def test_get_variables_success(self, app: Flask, sqlite_db, editor_user, restx_config):
api = RagPipelineVariableCollectionApi()
method = unwrap(api.get)
pipeline = _pipeline()
rag_srv = MagicMock()
rag_srv.is_workflow_exist.return_value = True
var_list = MagicMock()
var_list.variables = []
var_list.total = None
draft_srv = MagicMock()
draft_srv.list_variables_without_values.return_value = var_list
with (
app.test_request_context("/?page=1&limit=10"),
restx_config,
patch("controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.db", sqlite_db),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.RagPipelineService",
return_value=rag_srv,
),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.WorkflowDraftVariableService",
return_value=draft_srv,
),
):
result = method(api, PaginationQuery(page=1, limit=10), editor_user, pipeline)
assert result == {"items": [], "total": None}
draft_srv.list_variables_without_values.assert_called_once_with(
app_id="p1",
page=1,
limit=10,
user_id="account-1",
)
def test_get_variables_workflow_not_exist(self, app: Flask, sqlite_db, editor_user):
api = RagPipelineVariableCollectionApi()
method = unwrap(api.get)
pipeline = _pipeline()
rag_srv = MagicMock()
rag_srv.is_workflow_exist.return_value = False
with (
app.test_request_context("/"),
patch("controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.db", sqlite_db),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.RagPipelineService",
return_value=rag_srv,
),
):
with pytest.raises(DraftWorkflowNotExist):
method(api, PaginationQuery(), editor_user, pipeline)
def test_delete_variables_success(self, app: Flask, sqlite_db, editor_user):
api = RagPipelineVariableCollectionApi()
method = unwrap(api.delete)
pipeline = _pipeline()
with (
app.test_request_context("/"),
patch("controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.db", sqlite_db),
patch("controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.WorkflowDraftVariableService"),
):
result = method(api, editor_user, pipeline)
assert isinstance(result, Response)
assert result.status_code == 204
class TestRagPipelineNodeVariableCollectionApi:
def test_get_node_variables_success(self, app: Flask, sqlite_db, editor_user, restx_config):
api = RagPipelineNodeVariableCollectionApi()
method = unwrap(api.get)
pipeline = _pipeline()
var_list = MagicMock()
var_list.variables = []
srv = MagicMock()
srv.list_node_variables.return_value = var_list
with (
app.test_request_context("/"),
restx_config,
patch("controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.db", sqlite_db),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.WorkflowDraftVariableService",
return_value=srv,
),
):
result = method(api, editor_user, pipeline, "node1")
assert result == {"items": []}
srv.list_node_variables.assert_called_once_with("p1", "node1", user_id="account-1")
def test_get_node_variables_invalid_node(self, app: Flask, editor_user):
api = RagPipelineNodeVariableCollectionApi()
method = unwrap(api.get)
with (
app.test_request_context("/"),
):
with pytest.raises(InvalidArgumentError):
method(api, editor_user, _pipeline(), SYSTEM_VARIABLE_NODE_ID)
class TestRagPipelineVariableApi:
def test_get_variable_not_found(self, app: Flask, sqlite_db, editor_user):
api = RagPipelineVariableApi()
method = unwrap(api.get)
srv = MagicMock()
srv.get_variable.return_value = None
with (
app.test_request_context("/"),
patch("controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.db", sqlite_db),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.WorkflowDraftVariableService",
return_value=srv,
),
):
with pytest.raises(NotFoundError):
method(api, editor_user, _pipeline(), "v1")
def test_patch_variable_invalid_file_payload(self, app: Flask, sqlite_db, editor_user):
api = RagPipelineVariableApi()
method = unwrap(api.patch)
pipeline = _pipeline()
variable = _variable(file_value=True)
srv = MagicMock()
srv.get_variable.return_value = variable
payload = {"value": "invalid"}
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch("controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.db", sqlite_db),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.WorkflowDraftVariableService",
return_value=srv,
),
):
with pytest.raises(InvalidArgumentError):
method(api, WorkflowDraftVariablePatchPayload.model_validate(payload), editor_user, pipeline, "v1")
def test_delete_variable_success(self, app: Flask, sqlite_db, editor_user):
api = RagPipelineVariableApi()
method = unwrap(api.delete)
pipeline = _pipeline()
variable = _variable()
srv = MagicMock()
srv.get_variable.return_value = variable
with (
app.test_request_context("/"),
patch("controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.db", sqlite_db),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.WorkflowDraftVariableService",
return_value=srv,
),
):
result = method(api, editor_user, pipeline, "v1")
assert result.status_code == 204
@pytest.mark.parametrize(
("api_type", "method", "payload"),
[
(RagPipelineVariableApi, RagPipelineVariableApi.get, None),
(
RagPipelineVariableApi,
RagPipelineVariableApi.patch,
WorkflowDraftVariablePatchPayload(name="new name"),
),
(RagPipelineVariableApi, RagPipelineVariableApi.delete, None),
(RagPipelineVariableResetApi, RagPipelineVariableResetApi.put, None),
],
)
def test_direct_variable_access_rejects_different_user(
app: Flask,
sqlite_db: SimpleNamespace,
editor_user: Account,
api_type: type[RagPipelineVariableApi] | type[RagPipelineVariableResetApi],
method: Callable[..., object],
payload: WorkflowDraftVariablePatchPayload | None,
) -> None:
api = api_type()
method = unwrap(method)
pipeline = _pipeline()
variable = _variable(user_id="account-2")
draft_service = MagicMock()
draft_service.get_variable.return_value = variable
rag_service = MagicMock()
rag_service.get_draft_workflow.return_value = _workflow(pipeline)
if payload is not None:
call_args = (api, payload, editor_user, pipeline, "v1")
else:
call_args = (api, editor_user, pipeline, "v1")
with (
app.test_request_context("/"),
patch("controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.db", sqlite_db),
patch.object(sqlite_db.session, "commit") as commit,
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.RagPipelineService",
return_value=rag_service,
),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.WorkflowDraftVariableService",
return_value=draft_service,
),
pytest.raises(NotFoundError),
):
method(*call_args)
draft_service.update_variable.assert_not_called()
draft_service.delete_variable.assert_not_called()
draft_service.reset_variable.assert_not_called()
commit.assert_not_called()
class TestRagPipelineVariableResetApi:
def test_reset_variable_success(self, app: Flask, sqlite_db, editor_user):
api = RagPipelineVariableResetApi()
method = unwrap(api.put)
pipeline = _pipeline()
workflow = _workflow(pipeline)
variable = _variable()
srv = MagicMock()
srv.get_variable.return_value = variable
srv.reset_variable.return_value = variable
rag_srv = MagicMock()
rag_srv.get_draft_workflow.return_value = workflow
with (
app.test_request_context("/"),
patch("controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.db", sqlite_db),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.RagPipelineService",
return_value=rag_srv,
),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.WorkflowDraftVariableService",
return_value=srv,
),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.dump_response",
return_value={"id": "v1"},
),
):
result = method(api, editor_user, pipeline, "v1")
assert result == {"id": "v1"}
class TestSystemAndEnvironmentVariablesApi:
def test_system_variables_success(self, app: Flask, sqlite_db, editor_user, restx_config):
api = RagPipelineSystemVariableCollectionApi()
method = unwrap(api.get)
pipeline = _pipeline()
var_list = MagicMock()
var_list.variables = []
srv = MagicMock()
srv.list_system_variables.return_value = var_list
with (
app.test_request_context("/"),
restx_config,
patch("controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.db", sqlite_db),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.WorkflowDraftVariableService",
return_value=srv,
),
):
result = method(api, editor_user, pipeline)
assert result == {"items": []}
srv.list_system_variables.assert_called_once_with("p1", user_id="account-1")
def test_environment_variables_success(self, app: Flask, editor_user):
api = RagPipelineEnvironmentVariableCollectionApi()
method = unwrap(api.get)
env_var = StringVariable(
id="e1",
name="ENV",
description="d",
selector=["env", "ENV"],
value="x",
)
pipeline = _pipeline()
workflow = _workflow(pipeline, [env_var])
rag_srv = MagicMock()
rag_srv.get_draft_workflow.return_value = workflow
with (
app.test_request_context("/"),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.RagPipelineService",
return_value=rag_srv,
),
):
result = method(api, editor_user, pipeline)
assert len(result["items"]) == 1
assert result["items"][0]["value_type"] == "string"
def test_environment_variables_preserve_number_subtype_and_llm_type(self, app: Flask, editor_user):
api = RagPipelineEnvironmentVariableCollectionApi()
method = unwrap(api.get)
number_var = IntegerVariable(
id="number",
name="NUMBER",
description="",
selector=["env", "NUMBER"],
value=1,
)
llm_var = LLMEnvironmentVariable(
id="llm",
name="MODEL",
value={"provider": "provider", "name": "model", "mode": "chat"},
selector=["env", "MODEL"],
)
pipeline = _pipeline()
rag_srv = MagicMock()
rag_srv.get_draft_workflow.return_value = _workflow(pipeline, [number_var, llm_var])
with (
app.test_request_context("/"),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_draft_variable.RagPipelineService",
return_value=rag_srv,
),
):
result = method(api, editor_user, pipeline)
assert [item["value_type"] for item in result["items"]] == ["integer", "llm"]
@@ -0,0 +1,402 @@
"""Unit tests for rag_pipeline_import controller endpoints."""
from __future__ import annotations
from collections.abc import Callable, Iterator
from inspect import unwrap
from unittest.mock import MagicMock, patch
import pytest
from flask import Flask
from sqlalchemy.orm import Session
from controllers.common.schema import JsonResponseWithStatus
from controllers.console import console_ns
from controllers.console.datasets.rag_pipeline.rag_pipeline_import import (
IncludeSecretQuery,
RagPipelineExportApi,
RagPipelineImportApi,
RagPipelineImportCheckDependenciesApi,
RagPipelineImportConfirmApi,
RagPipelineImportPayload,
)
from core.plugin.entities.plugin import PluginDependency, PluginDependencyType
from models.account import Account
from models.dataset import Pipeline
from models.engine import db
from services.enterprise import rbac_service
from services.entities.dsl_entities import CheckDependenciesResult, ImportStatus
from services.rag_pipeline.rag_pipeline_dsl_service import RagPipelineImportInfo
from tests.helpers.unit.model_factories import make_account, make_tenant
def _account() -> Account:
return make_account(name="RAG Import Tester", email="rag-import@example.com")
@pytest.fixture
def app() -> Iterator[Flask]:
app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///:memory:"
db.init_app(app)
with app.app_context():
yield app
class TestRagPipelineImportApi:
def _payload(self, mode: str = "create") -> dict[str, str]:
return {
"mode": mode,
"yaml_content": "content",
"name": "Test",
}
def test_post_success_200(self, app: Flask) -> None:
api = RagPipelineImportApi()
method = unwrap(api.post)
payload = self._payload()
user = _account()
result = RagPipelineImportInfo(
id="import-1",
status=ImportStatus.COMPLETED,
pipeline_id="pipeline-1",
dataset_id="dataset-1",
current_dsl_version="0.1.0",
imported_dsl_version="0.1.0",
)
service = MagicMock()
service.import_rag_pipeline.return_value = result
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_import.RagPipelineDslService",
return_value=service,
),
):
response, status = method(api, RagPipelineImportPayload(mode="create"), user)
assert status == 200
assert response == {
"id": "import-1",
"status": "completed",
"pipeline_id": "pipeline-1",
"dataset_id": "dataset-1",
"current_dsl_version": "0.1.0",
"imported_dsl_version": "0.1.0",
"error": "",
}
def test_post_failed_400(self, app: Flask) -> None:
api = RagPipelineImportApi()
method = unwrap(api.post)
payload = self._payload()
user = _account()
result = RagPipelineImportInfo(
id="import-1",
status=ImportStatus.FAILED,
current_dsl_version="0.1.0",
imported_dsl_version="",
error="bad dsl",
)
service = MagicMock()
service.import_rag_pipeline.return_value = result
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_import.RagPipelineDslService",
return_value=service,
),
):
response, status = method(api, RagPipelineImportPayload(mode="create"), user)
assert status == 400
assert response["status"] == "failed"
assert response["error"] == "bad dsl"
assert response["pipeline_id"] is None
assert response["dataset_id"] is None
def test_post_pending_202(self, app: Flask) -> None:
api = RagPipelineImportApi()
method = unwrap(api.post)
payload = self._payload()
user = _account()
result = RagPipelineImportInfo(
id="import-1",
status=ImportStatus.PENDING,
pipeline_id="pipeline-1",
dataset_id="dataset-1",
current_dsl_version="0.1.0",
imported_dsl_version="0.2.0",
)
service = MagicMock()
service.import_rag_pipeline.return_value = result
with (
app.test_request_context("/", json=payload),
patch.object(type(console_ns), "payload", payload),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_import.RagPipelineDslService",
return_value=service,
),
):
response, status = method(api, RagPipelineImportPayload(mode="create"), user)
assert status == 202
assert response["status"] == "pending"
assert response["pipeline_id"] == "pipeline-1"
assert response["dataset_id"] == "dataset-1"
class TestRagPipelineImportConfirmApi:
def test_confirm_success(self, app: Flask) -> None:
api = RagPipelineImportConfirmApi()
method = unwrap(api.post)
user = _account()
result = RagPipelineImportInfo(
id="import-1",
status=ImportStatus.COMPLETED,
pipeline_id="pipeline-1",
dataset_id="dataset-1",
current_dsl_version="0.1.0",
imported_dsl_version="0.1.0",
)
service = MagicMock()
service.confirm_import.return_value = result
with (
app.test_request_context("/"),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_import.RagPipelineDslService",
return_value=service,
),
):
response, status = method(api, user, "import-1")
assert status == 200
assert response["status"] == "completed"
assert response["pipeline_id"] == "pipeline-1"
def test_confirm_failed(self, app: Flask) -> None:
api = RagPipelineImportConfirmApi()
method = unwrap(api.post)
user = _account()
result = RagPipelineImportInfo(
id="import-1",
status=ImportStatus.FAILED,
current_dsl_version="0.1.0",
imported_dsl_version="",
error="missing dependency",
)
service = MagicMock()
service.confirm_import.return_value = result
with (
app.test_request_context("/"),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_import.RagPipelineDslService",
return_value=service,
),
):
response, status = method(api, user, "import-1")
assert status == 400
assert response["status"] == "failed"
assert response["error"] == "missing dependency"
class TestRagPipelineImportCheckDependenciesApi:
def test_get_success(self, app: Flask) -> None:
api = RagPipelineImportCheckDependenciesApi()
method = unwrap(api.get)
pipeline = Pipeline(tenant_id="tenant-id", name="Test Pipeline")
result = CheckDependenciesResult()
service = MagicMock()
service.check_dependencies.return_value = result
with (
app.test_request_context("/"),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_import.RagPipelineDslService",
return_value=service,
),
):
response, status = method(api, pipeline)
assert status == 200
assert response == {"leaked_dependencies": []}
def test_get_serializes_leaked_dependencies(self, app: Flask) -> None:
api = RagPipelineImportCheckDependenciesApi()
method = unwrap(api.get)
pipeline = Pipeline(tenant_id="tenant-id", name="Test Pipeline")
dependency = PluginDependency(
type=PluginDependencyType.Marketplace,
value=PluginDependency.Marketplace(
marketplace_plugin_unique_identifier="langgenius/example:0.1.0",
version="0.1.0",
),
current_identifier="langgenius/example:0.0.1",
)
service = MagicMock()
service.check_dependencies.return_value = CheckDependenciesResult(leaked_dependencies=[dependency])
with (
app.test_request_context("/"),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_import.RagPipelineDslService",
return_value=service,
),
):
response, status = method(api, pipeline)
assert status == 200
assert response == {
"leaked_dependencies": [
{
"type": "marketplace",
"value": {
"marketplace_plugin_unique_identifier": "langgenius/example:0.1.0",
"version": "0.1.0",
},
"current_identifier": "langgenius/example:0.0.1",
}
]
}
class TestRagPipelineExportApi:
def test_get_with_include_secret(self, app: Flask) -> None:
api = RagPipelineExportApi()
method = unwrap(api.get)
pipeline = Pipeline(tenant_id="tenant-id", name="Test Pipeline")
service = MagicMock()
service.export_rag_pipeline_dsl.return_value = "yaml: data"
with (
app.test_request_context("/?include_secret=true"),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_import.RagPipelineDslService",
return_value=service,
),
):
response, status = method(api, IncludeSecretQuery(), pipeline)
assert status == 200
assert response == {"data": "yaml: data"}
@pytest.mark.parametrize("confirm", [False, True])
@pytest.mark.parametrize(
("import_status", "created", "dataset_id", "rbac_enabled", "commit_fails", "expected_calls"),
[
(ImportStatus.COMPLETED, True, "dataset-1", True, False, 1),
(ImportStatus.COMPLETED_WITH_WARNINGS, True, "dataset-1", True, False, 1),
(ImportStatus.COMPLETED, False, "dataset-1", True, False, 0),
(ImportStatus.PENDING, True, "dataset-1", True, False, 0),
(ImportStatus.FAILED, True, "dataset-1", True, False, 0),
(ImportStatus.COMPLETED, True, None, True, False, 0),
(ImportStatus.COMPLETED, True, "dataset-1", False, False, 0),
(ImportStatus.COMPLETED, True, "dataset-1", True, True, 0),
],
)
def test_creator_binding_only_after_successful_new_dataset_commit(
app: Flask,
config_overrides: Callable[..., None],
confirm: bool,
import_status: ImportStatus,
created: bool,
dataset_id: str | None,
rbac_enabled: bool,
commit_fails: bool,
expected_calls: int,
) -> None:
config_overrides(RBAC_ENABLED=rbac_enabled)
user = make_account(account_id="creator-1", tenant=make_tenant(tenant_id="tenant-1"))
result = RagPipelineImportInfo.model_validate(
{
"id": "import-1",
"status": import_status,
"dataset_id": dataset_id,
"dataset_created": created,
}
)
service = MagicMock()
service.import_rag_pipeline.return_value = result
service.confirm_import.return_value = result
events: list[str] = []
session = Session(db.engine, expire_on_commit=False)
commit = session.commit
close = session.close
def commit_session() -> None:
if commit_fails:
raise RuntimeError("commit failed")
commit()
events.append("commit")
def close_session() -> None:
close()
events.append("close")
def sync_binding(*_args: object, **_kwargs: object) -> list[object]:
events.append("sync")
return []
with (
app.test_request_context("/"),
patch("controllers.console.datasets.rag_pipeline.rag_pipeline_import.Session", return_value=session),
patch(
"controllers.console.datasets.rag_pipeline.rag_pipeline_import.RagPipelineDslService", return_value=service
),
patch.object(session, "commit", side_effect=commit_session),
patch.object(session, "close", side_effect=close_session),
patch.object(
rbac_service.RBACService.AccessPolicies,
"sync_creator_access_policy_member_bindings",
side_effect=sync_binding,
) as sync,
patch.object(rbac_service.RBACService.DatasetAccess, "replace_whitelist") as replace,
):
def invoke() -> JsonResponseWithStatus:
if confirm:
api = RagPipelineImportConfirmApi()
return unwrap(api.post)(api, user, "import-1")
api = RagPipelineImportApi()
return unwrap(api.post)(api, RagPipelineImportPayload(mode="yaml-content"), user)
if commit_fails:
with pytest.raises(RuntimeError, match="commit failed"):
invoke()
else:
response, _ = invoke()
assert "dataset_created" not in response
assert sync.call_count == expected_calls
if expected_calls:
assert events == ["commit", "close", "sync"]
sync.assert_called_once_with(
"tenant-1",
"creator-1",
resource_type=rbac_service.RBACResourceType.DATASET,
resource_id="dataset-1",
)
replace.assert_not_called()
@@ -0,0 +1,711 @@
from __future__ import annotations
import ast
from collections.abc import Callable
from dataclasses import dataclass, field
from datetime import UTC, datetime
from inspect import unwrap
from pathlib import Path
from typing import TYPE_CHECKING, cast
import pytest
from flask import Flask
from flask.testing import FlaskClient
from controllers.common.errors import NotFoundError
from controllers.common.rbac import DatasetId
from controllers.console import api as console_api
from controllers.console import console_ns
from controllers.console.app.error import ProviderNotInitializeError
from controllers.console.datasets import data_source as data_source_controller
from controllers.console.datasets.error import IndexingEstimateError
from core.entities.knowledge_entities import IndexingEstimate
from core.rbac import RBACPermission
from enums import DeploymentEdition
from libs.external_api import ExternalApi
from libs.login import AccountWithTenant
from machinery.context import RequestContext
from services.credentials.refresh import CredentialRefreshUnavailableError
from services.data_source.binding_application_service import (
BindingMutationResult,
DataSourceBindingApplicationService,
)
from services.data_source.entities.notion_import import (
AuthorizedNotionPage,
NotionPageIcon,
NotionPageType,
NotionWorkspace,
)
from services.data_source.entities.oauth import DataSourceBindingSummary
from services.data_source.notion_import_application_service import NotionImportApplicationService
from services.knowledge.dataset_access import DatasetAccessRecord, DatasetAccessService, DatasetAccessSnapshot
from services.knowledge.document_sync import DocumentSyncApplicationService, SyncDocumentRecord
from services.knowledge.entities.indexing_estimate import (
NewSourcesEstimateCommand,
NotionEstimateSource,
)
from services.knowledge.indexing.estimate import (
DatasetEstimateRecord,
EstimateDocumentRecord,
EstimateSourceNotFoundError,
IndexingEstimateCredentialUnavailableError,
IndexingEstimateExecutionError,
IndexingEstimateProviderUnavailableError,
)
from services.knowledge.resource_scope import DatasetRef, DocumentRef
from tests.helpers.unit.controllers.rbac_introspection import rbac_checks
"""Guard all migrated dataset endpoints against transport/persistence regressions."""
class TestApplicationBoundariesCases:
@staticmethod
@pytest.mark.parametrize(
("filename", "count"),
[("data_source.py", 7), ("datasets.py", 25), ("datasets_document.py", 24), ("external.py", 8)],
)
def test_every_endpoint_declares_admission_context_and_application_service(filename: str, count: int) -> None:
root = Path(__file__).resolve().parents[5]
tree = ast.parse((root / "controllers/console/datasets" / filename).read_text())
# This namespace package is not traversed by import-linter's package graph.
forbidden = (
"sqlalchemy",
"repositories",
"controllers.common.session",
"libs.login",
"services.knowledge.dataset_service",
"services.knowledge.external.service",
"services.hit_testing_service",
"services.knowledge.dataset_read_service",
"services.knowledge.datasets.adapters",
"services.knowledge.documents.adapters",
"services.knowledge.external.adapters",
)
for node in ast.walk(tree):
modules = (
[node.module or ""]
if isinstance(node, ast.ImportFrom)
else [item.name for item in node.names]
if isinstance(node, ast.Import)
else []
)
for module in modules:
assert not any(module == name or module.startswith(name + ".") for name in forbidden), module
endpoints = [
method
for resource in tree.body
if isinstance(resource, ast.ClassDef)
for method in resource.body
if isinstance(method, ast.FunctionDef) and method.name in {"get", "post", "patch", "put", "delete"}
]
assert len(endpoints) == count
for endpoint in endpoints:
assert any(
isinstance(d, ast.Call) and ast.unparse(d.func) == "console_account_admission"
for d in endpoint.decorator_list
), endpoint.name
assert any(
arg.arg == "request_context"
and arg.annotation is not None
and ast.unparse(arg.annotation) == "RequestContext"
for arg in endpoint.args.args
), endpoint.name
assert any(
isinstance(n, ast.Call) and ast.unparse(n.func) == "application_services" for n in ast.walk(endpoint)
), endpoint.name
assert not {"session", "current_user", "current_tenant_id"}.intersection(
arg.arg for arg in endpoint.args.args
)
# Importing the module registers only the resources under test on console_ns.
if TYPE_CHECKING:
from models import Account
TENANT_ID = "11111111-1111-1111-1111-111111111111"
ACCOUNT_ID = "22222222-2222-2222-2222-222222222222"
BINDING_ID = "33333333-3333-3333-3333-333333333333"
DATASET_ID = "44444444-4444-4444-4444-444444444444"
DOCUMENT_ID = "55555555-5555-5555-5555-555555555555"
PAGE_ID = "66666666-6666-6666-6666-666666666666"
FOREIGN_DATASET_ID = "77777777-7777-7777-7777-777777777777"
@dataclass
class RecordingBindingStore:
bindings: tuple[DataSourceBindingSummary, ...] = ()
mutations: list[tuple[str, str, bool]] = field(default_factory=list)
mutation_result: BindingMutationResult = "updated"
def list_enabled_bindings(self, *, workspace_id: str) -> tuple[DataSourceBindingSummary, ...]:
assert workspace_id == TENANT_ID
return self.bindings
def change_disabled_state(
self,
*,
workspace_id: str,
binding_id: str,
disabled: bool,
) -> BindingMutationResult:
self.mutations.append((workspace_id, binding_id, disabled))
return self.mutation_result
@dataclass
class DatasetCatalog:
record: DatasetAccessRecord
def get_access_snapshot(
self,
*,
workspace_id: str,
dataset_id: str,
actor_id: str,
) -> DatasetAccessSnapshot | None:
assert actor_id == ACCOUNT_ID
if workspace_id != self.record.workspace_id or dataset_id != self.record.id:
return None
return DatasetAccessSnapshot(dataset=self.record, actor_has_partial_access=False)
def get_estimate_record(self, dataset_ref: DatasetRef) -> DatasetEstimateRecord | None:
if dataset_ref != DatasetRef(self.record.workspace_id, self.record.id):
return None
return DatasetEstimateRecord(
id=self.record.id,
workspace_id=self.record.workspace_id,
indexing_technique="economy",
)
def is_notion_dataset(self, dataset_ref: DatasetRef) -> bool:
return dataset_ref == DatasetRef(self.record.workspace_id, self.record.id)
class OwnerWorkspaceRoles:
def get_legacy_role(self, *, workspace_id: str, account_id: str) -> str | None:
assert workspace_id == TENANT_ID
assert account_id == ACCOUNT_ID
return "owner"
@dataclass
class KnowledgeDocuments:
bound_page_ids: frozenset[str] = frozenset()
active_refs: tuple[DocumentRef, ...] = ()
def list_bound_notion_page_ids(self, dataset_ref: DatasetRef) -> frozenset[str]:
assert dataset_ref == DatasetRef(TENANT_ID, DATASET_ID)
return self.bound_page_ids
def list_active_notion_refs(self, dataset_ref: DatasetRef) -> tuple[DocumentRef, ...]:
assert dataset_ref == DatasetRef(TENANT_ID, DATASET_ID)
return self.active_refs
def get_estimate_document(self, document_ref: DocumentRef) -> EstimateDocumentRecord | None:
if document_ref.document_id != DOCUMENT_ID:
return None
return EstimateDocumentRecord(
id=DOCUMENT_ID,
workspace_id=TENANT_ID,
dataset_id=DATASET_ID,
data_source_type="notion_import",
data_source_info=None,
indexing_status="waiting",
doc_form="text_model",
doc_language="English",
dataset_process_rule_id=None,
)
def list_estimate_documents_by_batch(
self, dataset_ref: DatasetRef, batch: str
) -> tuple[EstimateDocumentRecord, ...]:
document = self.get_estimate_document(dataset_ref.document(DOCUMENT_ID))
if document is None or batch != "batch":
return ()
return (document,)
def get_sync_document(self, document_ref: DocumentRef) -> SyncDocumentRecord | None:
if document_ref.document_id != DOCUMENT_ID:
return None
return SyncDocumentRecord(id=DOCUMENT_ID, data_source_type="notion_import")
@dataclass
class RecordingNotionSource:
workspaces: tuple[NotionWorkspace, ...]
list_calls: list[tuple[str, str, str]] = field(default_factory=list)
preview_calls: list[tuple[str, str, str, str, str]] = field(default_factory=list)
error: Exception | None = None
def list_authorized_pages(
self,
*,
workspace_id: str,
actor_id: str,
credential_id: str,
) -> tuple[NotionWorkspace, ...]:
self.list_calls.append((workspace_id, actor_id, credential_id))
if self.error is not None:
raise self.error
return self.workspaces
def preview_page(
self,
*,
workspace_id: str,
actor_id: str,
credential_id: str,
page_id: str,
page_type: str,
) -> str:
self.preview_calls.append((workspace_id, actor_id, credential_id, page_id, page_type))
if self.error is not None:
raise self.error
return "preview text"
@dataclass
class RecordingEstimateService:
calls: list[tuple[RequestContext, NewSourcesEstimateCommand]] = field(default_factory=list)
error: Exception | None = None
def estimate_new_sources(self, context: RequestContext, command: NewSourcesEstimateCommand) -> IndexingEstimate:
self.calls.append((context, command))
if self.error is not None:
raise self.error
return IndexingEstimate(total_segments=3, preview=[])
@dataclass
class RecordingDispatcher:
calls: list[tuple[str, str]] = field(default_factory=list)
def dispatch(self, *, dataset_id: str, document_id: str) -> None:
self.calls.append((dataset_id, document_id))
@dataclass(frozen=True)
class DataSourceApplicationServices:
bindings: DataSourceBindingApplicationService
notion_imports: NotionImportApplicationService
@dataclass(frozen=True)
class KnowledgeApplicationServices:
document_sync: DocumentSyncApplicationService
indexing_estimates: RecordingEstimateService
@dataclass(frozen=True)
class ApplicationServiceRegistry:
data_sources: DataSourceApplicationServices
knowledge: KnowledgeApplicationServices
@dataclass(frozen=True)
class ControllerCollaborators:
client: FlaskClient
account: AdmittedAccount
bindings: RecordingBindingStore
notion_source: RecordingNotionSource
estimates: RecordingEstimateService
dispatcher: RecordingDispatcher
@dataclass
class AdmittedAccount:
id: str
role: str
status: str
@pytest.fixture(scope="module")
def console_app() -> Flask:
"""One app with the console namespace, which takes a few hundred milliseconds to mount.
Each test registers its own ``extensions["application_services"]`` for the duration of that test.
"""
app = Flask(__name__)
app.config.update(TESTING=False, PROPAGATE_EXCEPTIONS=False)
api = ExternalApi(app)
api.error_handlers = console_api.error_handlers.copy()
api.add_namespace(console_ns, path="/console/api")
return app
class TestDataSourceCases:
@staticmethod
@pytest.fixture
def collaborators(
console_app: Flask,
config_overrides: Callable[..., None],
monkeypatch: pytest.MonkeyPatch,
) -> ControllerCollaborators:
config_overrides(
DEPLOYMENT_EDITION=DeploymentEdition.CLOUD,
LOGIN_DISABLED=True,
RBAC_ENABLED=False,
CONSOLE_API_URL="https://console-api.example.com",
)
account = AdmittedAccount(id=ACCOUNT_ID, role="owner", status="active")
account_with_tenant = AccountWithTenant(account=cast("Account", account), tenant_id=TENANT_ID)
monkeypatch.setattr(
"controllers.console.flask_admission.current_account_with_tenant",
lambda: account_with_tenant,
)
monkeypatch.setattr(
"controllers.console.wraps.current_account_with_tenant",
lambda: account_with_tenant,
)
dataset = DatasetAccessRecord(
id=DATASET_ID,
workspace_id=TENANT_ID,
maintainer_id=ACCOUNT_ID,
permission="only_me",
)
dataset_catalog = DatasetCatalog(dataset)
dataset_access = DatasetAccessService(
datasets=dataset_catalog,
workspace_roles=OwnerWorkspaceRoles(),
legacy_permissions_enabled=True,
)
documents = KnowledgeDocuments(
bound_page_ids=frozenset({PAGE_ID}),
active_refs=(DatasetRef(TENANT_ID, DATASET_ID).document(DOCUMENT_ID),),
)
bindings = RecordingBindingStore()
notion_source = RecordingNotionSource(
workspaces=(
NotionWorkspace(
workspace_id="notion-workspace-1",
workspace_name="One",
workspace_icon=None,
pages=(
AuthorizedNotionPage(
page_id=PAGE_ID,
page_name="Page one",
page_icon=NotionPageIcon(type="emoji", emoji="📄"),
parent_id=None,
page_type=NotionPageType.PAGE,
),
),
),
NotionWorkspace(
workspace_id="notion-workspace-2",
workspace_name="Two",
workspace_icon=None,
pages=(),
),
)
)
estimates = RecordingEstimateService()
dispatcher = RecordingDispatcher()
services = ApplicationServiceRegistry(
data_sources=DataSourceApplicationServices(
bindings=DataSourceBindingApplicationService(bindings=bindings),
notion_imports=NotionImportApplicationService(
dataset_access=dataset_access,
datasets=dataset_catalog,
documents=documents,
source=notion_source,
),
),
knowledge=KnowledgeApplicationServices(
document_sync=DocumentSyncApplicationService(
dataset_access=dataset_access,
documents=documents,
dispatcher=dispatcher,
),
indexing_estimates=estimates,
),
)
monkeypatch.setitem(console_app.extensions, "application_services", services)
return ControllerCollaborators(
client=console_app.test_client(),
account=account,
bindings=bindings,
notion_source=notion_source,
estimates=estimates,
dispatcher=dispatcher,
)
@staticmethod
def test_integration_collection_only_exposes_get(collaborators: ControllerCollaborators) -> None:
client = collaborators.client
assert client.get("/console/api/data-source/integrates").status_code == 200
assert client.patch("/console/api/data-source/integrates").status_code == 405
@staticmethod
@pytest.mark.parametrize(
("method", "path"),
[
("get", "/console/api/data-source/integrates"),
("patch", f"/console/api/data-source/integrates/{BINDING_ID}/enable"),
],
)
def test_integration_management_rejects_non_admin_role(
collaborators: ControllerCollaborators,
method: str,
path: str,
) -> None:
collaborators.account.role = "editor"
assert collaborators.client.open(path, method=method.upper()).status_code == 403
@staticmethod
def test_integration_management_enforces_workspace_credential_permission(
collaborators: ControllerCollaborators,
config_overrides: Callable[..., None],
monkeypatch: pytest.MonkeyPatch,
) -> None:
config_overrides(RBAC_ENABLED=True)
calls: list[dict[str, object]] = []
def record_access(tenant_id: str, account_id: str, **requirement: object) -> bool:
calls.append({"tenant_id": tenant_id, "account_id": account_id, **requirement})
return True
monkeypatch.setattr("controllers.common.rbac.checks.RBACService.CheckAccess.check", record_access)
list_response = collaborators.client.get("/console/api/data-source/integrates")
mutation_response = collaborators.client.patch(f"/console/api/data-source/integrates/{BINDING_ID}/enable")
assert list_response.status_code == 200
assert mutation_response.status_code == 200
assert calls == [
{
"tenant_id": TENANT_ID,
"account_id": ACCOUNT_ID,
"scene": RBACPermission.CREDENTIAL_MANAGE,
"resource_type": None,
"resource_id": None,
},
{
"tenant_id": TENANT_ID,
"account_id": ACCOUNT_ID,
"scene": RBACPermission.CREDENTIAL_MANAGE,
"resource_type": None,
"resource_id": None,
},
]
@staticmethod
@pytest.mark.parametrize(("action", "disabled"), [("enable", False), ("disable", True)])
def test_integration_item_only_exposes_patch_and_rejects_unknown_action(
collaborators: ControllerCollaborators,
action: str,
disabled: bool,
) -> None:
client = collaborators.client
item_path = f"/console/api/data-source/integrates/{BINDING_ID}/{action}"
assert client.get(item_path).status_code == 405
response = client.patch(item_path)
assert response.status_code == 200
assert response.get_json() == {"result": "success"}
assert collaborators.bindings.mutations == [(TENANT_ID, BINDING_ID, disabled)]
invalid = client.patch(f"/console/api/data-source/integrates/{BINDING_ID}/remove")
assert invalid.status_code == 400
assert invalid.get_json()["code"] == "invalid_action"
assert len(collaborators.bindings.mutations) == 1
@staticmethod
def test_integration_list_serializes_application_result_and_http_link(
collaborators: ControllerCollaborators,
) -> None:
collaborators.bindings.bindings = (
DataSourceBindingSummary(
id=BINDING_ID,
provider="notion",
created_at=datetime(2026, 5, 25, 1, 2, 3, tzinfo=UTC),
disabled=False,
source_info={
"workspace_name": "Workspace",
"workspace_id": "workspace-1",
"workspace_icon": None,
"pages": [],
"total": 0,
},
),
)
response = collaborators.client.get("/console/api/data-source/integrates")
assert response.status_code == 200
assert response.get_json()["data"][0] == {
"id": BINDING_ID,
"provider": "notion",
"created_at": 1779670923,
"is_bound": True,
"disabled": False,
"source_info": {
"workspace_name": "Workspace",
"workspace_id": "workspace-1",
"workspace_icon": None,
"pages": [],
"total": 0,
},
"link": "https://console-api.example.com/console/api/oauth/data-source/notion",
}
@staticmethod
def test_notion_list_preserves_workspace_groups_and_bound_state(collaborators: ControllerCollaborators) -> None:
response = collaborators.client.get(
"/console/api/notion/pre-import/pages",
query_string={"credential_id": "credential-1", "dataset_id": DATASET_ID},
)
assert response.status_code == 200
payload = response.get_json()["notion_info"]
assert [workspace["workspace_id"] for workspace in payload] == [
"notion-workspace-1",
"notion-workspace-2",
]
assert payload[0]["pages"][0]["is_bound"] is True
assert payload[0]["pages"][0]["type"] == "page"
assert "page_type" not in payload[0]["pages"][0]
assert collaborators.notion_source.list_calls == [(TENANT_ID, ACCOUNT_ID, "credential-1")]
@staticmethod
def test_notion_list_accepts_empty_dataset_id_for_new_dataset(collaborators: ControllerCollaborators) -> None:
response = collaborators.client.get(
"/console/api/notion/pre-import/pages",
query_string={"credential_id": "credential-1", "dataset_id": ""},
)
assert response.status_code == 200
assert response.get_json()["notion_info"][0]["pages"][0]["is_bound"] is False
assert collaborators.notion_source.list_calls == [(TENANT_ID, ACCOUNT_ID, "credential-1")]
@staticmethod
@pytest.mark.parametrize("page_type", ["page", "database"])
def test_notion_preview_validates_page_type_and_delegates(
collaborators: ControllerCollaborators, page_type: str
) -> None:
response = collaborators.client.get(
f"/console/api/notion/pages/{PAGE_ID}/{page_type}/preview",
query_string={"credential_id": "credential-1"},
)
invalid = collaborators.client.get(
f"/console/api/notion/pages/{PAGE_ID}/collection/preview",
query_string={"credential_id": "credential-1"},
)
assert response.status_code == 200
assert response.get_json() == {"content": "preview text"}
assert invalid.status_code == 400
assert invalid.get_json()["code"] == "invalid_param"
assert collaborators.notion_source.preview_calls == [
(TENANT_ID, ACCOUNT_ID, "credential-1", PAGE_ID, page_type)
]
@staticmethod
@pytest.mark.parametrize("path", ["/notion/pre-import/pages", f"/notion/pages/{PAGE_ID}/page/preview"])
def test_notion_refresh_unavailable_returns_retryable_response(
collaborators: ControllerCollaborators, path: str
) -> None:
error = CredentialRefreshUnavailableError()
collaborators.notion_source.error = error
response = collaborators.client.get(f"/console/api{path}", query_string={"credential_id": "credential-1"})
assert response.status_code == 503
assert response.get_json() == {
"code": "service_unavailable",
"message": str(error),
"status": 503,
}
@staticmethod
def test_notion_estimate_maps_nested_payload_to_shared_command(collaborators: ControllerCollaborators) -> None:
response = collaborators.client.post(
"/console/api/datasets/notion-indexing-estimate",
json={
"notion_info_list": [
{
"workspace_id": "notion-workspace-1",
"credential_id": "credential-1",
"pages": [{"page_id": PAGE_ID, "type": "page"}],
}
],
"process_rule": {"mode": "automatic"},
"doc_form": "text_model",
"doc_language": "English",
},
)
assert response.status_code == 200
assert response.get_json()["total_segments"] == 3
context, command = collaborators.estimates.calls[0]
assert context.active_workspace_id == TENANT_ID
assert context.account_id == ACCOUNT_ID
assert command.process_rule == {"mode": "automatic"}
source = command.sources[0]
assert isinstance(source, NotionEstimateSource)
assert source.credential_id == "credential-1"
assert source.page_id == PAGE_ID
@staticmethod
@pytest.mark.parametrize(
("error", "expected_http_error"),
[
(IndexingEstimateCredentialUnavailableError(), NotFoundError),
(EstimateSourceNotFoundError("page-1"), NotFoundError),
(IndexingEstimateProviderUnavailableError(), ProviderNotInitializeError),
(IndexingEstimateExecutionError(), IndexingEstimateError),
],
)
def test_notion_estimate_maps_application_errors(
error: Exception,
expected_http_error: type[Exception],
collaborators: ControllerCollaborators,
) -> None:
collaborators.estimates.error = error
api = data_source_controller.DataSourceNotionIndexingEstimateApi()
method = unwrap(api.post)
payload = data_source_controller.NotionEstimatePayload.model_validate(
{
"notion_info_list": [
{
"workspace_id": "notion-workspace",
"credential_id": "credential-1",
"pages": [{"page_id": "page-1", "type": "page"}],
}
],
"process_rule": {"mode": "automatic"},
}
)
context = RequestContext("request-1", None, "account-1", "workspace-1")
with collaborators.client.application.app_context(), pytest.raises(expected_http_error):
method(api, payload, context)
@staticmethod
def test_sync_routes_dispatch_only_application_selected_documents(collaborators: ControllerCollaborators) -> None:
dataset_response = collaborators.client.get(f"/console/api/datasets/{DATASET_ID}/notion/sync")
document_response = collaborators.client.get(
f"/console/api/datasets/{DATASET_ID}/documents/{DOCUMENT_ID}/notion/sync"
)
assert dataset_response.status_code == 200
assert dataset_response.get_json() == {"result": "success"}
assert document_response.status_code == 200
assert document_response.get_json() == {"result": "success"}
assert collaborators.dispatcher.calls == [(DATASET_ID, DOCUMENT_ID), (DATASET_ID, DOCUMENT_ID)]
@staticmethod
def test_sync_route_does_not_dispatch_cross_workspace_dataset(collaborators: ControllerCollaborators) -> None:
response = collaborators.client.get(f"/console/api/datasets/{FOREIGN_DATASET_ID}/notion/sync")
assert response.status_code == 404
assert response.get_json()["code"] == "not_found"
assert collaborators.dispatcher.calls == []
@staticmethod
@pytest.mark.parametrize(
"resource",
[data_source_controller.DataSourceNotionDatasetSyncApi, data_source_controller.DataSourceNotionDocumentSyncApi],
)
def test_notion_sync_requires_dataset_edit_permission(resource):
[check] = rbac_checks(resource.get)
assert check.scene is RBACPermission.DATASET_EDIT
assert isinstance(check.locator, DatasetId)
@@ -0,0 +1,597 @@
import datetime
from dataclasses import dataclass
from inspect import unwrap
from types import SimpleNamespace
from unittest.mock import MagicMock, create_autospec, patch
from uuid import UUID
import pytest
from werkzeug.exceptions import BadRequest, Conflict, Forbidden, NotFound
import services
from controllers.common.errors import InvalidArgumentError, NotFoundError
from controllers.common.rbac import DatasetId, RBACPermission, Workspace
from controllers.console.app.error import ProviderNotInitializeError
from controllers.console.datasets import datasets as controller
from controllers.console.datasets.datasets import (
DatasetApi,
DatasetApiBaseUrlApi,
DatasetApiKeyApi,
DatasetAutoDisableLogApi,
DatasetCreatePayload,
DatasetEnableApiApi,
DatasetErrorDocs,
DatasetIndexingEstimateApi,
DatasetIndexingStatusApi,
DatasetKnowledgeFSUpgradeApi,
DatasetKnowledgeFSUpgradeJobApi,
DatasetKnowledgeFSUpgradeJobsApi,
DatasetListApi,
DatasetPermissionUserListApi,
DatasetQueryApi,
DatasetRelatedAppListApi,
DatasetRetrievalSettingApi,
DatasetRetrievalSettingMockApi,
DatasetUpdatePayload,
DatasetUseCheckApi,
IndexingEstimatePayload,
_new_estimate_sources,
)
from controllers.console.datasets.error import (
DatasetAccessDeniedRequestError,
DatasetNameDuplicateError,
IndexingEstimateError,
KnowledgeFSUpgradeModelsUnavailableHTTPError,
)
from machinery.context import RequestContext
from models.knowledge_fs import KnowledgeFSUpgradeJob, KnowledgeFSUpgradeJobStatus, KnowledgeFSUpgradeStage
from services.data_source.entities.notion_import import NotionPageType
from services.dataset_knowledge_fs_upgrade_service import (
KnowledgeFSUpgradeConflictError,
KnowledgeFSUpgradeModelsUnavailableError,
KnowledgeFSUpgradeNotFoundError,
)
from services.knowledge.dataset_access import DatasetAccessDeniedError, DatasetNotFoundError
from services.knowledge.datasets.application import DatasetApplicationService, DatasetListFilter
from services.knowledge.datasets.upgrades import (
KnowledgeFSUpgradeUnavailableError,
KnowledgeUpgradeApplicationService,
)
from services.knowledge.entities.indexing_estimate import (
NotionEstimateSource,
UploadFileEstimateSource,
WebsiteEstimateSource,
)
from services.knowledge.indexing.estimate import (
EstimateSourceNotFoundError,
IndexingEstimateCredentialUnavailableError,
IndexingEstimateExecutionError,
IndexingEstimateProviderUnavailableError,
UnsupportedEstimateSourceError,
)
from services.knowledge_fs.product_dto import (
KnowledgeFSUpgradeModelIssueResponse,
KnowledgeFSUpgradeModelsPayload,
KnowledgeFSUpgradePreparationResponse,
)
from tests.helpers.unit.controllers.rbac_introspection import rbac_checks
CONTEXT = RequestContext("request-1", None, "account-1", "tenant-1")
DATASET_ID = UUID(int=1)
def test_dataset_delete_requires_dataset_delete_permission() -> None:
[check] = rbac_checks(DatasetApi.delete)
assert check.scene is RBACPermission.DATASET_DELETE
assert isinstance(check.locator, DatasetId)
@pytest.fixture
def datasets(monkeypatch):
service = create_autospec(DatasetApplicationService, instance=True, spec_set=True)
monkeypatch.setattr(
controller, "application_services", lambda: SimpleNamespace(knowledge=SimpleNamespace(datasets=service))
)
return service
@pytest.mark.parametrize(
("resource", "operation"),
[
(DatasetApi, lambda service: service.get_dataset),
(DatasetUseCheckApi, lambda service: service.is_in_use),
(DatasetQueryApi, lambda service: service.queries),
(DatasetRelatedAppListApi, lambda service: service.related_apps),
(DatasetIndexingStatusApi, lambda service: service.indexing_status),
(DatasetErrorDocs, lambda service: service.error_documents),
(DatasetPermissionUserListApi, lambda service: service.partial_members),
(DatasetAutoDisableLogApi, lambda service: service.auto_disable_logs),
],
)
@pytest.mark.parametrize(
("error", "http_error"), [(DatasetNotFoundError(), NotFound), (DatasetAccessDeniedError(), Forbidden)]
)
def test_scoped_reads_pass_context_and_map_access_errors(app, datasets, resource, operation, error, http_error):
method = operation(datasets)
method.side_effect = error
with app.test_request_context("/"), pytest.raises(http_error):
unwrap(resource.get)(resource(), CONTEXT, DATASET_ID)
assert method.call_args.args == (CONTEXT,)
assert method.call_args.kwargs["dataset_id"] == str(DATASET_ID)
def test_list_parses_repeated_filters_and_serializes_page(app, datasets):
datasets.list_datasets.return_value = {"data": [], "page": 2, "limit": 3, "total": 4, "has_more": False}
with app.test_request_context(
"/?page=2&limit=3&ids=a&ids=b&tag_ids=x&tag_ids=y&creator_ids=c&include_all=true&keyword=term"
):
result, status = unwrap(DatasetListApi.get)(DatasetListApi(), CONTEXT)
datasets.list_datasets.assert_called_once_with(
CONTEXT,
DatasetListFilter(
page=2,
limit=3,
ids=["a", "b"],
tag_ids=["x", "y"],
creator_ids=["c"],
include_all=True,
keyword="term",
),
)
assert status == 200
assert result == datasets.list_datasets.return_value
def test_patch_does_not_turn_omitted_fields_into_updates(datasets):
datasets.update_dataset.side_effect = DatasetNotFoundError()
with pytest.raises(NotFound):
unwrap(DatasetApi.patch)(DatasetApi(), DatasetUpdatePayload(name="Changed"), CONTEXT, DATASET_ID)
datasets.update_dataset.assert_called_once_with(CONTEXT, dataset_id=str(DATASET_ID), values={"name": "Changed"})
def test_duplicate_name_is_mapped_at_transport_on_create(datasets):
datasets.create_dataset.side_effect = services.errors.dataset.DatasetNameDuplicateError()
with pytest.raises(DatasetNameDuplicateError):
unwrap(DatasetListApi.post)(DatasetListApi(), DatasetCreatePayload(name="Duplicate"), CONTEXT)
def test_delete_success_returns_empty_204(datasets):
assert unwrap(DatasetApi.delete)(DatasetApi(), CONTEXT, DATASET_ID) == ("", 204)
datasets.delete_dataset.assert_called_once_with(CONTEXT, dataset_id=str(DATASET_ID))
def test_request_base_url_and_explicit_status_are_forwarded(app, datasets):
datasets.api_base_url.return_value = "https://api.example/v1"
with app.test_request_context("/", base_url="https://console.example/"):
assert unwrap(DatasetApiBaseUrlApi.get)(DatasetApiBaseUrlApi(), CONTEXT) == {
"api_base_url": "https://api.example/v1"
}
datasets.api_base_url.assert_called_once_with(CONTEXT, request_base_url="https://console.example")
assert unwrap(DatasetEnableApiApi.post)(DatasetEnableApiApi(), CONTEXT, DATASET_ID, "disable") == (
{"result": "success"},
200,
)
datasets.set_api_enabled.assert_called_once_with(CONTEXT, dataset_id=str(DATASET_ID), status="disable")
def test_retrieval_settings_forward_mock_flag(datasets):
datasets.retrieval_settings.return_value = {"retrieval_method": ["semantic_search"]}
assert (
unwrap(DatasetRetrievalSettingApi.get)(DatasetRetrievalSettingApi(), CONTEXT)
== datasets.retrieval_settings.return_value
)
unwrap(DatasetRetrievalSettingMockApi.get)(DatasetRetrievalSettingMockApi(), CONTEXT, "milvus")
datasets.retrieval_settings.assert_called_with(CONTEXT, vector_type="milvus", is_mock=True)
def test_new_estimate_sources_maps_each_supported_transport_shape() -> None:
upload_sources = _new_estimate_sources(
{"data_source_type": "upload_file", "file_info_list": {"file_ids": ["file-1", "file-2"]}}
)
notion_sources = _new_estimate_sources(
{
"data_source_type": "notion_import",
"notion_info_list": [
{
"workspace_id": "notion-workspace",
"credential_id": "credential-1",
"pages": [{"page_id": "page-1", "type": "page"}],
}
],
}
)
website_sources = _new_estimate_sources(
{
"data_source_type": "website_crawl",
"website_info_list": {
"provider": "firecrawl",
"job_id": "job-1",
"urls": ["https://example.com/a", "https://example.com/b"],
"only_main_content": True,
},
}
)
assert upload_sources == (UploadFileEstimateSource("file-1"), UploadFileEstimateSource("file-2"))
assert notion_sources == (NotionEstimateSource("notion-workspace", "page-1", NotionPageType.PAGE, "credential-1"),)
assert website_sources == (
WebsiteEstimateSource("firecrawl", "job-1", "https://example.com/a", only_main_content=True),
WebsiteEstimateSource("firecrawl", "job-1", "https://example.com/b", only_main_content=True),
)
@pytest.mark.parametrize(("value", "expected"), [("false", False), ("true", True), (False, False), (True, True)])
def test_website_estimate_parses_boolean_values(value: str | bool, expected: bool) -> None:
sources = _new_estimate_sources(
{
"data_source_type": "website_crawl",
"website_info_list": {
"provider": "firecrawl",
"job_id": "job-1",
"urls": ["https://example.com"],
"only_main_content": value,
},
}
)
assert sources == (WebsiteEstimateSource("firecrawl", "job-1", "https://example.com", only_main_content=expected),)
@pytest.mark.parametrize("values", [{"only_main_content": "invalid"}, {"urls": [42]}])
def test_website_estimate_rejects_invalid_field_types(values: dict[str, object]) -> None:
with pytest.raises(
ValueError,
match=(
"(?:1 validation error for WebsiteInfo\\\nonly_main_content|1 validation error for WebsiteInfo\\\nurls\\.0)"
),
):
_new_estimate_sources(
{
"data_source_type": "website_crawl",
"website_info_list": {
"provider": "firecrawl",
"job_id": "job-1",
"urls": ["https://example.com"],
**values,
},
}
)
def test_new_estimate_sources_deduplicates_upload_ids_without_reordering() -> None:
sources = _new_estimate_sources(
{"data_source_type": "upload_file", "file_info_list": {"file_ids": ["file-2", "file-1", "file-2"]}}
)
assert sources == (UploadFileEstimateSource("file-2"), UploadFileEstimateSource("file-1"))
@pytest.mark.parametrize(
"info_list",
[
{"data_source_type": "upload_file", "file_info_list": {}},
{"data_source_type": "notion_import", "notion_info_list": [{"workspace_id": "workspace"}]},
{
"data_source_type": "notion_import",
"notion_info_list": [
{
"workspace_id": "workspace",
"credential_id": "credential",
"pages": [{"page_id": "page", "type": "unknown"}],
}
],
},
{"data_source_type": "unsupported"},
],
)
def test_new_estimate_sources_rejects_malformed_transport_shapes(info_list: dict[str, object]) -> None:
with pytest.raises(
ValueError,
match=(
"(?:1 validation error for FileInfo\\\nfile_ids|1 validation error for "
"list\\[NotionEstimateWorkspacePayload\\]\\\n0\\.pages\\.0\\.type|2 "
"validation errors for list\\[NotionEstimateWorkspacePayload\\]\\\n0\\."
"credential_id|Data source type not support)"
),
):
_new_estimate_sources(info_list)
@pytest.mark.parametrize(
("error", "expected_http_error"),
[
(IndexingEstimateCredentialUnavailableError(), NotFoundError),
(EstimateSourceNotFoundError("source-1"), NotFoundError),
(DatasetNotFoundError(), NotFoundError),
(DatasetAccessDeniedError(), DatasetAccessDeniedRequestError),
(UnsupportedEstimateSourceError("unsupported"), InvalidArgumentError),
(IndexingEstimateProviderUnavailableError(), ProviderNotInitializeError),
(IndexingEstimateExecutionError(), IndexingEstimateError),
],
)
def test_new_source_estimate_maps_application_errors(
error: Exception,
expected_http_error: type[Exception],
) -> None:
estimates = MagicMock()
estimates.estimate_new_sources.side_effect = error
registry = SimpleNamespace(knowledge=SimpleNamespace(indexing_estimates=estimates))
api = DatasetIndexingEstimateApi()
method = unwrap(api.post)
payload = IndexingEstimatePayload(
info_list={"data_source_type": "upload_file", "file_info_list": {"file_ids": ["file-1"]}},
process_rule={"mode": "automatic"},
indexing_technique="economy",
)
context = RequestContext("request-1", None, "account-1", "workspace-1")
with patch("controllers.console.datasets.datasets.application_services", return_value=registry):
with pytest.raises(expected_http_error):
method(api, payload, context)
@pytest.mark.parametrize(
("dataset_id", "scene", "locator_type"),
[
("dataset-1", RBACPermission.DATASET_USE, DatasetId),
(None, RBACPermission.DATASET_CREATE_AND_MANAGEMENT, Workspace),
],
)
def test_new_source_estimate_authorizes_before_execution(dataset_id, scene, locator_type):
estimates = MagicMock()
registry = SimpleNamespace(knowledge=SimpleNamespace(indexing_estimates=estimates))
payload = IndexingEstimatePayload(
info_list={"data_source_type": "upload_file", "file_info_list": {"file_ids": ["file-1"]}},
process_rule={"mode": "automatic"},
indexing_technique="economy",
dataset_id=dataset_id,
)
with (
patch.object(controller, "application_services", return_value=registry),
patch.object(controller, "enforce_rbac_checks", side_effect=Forbidden) as enforce_checks,
pytest.raises(Forbidden),
):
unwrap(DatasetIndexingEstimateApi.post)(DatasetIndexingEstimateApi(), payload, CONTEXT)
enforce_checks.assert_called_once()
kwargs = enforce_checks.call_args.kwargs
assert kwargs["tenant_id"] == CONTEXT.active_workspace_id
assert kwargs["account_id"] == CONTEXT.account_id
assert kwargs["path_args"] == ({"dataset_id": dataset_id} if dataset_id else None)
[check] = kwargs["checks"]
assert check.scene is scene
assert isinstance(check.locator, locator_type)
estimates.estimate_new_sources.assert_not_called()
def _upgrade_job(job_id: str = "upgrade-job-1") -> KnowledgeFSUpgradeJob:
job = KnowledgeFSUpgradeJob(
tenant_id="tenant-1",
old_dataset_id=str(DATASET_ID),
requested_by_account_id="account-1",
owner_account_id="account-1",
idempotency_key="upgrade-request-1",
snapshot_at=datetime.datetime(2026, 8, 17, tzinfo=datetime.UTC),
config_snapshot={},
permission_snapshot={},
app_binding_snapshot=[],
tag_ids_snapshot=[],
status=KnowledgeFSUpgradeJobStatus.QUEUED,
stage=KnowledgeFSUpgradeStage.VALIDATING,
total_documents=1,
)
job.id = job_id
return job
@dataclass(frozen=True)
class _UpgradeKnowledgeServices:
upgrades: KnowledgeUpgradeApplicationService
@dataclass(frozen=True)
class _UpgradeApplicationServices:
knowledge: _UpgradeKnowledgeServices
@pytest.fixture
def upgrades(monkeypatch):
service = create_autospec(KnowledgeUpgradeApplicationService, instance=True, spec_set=True)
services = _UpgradeApplicationServices(knowledge=_UpgradeKnowledgeServices(upgrades=service))
monkeypatch.setattr(controller, "application_services", lambda: services)
return service
def test_upgrade_writes_require_dataset_edit_permission() -> None:
for method in (DatasetKnowledgeFSUpgradeApi.post, DatasetKnowledgeFSUpgradeJobApi.post):
[check] = rbac_checks(method)
assert check.scene is RBACPermission.DATASET_EDIT
assert isinstance(check.locator, DatasetId)
[check] = rbac_checks(DatasetKnowledgeFSUpgradeJobsApi.get)
assert check.scene is RBACPermission.DATASET_READONLY
assert isinstance(check.locator, Workspace)
def test_upgrade_jobs_serializes_recoverable_jobs(app, upgrades):
upgrades.list_recoverable_jobs.return_value = [_upgrade_job(job_id="job-1")]
with app.test_request_context("/datasets/knowledge-fs-upgrade-jobs"):
response = unwrap(DatasetKnowledgeFSUpgradeJobsApi.get)(DatasetKnowledgeFSUpgradeJobsApi(), CONTEXT)
upgrades.list_recoverable_jobs.assert_called_once_with(CONTEXT)
assert [job["id"] for job in response["data"]] == ["job-1"]
def test_upgrade_start_forwards_idempotency_key(app, upgrades):
upgrades.start.return_value = _upgrade_job()
with app.test_request_context(
f"/datasets/{DATASET_ID}/knowledge-fs-upgrades", headers={"Idempotency-Key": "upgrade-request-1"}
):
response, status = unwrap(DatasetKnowledgeFSUpgradeApi.post)(
DatasetKnowledgeFSUpgradeApi(), CONTEXT, DATASET_ID
)
assert status == 202
assert response["id"] == "upgrade-job-1"
upgrades.start.assert_called_once_with(
CONTEXT, dataset_id=str(DATASET_ID), idempotency_key="upgrade-request-1", models=None
)
def test_upgrade_start_forwards_all_model_choices(app, upgrades):
upgrades.start.return_value = _upgrade_job()
choices = {
"embedding": {"provider": "langgenius/openai/openai", "model": "embedding"},
"rerank": {"provider": "langgenius/cohere/cohere", "model": "rerank"},
"reasoning": {"provider": "langgenius/anthropic/anthropic", "model": "reasoning"},
}
with app.test_request_context(
f"/datasets/{DATASET_ID}/knowledge-fs-upgrades",
method="POST",
headers={"Idempotency-Key": "upgrade-request-1"},
json={"models": choices},
):
response, status = unwrap(DatasetKnowledgeFSUpgradeApi.post)(
DatasetKnowledgeFSUpgradeApi(), CONTEXT, DATASET_ID
)
assert status == 202
assert response["id"] == "upgrade-job-1"
upgrades.start.assert_called_once_with(
CONTEXT,
dataset_id=str(DATASET_ID),
idempotency_key="upgrade-request-1",
models=KnowledgeFSUpgradeModelsPayload.model_validate(choices),
)
def test_upgrade_start_rejects_incomplete_model_selection(app, upgrades):
with (
app.test_request_context(
f"/datasets/{DATASET_ID}/knowledge-fs-upgrades",
method="POST",
headers={"Idempotency-Key": "upgrade-request-1"},
json={"models": {"embedding": {"provider": "openai", "model": "embedding"}}},
),
pytest.raises(BadRequest, match="Invalid upgrade model selection"),
):
unwrap(DatasetKnowledgeFSUpgradeApi.post)(DatasetKnowledgeFSUpgradeApi(), CONTEXT, DATASET_ID)
upgrades.start.assert_not_called()
def test_upgrade_start_returns_field_specific_model_errors(app, upgrades):
upgrades.start.side_effect = KnowledgeFSUpgradeModelsUnavailableError(
[
KnowledgeFSUpgradeModelIssueResponse(
field="embedding", reason="credential-removed", provider="openai", model="embedding"
)
]
)
with (
app.test_request_context(
f"/datasets/{DATASET_ID}/knowledge-fs-upgrades",
method="POST",
headers={"Idempotency-Key": "upgrade-request-1"},
),
pytest.raises(KnowledgeFSUpgradeModelsUnavailableHTTPError) as error,
):
unwrap(DatasetKnowledgeFSUpgradeApi.post)(DatasetKnowledgeFSUpgradeApi(), CONTEXT, DATASET_ID)
assert error.value.data is not None
assert error.value.data["details"]["issues"] == [
{"field": "embedding", "reason": "credential-removed", "provider": "openai", "model": "embedding"}
]
def test_upgrade_start_requires_idempotency_key(app, upgrades):
with (
app.test_request_context(f"/datasets/{DATASET_ID}/knowledge-fs-upgrades"),
pytest.raises(BadRequest, match="Idempotency-Key"),
):
unwrap(DatasetKnowledgeFSUpgradeApi.post)(DatasetKnowledgeFSUpgradeApi(), CONTEXT, DATASET_ID)
upgrades.start.assert_not_called()
@pytest.mark.parametrize(
("error", "http_error"),
[
(KnowledgeFSUpgradeUnavailableError(), NotFound),
(DatasetNotFoundError(), NotFound),
(DatasetAccessDeniedError(), Forbidden),
(KnowledgeFSUpgradeConflictError("already running"), Conflict),
],
)
def test_upgrade_start_maps_domain_errors(app, upgrades, error, http_error):
upgrades.start.side_effect = error
with (
app.test_request_context(
f"/datasets/{DATASET_ID}/knowledge-fs-upgrades", headers={"Idempotency-Key": "upgrade-request-1"}
),
pytest.raises(http_error),
):
unwrap(DatasetKnowledgeFSUpgradeApi.post)(DatasetKnowledgeFSUpgradeApi(), CONTEXT, DATASET_ID)
def test_upgrade_discovery_serializes_service_result(app, upgrades):
upgrades.discovery.return_value = KnowledgeFSUpgradePreparationResponse.model_validate(
{
"job": None,
"can_upgrade": True,
"can_retry": False,
"models": {
"embedding": {
"value": {"provider": "openai", "model": "embedding"},
"source": "legacy",
"available": True,
},
"rerank": {
"value": {"provider": "cohere", "model": "rerank"},
"source": "workspace_default",
"available": True,
},
"reasoning": {
"value": {"provider": "anthropic", "model": "reasoning"},
"source": "workspace_default",
"available": False,
"unavailable_reason": "credential-removed",
},
},
}
)
with app.test_request_context(f"/datasets/{DATASET_ID}/knowledge-fs-upgrades"):
response = unwrap(DatasetKnowledgeFSUpgradeApi.get)(DatasetKnowledgeFSUpgradeApi(), CONTEXT, DATASET_ID)
upgrades.discovery.assert_called_once_with(CONTEXT, dataset_id=str(DATASET_ID))
assert response["can_upgrade"] is True
assert response["models"]["embedding"]["value"] == {"provider": "openai", "model": "embedding"}
assert response["models"]["reasoning"]["unavailable_reason"] == "credential-removed"
def test_upgrade_job_status_maps_missing_job_to_not_found(app, upgrades):
upgrades.get_job.side_effect = KnowledgeFSUpgradeNotFoundError("Upgrade job was not found")
with (
app.test_request_context(f"/datasets/{DATASET_ID}/knowledge-fs-upgrades/job-1"),
pytest.raises(NotFound, match="Upgrade job was not found"),
):
unwrap(DatasetKnowledgeFSUpgradeJobApi.get)(DatasetKnowledgeFSUpgradeJobApi(), CONTEXT, DATASET_ID, "job-1")
def test_upgrade_retry_returns_queued(app, upgrades):
upgrades.retry.return_value = _upgrade_job(job_id="job-1")
with app.test_request_context(f"/datasets/{DATASET_ID}/knowledge-fs-upgrades/job-1"):
response, status = unwrap(DatasetKnowledgeFSUpgradeJobApi.post)(
DatasetKnowledgeFSUpgradeJobApi(), CONTEXT, DATASET_ID, "job-1"
)
assert status == 202
assert response == {"id": "job-1", "status": "queued"}
def test_upgrade_retry_maps_disabled_feature_to_not_found(app, upgrades):
upgrades.retry.side_effect = KnowledgeFSUpgradeUnavailableError()
with (
app.test_request_context(f"/datasets/{DATASET_ID}/knowledge-fs-upgrades/job-1"),
pytest.raises(NotFound),
):
unwrap(DatasetKnowledgeFSUpgradeJobApi.post)(DatasetKnowledgeFSUpgradeJobApi(), CONTEXT, DATASET_ID, "job-1")
def test_api_key_create_rejects_non_string_dataset_ids_with_the_standard_error(app):
# A raised BadRequest gets the standard error body; ``Namespace.abort(message=...)`` replaced it.
with app.test_request_context("/", method="POST", json={"dataset_ids": [123]}), pytest.raises(BadRequest) as error:
unwrap(DatasetApiKeyApi.post)(DatasetApiKeyApi(), CONTEXT)
assert error.value.description == "dataset_ids must be a list of strings."
@@ -0,0 +1,784 @@
import datetime as _datasets_document_datetime
import json
from datetime import datetime as _datasets_document_download_datetime
from inspect import unwrap
from io import BytesIO
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import MagicMock, create_autospec, patch
from uuid import UUID
from zipfile import ZipFile
import pytest
from flask import send_file
from sqlalchemy import event
from werkzeug.exceptions import Forbidden, NotFound
from controllers.common.errors import InvalidArgumentError, NotFoundError
from controllers.common.rbac import DatasetByDocument, DatasetId, RBACPermission
from controllers.console.app.error import ProviderNotInitializeError
from controllers.console.datasets import datasets_document as controller
from controllers.console.datasets.datasets_document import (
DatasetDocumentListApi,
DatasetInitApi,
DocumentApi,
DocumentBatchDownloadZipApi,
DocumentBatchIndexingEstimateApi,
DocumentBatchIndexingStatusApi,
DocumentDownloadApi,
DocumentGenerateSummaryApi,
DocumentIndexingEstimateApi,
DocumentIndexingStatusApi,
DocumentMetadataApi,
DocumentMetadataUpdatePayload,
DocumentPauseApi,
DocumentPipelineExecutionLogApi,
DocumentProcessingApi,
DocumentRecoverApi,
DocumentRenameApi,
DocumentRenamePayload,
DocumentRetryApi,
DocumentRetryPayload,
DocumentStatusApi,
DocumentSummaryStatusApi,
GenerateSummaryPayload,
GetProcessRuleApi,
WebsiteDocumentSyncApi,
)
from controllers.console.datasets.error import (
ArchivedDocumentImmutableError,
DatasetAccessDeniedRequestError,
DocumentAlreadyFinishedError,
DocumentIndexingError,
IndexingEstimateError,
InvalidActionError,
InvalidMetadataError,
)
from machinery.context import RequestContext
from models.dataset import Dataset, Document
from models.model import UploadFile
from services.knowledge.dataset_access import (
AccessibleDataset,
DatasetAccess,
DatasetAccessDeniedError,
DatasetNotFoundError,
)
from services.knowledge.documents.adapters import SQLAlchemyDocumentOperations
from services.knowledge.documents.application import (
DatasetDocumentApplicationService,
DocumentArchivedError,
DocumentIndexingStateError,
DocumentInvalidActionError,
DocumentListFilter,
DocumentNotFoundError,
DocumentProviderError,
)
from services.knowledge.indexing.estimate import (
EstimateDocumentAlreadyFinishedError,
EstimateDocumentNotFoundError,
EstimateSourceNotFoundError,
IndexingEstimateCredentialUnavailableError,
IndexingEstimateExecutionError,
IndexingEstimateProviderUnavailableError,
UnsupportedEstimateSourceError,
)
from tests.helpers.unit.controllers.rbac_introspection import rbac_checks
_DATASETS_DOCUMENT_CONTEXT = RequestContext("request-1", None, "account-1", "tenant-1")
DS = UUID(int=1)
DOC = UUID(int=2)
class TestDatasetsDocumentCases:
@staticmethod
@pytest.fixture
def documents(monkeypatch):
documents = create_autospec(DatasetDocumentApplicationService, instance=True, spec_set=True)
monkeypatch.setattr(
controller, "application_services", lambda: SimpleNamespace(knowledge=SimpleNamespace(documents=documents))
)
monkeypatch.setattr(controller, "check_knowledge_rate_limit", lambda: None)
return documents
@staticmethod
def test_process_rule_authorizes_document_dataset_before_read(app, documents):
with (
app.test_request_context(f"/?document_id={DOC}"),
patch.object(controller, "enforce_rbac_checks", side_effect=Forbidden) as enforce_checks,
pytest.raises(Forbidden),
):
unwrap(GetProcessRuleApi.get)(GetProcessRuleApi(), _DATASETS_DOCUMENT_CONTEXT)
enforce_checks.assert_called_once()
kwargs = enforce_checks.call_args.kwargs
assert kwargs["tenant_id"] == _DATASETS_DOCUMENT_CONTEXT.active_workspace_id
assert kwargs["account_id"] == _DATASETS_DOCUMENT_CONTEXT.account_id
assert kwargs["path_args"] == {"document_id": str(DOC)}
[check] = kwargs["checks"]
assert check.scene is RBACPermission.DATASET_READONLY
assert isinstance(check.locator, DatasetByDocument)
documents.get_process_rule.assert_not_called()
@staticmethod
def test_default_process_rule_does_not_require_dataset_permission(app, documents):
documents.get_process_rule.return_value = {
"mode": "automatic",
"rules": {},
"limits": {"indexing_max_segmentation_tokens_length": 4000},
}
with app.test_request_context("/"), patch.object(controller, "enforce_rbac_checks") as enforce_checks:
unwrap(GetProcessRuleApi.get)(GetProcessRuleApi(), _DATASETS_DOCUMENT_CONTEXT)
enforce_checks.assert_not_called()
documents.get_process_rule.assert_called_once_with(_DATASETS_DOCUMENT_CONTEXT, document_id=None)
@staticmethod
@pytest.mark.parametrize(
("resource", "verb", "operation", "kwargs"),
[
(GetProcessRuleApi, GetProcessRuleApi.get, lambda service: service.get_process_rule, {}),
(
DatasetDocumentListApi,
DatasetDocumentListApi.get,
lambda service: service.list_documents,
{"dataset_id": DS},
),
(
DatasetDocumentListApi,
DatasetDocumentListApi.post,
lambda service: service.create_documents,
{"dataset_id": DS},
),
(
DatasetDocumentListApi,
DatasetDocumentListApi.delete,
lambda service: service.delete_documents,
{"dataset_id": DS},
),
(DatasetInitApi, DatasetInitApi.post, lambda service: service.initialize_dataset, {}),
(
DocumentBatchIndexingStatusApi,
DocumentBatchIndexingStatusApi.get,
lambda service: service.get_batch_indexing_status,
{"dataset_id": DS, "batch": "batch-1"},
),
(
DocumentIndexingStatusApi,
DocumentIndexingStatusApi.get,
lambda service: service.get_indexing_status,
{"dataset_id": DS, "document_id": DOC},
),
(
DocumentApi,
DocumentApi.get,
lambda service: service.get_document,
{"dataset_id": DS, "document_id": DOC},
),
(
DocumentApi,
DocumentApi.delete,
lambda service: service.delete_document,
{"dataset_id": DS, "document_id": DOC},
),
(
DocumentDownloadApi,
DocumentDownloadApi.get,
lambda service: service.get_download_url,
{"dataset_id": DS, "document_id": DOC},
),
(
DocumentBatchDownloadZipApi,
DocumentBatchDownloadZipApi.post,
lambda service: service.build_download_zip,
{"dataset_id": DS},
),
(
DocumentProcessingApi,
DocumentProcessingApi.patch,
lambda service: service.update_processing,
{"dataset_id": DS, "document_id": DOC, "action": "pause"},
),
(
DocumentMetadataApi,
DocumentMetadataApi.put,
lambda service: service.update_metadata,
{
"dataset_id": DS,
"document_id": DOC,
"req_data": DocumentMetadataUpdatePayload(doc_type="book", doc_metadata={"title": "Book"}),
},
),
(
DocumentStatusApi,
DocumentStatusApi.patch,
lambda service: service.change_status,
{"dataset_id": DS, "action": "enable"},
),
(
DocumentPauseApi,
DocumentPauseApi.patch,
lambda service: service.pause_document,
{"dataset_id": DS, "document_id": DOC},
),
(
DocumentRecoverApi,
DocumentRecoverApi.patch,
lambda service: service.recover_document,
{"dataset_id": DS, "document_id": DOC},
),
(
DocumentRetryApi,
DocumentRetryApi.post,
lambda service: service.retry_documents,
{"dataset_id": DS, "req_data": DocumentRetryPayload(document_ids=[str(DOC)])},
),
(
DocumentRenameApi,
DocumentRenameApi.post,
lambda service: service.rename_document,
{"dataset_id": DS, "document_id": DOC, "req_data": DocumentRenamePayload(name="New name")},
),
(
WebsiteDocumentSyncApi,
WebsiteDocumentSyncApi.get,
lambda service: service.sync_website,
{"dataset_id": DS, "document_id": DOC},
),
(
DocumentPipelineExecutionLogApi,
DocumentPipelineExecutionLogApi.get,
lambda service: service.get_execution_log,
{"dataset_id": DS, "document_id": DOC},
),
(
DocumentGenerateSummaryApi,
DocumentGenerateSummaryApi.post,
lambda service: service.generate_summary,
{"dataset_id": DS, "req_data": GenerateSummaryPayload(document_list=[str(DOC)])},
),
(
DocumentSummaryStatusApi,
DocumentSummaryStatusApi.get,
lambda service: service.get_summary_status,
{"dataset_id": DS, "document_id": DOC},
),
],
)
def test_endpoints_pass_request_context_and_map_application_errors(
app, documents, resource, verb, operation, kwargs
):
operation(documents).side_effect = DocumentNotFoundError("Document not found.")
with app.test_request_context(
"/?document_id=" + str(DOC), json={"indexing_technique": "economy", "document_ids": [str(DOC)]}
):
with pytest.raises(NotFound):
unwrap(verb)(resource(), request_context=_DATASETS_DOCUMENT_CONTEXT, **kwargs)
called = operation(documents)
assert called.call_count == 1
assert called.call_args.args == (_DATASETS_DOCUMENT_CONTEXT,)
if "dataset_id" in kwargs:
assert called.call_args.kwargs["dataset_id"] == str(DS)
if "document_id" in kwargs:
assert called.call_args.kwargs["document_id"] == str(DOC)
@staticmethod
@pytest.mark.parametrize(
("fetch", "expected"), [("true", True), ("YES", True), ("false", False), ("invalid", False)]
)
def test_list_preserves_filters_pagination_and_fetch_parsing(app, documents, fetch, expected):
documents.list_documents.return_value = {"data": [], "has_more": False, "page": 2, "limit": 3, "total": 3}
with app.test_request_context(f"/?page=2&limit=3&keyword=needle&status=available&sort=hit_count&fetch={fetch}"):
response = unwrap(DatasetDocumentListApi.get)(DatasetDocumentListApi(), _DATASETS_DOCUMENT_CONTEXT, DS)
documents.list_documents.assert_called_once_with(
_DATASETS_DOCUMENT_CONTEXT,
dataset_id=str(DS),
query=DocumentListFilter(
page=2, limit=3, search="needle", status="available", sort="hit_count", fetch=expected
),
)
assert response == {"data": [], "has_more": False, "page": 2, "limit": 3, "total": 3}
@staticmethod
@pytest.mark.parametrize("metadata", ["only", "without", "all"])
def test_document_detail_metadata_projection_and_raw_source(app, documents, metadata):
documents.get_document.return_value = {
"id": str(DOC),
"doc_type": "others",
"doc_metadata": [],
"name": "Name",
"data_source_info": {"file_path": "/path/to/local/file"},
"data_source_detail_dict": {},
}
with app.test_request_context(f"/?metadata={metadata}"):
response, status = unwrap(DocumentApi.get)(DocumentApi(), _DATASETS_DOCUMENT_CONTEXT, DS, DOC)
assert status == 200
documents.get_document.assert_called_once_with(
_DATASETS_DOCUMENT_CONTEXT, dataset_id=str(DS), document_id=str(DOC), metadata_only=metadata == "only"
)
if metadata == "only":
assert response == {"id": str(DOC), "doc_type": "others", "doc_metadata": []}
else:
assert response["data_source_info"] == {"file_path": "/path/to/local/file"}
assert ("doc_metadata" in response) is (metadata == "all")
@staticmethod
def test_invalid_metadata_fails_before_application_call(app, documents):
with app.test_request_context("/?metadata=invalid"), pytest.raises(InvalidMetadataError):
unwrap(DocumentApi.get)(DocumentApi(), _DATASETS_DOCUMENT_CONTEXT, DS, DOC)
documents.get_document.assert_not_called()
@staticmethod
@pytest.mark.parametrize(
("resource", "verb", "kwargs"),
[
(DocumentApi, DocumentApi.delete, {"document_id": DOC}),
(DatasetDocumentListApi, DatasetDocumentListApi.delete, {}),
(DocumentPauseApi, DocumentPauseApi.patch, {"document_id": DOC}),
(DocumentRecoverApi, DocumentRecoverApi.patch, {"document_id": DOC}),
(DocumentRetryApi, DocumentRetryApi.post, {"req_data": DocumentRetryPayload(document_ids=[str(DOC)])}),
],
)
@pytest.mark.usefixtures("documents")
def test_no_content_mutations_return_empty_204(app, resource, verb, kwargs):
with app.test_request_context("/?document_id=" + str(DOC)):
result = unwrap(verb)(resource(), request_context=_DATASETS_DOCUMENT_CONTEXT, dataset_id=DS, **kwargs)
assert result == ("", 204)
@staticmethod
@pytest.mark.parametrize(
("resource", "verb", "operation", "kwargs"),
[
(
DocumentProcessingApi,
DocumentProcessingApi.patch,
lambda service: service.update_processing,
{"document_id": DOC, "action": "resume"},
),
(DocumentStatusApi, DocumentStatusApi.patch, lambda service: service.change_status, {"action": "disable"}),
(
WebsiteDocumentSyncApi,
WebsiteDocumentSyncApi.get,
lambda service: service.sync_website,
{"document_id": DOC},
),
(
DocumentGenerateSummaryApi,
DocumentGenerateSummaryApi.post,
lambda service: service.generate_summary,
{"req_data": GenerateSummaryPayload(document_list=[str(DOC)])},
),
],
)
def test_success_mutations_return_success_response(app, documents, resource, verb, operation, kwargs):
with app.test_request_context("/?document_id=" + str(DOC)):
result = unwrap(verb)(resource(), request_context=_DATASETS_DOCUMENT_CONTEXT, dataset_id=DS, **kwargs)
assert result == ({"result": "success"}, 200)
assert operation(documents).call_count == 1
@staticmethod
@pytest.mark.parametrize("resource", [DatasetInitApi, DatasetDocumentListApi])
def test_creation_serializes_materialized_dataset_and_documents(app, documents, resource):
operation = documents.initialize_dataset if resource is DatasetInitApi else documents.create_documents
operation.return_value = {
"dataset": {
"id": str(DS),
"name": "Dataset",
"created_at": _datasets_document_datetime.datetime(2024, 1, 1, tzinfo=_datasets_document_datetime.UTC),
},
"documents": [
{
"id": str(DOC),
"name": "Document",
"data_source_detail_dict": {},
"data_source_info_dict": {},
"doc_metadata_details": [],
}
],
"batch": "batch-1",
}
with app.test_request_context("/", json={"indexing_technique": "economy"}):
response = unwrap(resource.post)(
resource(),
request_context=_DATASETS_DOCUMENT_CONTEXT,
**({} if resource is DatasetInitApi else {"dataset_id": DS}),
)
assert response["dataset"]["created_at"] == 1704067200
assert response["documents"][0]["data_source_info"] == {}
assert response["documents"][0]["doc_metadata"] == []
assert response["batch"] == "batch-1"
@staticmethod
@pytest.mark.parametrize("resource", [DocumentIndexingStatusApi, DocumentBatchIndexingStatusApi])
def test_indexing_status_keeps_timestamps_counts_and_error_fields(app, documents, resource):
value = {
"id": str(DOC),
"indexing_status": "paused",
"completed_segments": 2,
"total_segments": 3,
**dict.fromkeys(
(
"processing_started_at",
"parsing_completed_at",
"cleaning_completed_at",
"splitting_completed_at",
"completed_at",
"paused_at",
"error",
"stopped_at",
)
),
}
value["processing_started_at"] = _datasets_document_datetime.datetime(
2024, 1, 1, tzinfo=_datasets_document_datetime.UTC
)
batch = resource is DocumentBatchIndexingStatusApi
operation = documents.get_batch_indexing_status if batch else documents.get_indexing_status
operation.return_value = {"data": [value]} if batch else value
with app.test_request_context("/"):
response = unwrap(resource.get)(
resource(),
request_context=_DATASETS_DOCUMENT_CONTEXT,
dataset_id=DS,
**({"batch": "batch-1"} if batch else {"document_id": DOC}),
)
row = response["data"][0] if batch else response
assert row["indexing_status"] == "paused"
assert row["processing_started_at"] == 1704067200
assert row["completed_segments"] == 2
assert row["total_segments"] == 3
@staticmethod
@pytest.mark.parametrize(
("translate", "error", "http_error"),
[
(controller._raise_document_error, DatasetNotFoundError(), NotFound),
(controller._raise_document_error, DocumentNotFoundError("missing"), NotFound),
(controller._raise_document_error, DatasetAccessDeniedError(), Forbidden),
(controller._raise_document_indexing_error, DocumentIndexingStateError("indexing"), DocumentIndexingError),
(
controller._raise_document_indexing_error,
DocumentProviderError("provider", kind="uninitialized"),
ProviderNotInitializeError,
),
(controller._raise_document_action_error, DocumentInvalidActionError("invalid"), InvalidActionError),
(controller._raise_document_status_error, DocumentInvalidActionError("invalid"), InvalidActionError),
(controller._raise_document_status_error, DocumentIndexingStateError("indexing"), DocumentIndexingError),
(controller._raise_document_archive_error, DocumentArchivedError(), ArchivedDocumentImmutableError),
(controller._raise_document_archive_error, DocumentIndexingStateError("indexing"), DocumentIndexingError),
# Every narrow translator falls back to the shared scope mapping.
(controller._raise_document_archive_error, DatasetNotFoundError(), NotFound),
],
)
def test_document_errors_are_mapped_at_transport_boundary(translate, error, http_error):
with pytest.raises(http_error):
translate(error)
@staticmethod
def test_scope_translator_does_not_map_other_operations_errors():
error = DocumentInvalidActionError("invalid")
with pytest.raises(DocumentInvalidActionError) as raised:
controller._raise_document_error(error)
assert raised.value is error
@staticmethod
def test_unexpected_error_is_not_hidden():
error = RuntimeError("unexpected")
with pytest.raises(RuntimeError) as raised:
controller._raise_document_error(error)
assert raised.value is error
class TestIndexingEstimateExceptionMapping:
@staticmethod
def _registry(method_name: str, error: Exception) -> SimpleNamespace:
estimates = MagicMock()
method = estimates.estimate_document if method_name == "estimate_document" else estimates.estimate_batch
method.side_effect = error
return SimpleNamespace(knowledge=SimpleNamespace(indexing_estimates=estimates))
@pytest.mark.parametrize(
("error", "expected_http_error"),
[
(DatasetNotFoundError(), NotFoundError),
(EstimateDocumentNotFoundError(), NotFoundError),
(EstimateSourceNotFoundError("source-1"), NotFoundError),
(IndexingEstimateCredentialUnavailableError(), NotFoundError),
(DatasetAccessDeniedError(), DatasetAccessDeniedRequestError),
(EstimateDocumentAlreadyFinishedError(), DocumentAlreadyFinishedError),
(UnsupportedEstimateSourceError("unsupported"), InvalidArgumentError),
(IndexingEstimateProviderUnavailableError(), ProviderNotInitializeError),
(IndexingEstimateExecutionError(), IndexingEstimateError),
],
)
def test_document_estimate_maps_application_errors(
self,
error: Exception,
expected_http_error: type[Exception],
) -> None:
api = DocumentIndexingEstimateApi()
method = unwrap(api.get)
context = RequestContext("request-1", None, "account-1", "workspace-1")
registry = self._registry("estimate_document", error)
with patch(
"controllers.console.datasets.datasets_document.application_services",
return_value=registry,
):
with pytest.raises(expected_http_error):
method(api, context, UUID(int=1), UUID(int=2))
@pytest.mark.parametrize(
("error", "expected_http_error"),
[
(DatasetNotFoundError(), NotFoundError),
(EstimateDocumentNotFoundError(), NotFoundError),
(EstimateSourceNotFoundError("source-1"), NotFoundError),
(IndexingEstimateCredentialUnavailableError(), NotFoundError),
(DatasetAccessDeniedError(), DatasetAccessDeniedRequestError),
(EstimateDocumentAlreadyFinishedError(), DocumentAlreadyFinishedError),
(UnsupportedEstimateSourceError("unsupported"), InvalidArgumentError),
(IndexingEstimateProviderUnavailableError(), ProviderNotInitializeError),
(IndexingEstimateExecutionError(), IndexingEstimateError),
],
)
def test_batch_estimate_maps_application_errors(
self,
error: Exception,
expected_http_error: type[Exception],
) -> None:
api = DocumentBatchIndexingEstimateApi()
method = unwrap(api.get)
context = RequestContext("request-1", None, "account-1", "workspace-1")
registry = self._registry("estimate_batch", error)
with patch(
"controllers.console.datasets.datasets_document.application_services",
return_value=registry,
):
with pytest.raises(expected_http_error):
method(api, context, UUID(int=1), "unknown-batch")
@staticmethod
@pytest.mark.parametrize(
"method",
[
DatasetDocumentListApi.get,
DocumentBatchIndexingStatusApi.get,
DocumentIndexingStatusApi.get,
DocumentApi.get,
DocumentPipelineExecutionLogApi.get,
DocumentSummaryStatusApi.get,
],
)
def test_document_read_routes_require_dataset_readonly_permission(method) -> None:
[check] = rbac_checks(method)
assert check.scene is RBACPermission.DATASET_READONLY
assert isinstance(check.locator, DatasetId)
@staticmethod
@pytest.mark.parametrize(
"method",
[DocumentIndexingEstimateApi.get, DocumentBatchIndexingEstimateApi.get],
)
def test_document_indexing_estimates_require_dataset_use_permission(method) -> None:
[check] = rbac_checks(method)
assert check.scene is RBACPermission.DATASET_USE
assert isinstance(check.locator, DatasetId)
@staticmethod
@pytest.mark.parametrize(
("method", "expected_scene"),
[
(DatasetDocumentListApi.post, RBACPermission.DATASET_USE),
(DatasetDocumentListApi.delete, RBACPermission.DATASET_DELETE_FILE),
(DocumentApi.delete, RBACPermission.DATASET_DELETE_FILE),
(DocumentBatchDownloadZipApi.post, RBACPermission.DATASET_DOCUMENT_DOWNLOAD),
],
)
def test_document_mutation_routes_require_operation_specific_permissions(method, expected_scene) -> None:
[check] = rbac_checks(method)
assert check.scene is expected_scene
assert isinstance(check.locator, DatasetId)
"""Document downloads through the controller, application service, and SQLite adapter."""
_DATASETS_DOCUMENT_DOWNLOAD_CONTEXT = RequestContext("request-1", None, "actor-1", "tenant-1")
DOC_ID = str(UUID(int=1))
FILE_ID = str(UUID(int=2))
def _document(**values):
return Document(
**{
"id": DOC_ID,
"tenant_id": "tenant-1",
"dataset_id": "dataset-1",
"position": 1,
"data_source_type": "upload_file",
"data_source_info": json.dumps({"upload_file_id": FILE_ID}),
"batch": "batch-1",
"name": "document.txt",
"created_from": "web",
"created_by": "actor-1",
**values,
}
)
class TestDatasetsDocumentDownloadCases:
@staticmethod
@pytest.fixture(autouse=True)
def downloads(monkeypatch, sqlite_session_factory):
with sqlite_session_factory.begin() as session:
session.add(Dataset(id="dataset-1", tenant_id="tenant-1", name="Dataset", created_by="actor-1"))
session.add(_document())
upload = UploadFile(
tenant_id="tenant-1",
storage_type="local",
key="key-1",
name="document.txt",
size=5,
extension="txt",
mime_type="text/plain",
created_by_role="account",
created_by="actor-1",
created_at=_datasets_document_download_datetime(2024, 1, 1),
used=False,
)
upload.id = FILE_ID
session.add(upload)
access = create_autospec(DatasetAccess, instance=True, spec_set=True)
access.require_accessible.return_value = AccessibleDataset("dataset-1", "tenant-1")
documents = DatasetDocumentApplicationService(
dataset_access=access,
operations=SQLAlchemyDocumentOperations(session_factory=sqlite_session_factory),
metadata_schema={},
)
monkeypatch.setattr(
controller, "application_services", lambda: SimpleNamespace(knowledge=SimpleNamespace(documents=documents))
)
return documents
@staticmethod
def test_document_download_returns_signed_url(app, monkeypatch):
from services.knowledge import dataset_service
signed = []
def sign(**kwargs):
signed.append(kwargs)
return "https://files.example/download"
monkeypatch.setattr(dataset_service.file_helpers, "get_signed_file_url", sign)
with app.test_request_context("/"):
result = unwrap(controller.DocumentDownloadApi.get)(
controller.DocumentDownloadApi(), _DATASETS_DOCUMENT_DOWNLOAD_CONTEXT, "dataset-1", DOC_ID
)
assert result == {"url": "https://files.example/download"}
assert signed == [{"upload_file_id": FILE_ID, "as_attachment": True}]
@staticmethod
@pytest.mark.parametrize(
"values",
[
{"data_source_type": "website_crawl"},
{"data_source_info": "{}"},
{"data_source_info": json.dumps({"upload_file_id": "missing"})},
{"tenant_id": "foreign"},
{"dataset_id": "foreign"},
],
)
def test_invalid_or_foreign_document_is_not_downloadable(app, sqlite_session_factory, values):
with sqlite_session_factory.begin() as session:
document = session.get(Document, DOC_ID)
for key, value in values.items():
setattr(document, key, value)
with app.test_request_context("/"), pytest.raises(NotFound):
unwrap(controller.DocumentDownloadApi.get)(
controller.DocumentDownloadApi(), _DATASETS_DOCUMENT_DOWNLOAD_CONTEXT, "dataset-1", DOC_ID
)
@staticmethod
def test_cross_tenant_upload_file_is_not_signed(app, sqlite_session_factory):
with sqlite_session_factory.begin() as session:
session.get(UploadFile, FILE_ID).tenant_id = "foreign"
with app.test_request_context("/"), pytest.raises(NotFound):
unwrap(controller.DocumentDownloadApi.get)(
controller.DocumentDownloadApi(), _DATASETS_DOCUMENT_DOWNLOAD_CONTEXT, "dataset-1", DOC_ID
)
@staticmethod
def test_zip_is_readable_and_cleanup_waits_for_response_close(app, monkeypatch, sqlite_engine):
from services import file_service
paths = []
checked_out = set()
def checkout(_connection, record, _proxy):
checked_out.add(record)
def checkin(_connection, record):
checked_out.discard(record)
def load(key, *, stream):
assert not checked_out, "storage I/O must run after the read transaction closes"
assert key == "key-1"
assert stream is True
return iter([b"hello"])
def send(path, **kwargs):
paths.append(Path(path))
return send_file(path, **kwargs)
monkeypatch.setattr(file_service.storage, "load", load)
monkeypatch.setattr(controller, "send_file", send)
event.listen(sqlite_engine, "checkout", checkout)
event.listen(sqlite_engine, "checkin", checkin)
try:
with app.test_request_context("/", json={"document_ids": [DOC_ID]}):
response = unwrap(controller.DocumentBatchDownloadZipApi.post)(
controller.DocumentBatchDownloadZipApi(), _DATASETS_DOCUMENT_DOWNLOAD_CONTEXT, "dataset-1"
)
assert paths[0].exists()
response.direct_passthrough = False
with ZipFile(BytesIO(response.get_data())) as archive:
assert archive.read("document.txt") == b"hello"
response.close()
assert not paths[0].exists()
finally:
event.remove(sqlite_engine, "checkout", checkout)
event.remove(sqlite_engine, "checkin", checkin)
@staticmethod
def test_zip_cleanup_when_response_creation_fails(app, monkeypatch):
from services import file_service
paths = []
monkeypatch.setattr(file_service.storage, "load", lambda *_args, **_kwargs: iter([b"hello"]))
def fail_send(path, **_kwargs):
paths.append(Path(path))
raise RuntimeError("response failed")
monkeypatch.setattr(controller, "send_file", fail_send)
with (
app.test_request_context("/", json={"document_ids": [DOC_ID]}),
pytest.raises(RuntimeError, match="response failed"),
):
unwrap(controller.DocumentBatchDownloadZipApi.post)(
controller.DocumentBatchDownloadZipApi(), _DATASETS_DOCUMENT_DOWNLOAD_CONTEXT, "dataset-1"
)
assert paths
assert not paths[0].exists()
@staticmethod
def test_zip_rejects_non_upload_document(app, sqlite_session_factory):
with sqlite_session_factory.begin() as session:
session.get(Document, DOC_ID).data_source_type = "website_crawl"
with app.test_request_context("/", json={"document_ids": [DOC_ID]}), pytest.raises(NotFound):
unwrap(controller.DocumentBatchDownloadZipApi.post)(
controller.DocumentBatchDownloadZipApi(), _DATASETS_DOCUMENT_DOWNLOAD_CONTEXT, "dataset-1"
)
@@ -0,0 +1,402 @@
from collections.abc import Callable
from contextlib import AbstractContextManager
from dataclasses import dataclass
from datetime import UTC, datetime
from inspect import unwrap
from typing import Never
from unittest.mock import create_autospec, patch
import pytest
from flask import Flask
from werkzeug.exceptions import Forbidden, NotFound
from controllers.common.controller_schemas import ChildChunkCreatePayload, ChildChunkUpdatePayload
from controllers.console.app.error import ProviderNotInitializeError
from controllers.console.datasets.datasets_segments import (
BatchImportPayload,
ChildChunkAddApi,
ChildChunkBatchUpdatePayload,
ChildChunkUpdateApi,
DatasetDocumentSegmentAddApi,
DatasetDocumentSegmentApi,
DatasetDocumentSegmentBatchImportApi,
DatasetDocumentSegmentBatchImportStatusApi,
DatasetDocumentSegmentListApi,
DatasetDocumentSegmentUpdateApi,
SegmentCreatePayload,
SegmentUpdatePayload,
_raise_child_chunk_create_error,
_raise_child_chunk_delete_error,
_raise_child_chunk_write_error,
_raise_segment_embedding_error,
_raise_segment_error,
_raise_segment_status_error,
)
from controllers.console.datasets.error import ChildChunkDeleteIndexError, ChildChunkIndexingError, InvalidActionError
from machinery.context import RequestContext
from services.knowledge.entities.segments import ChildChunkRecord, ChildChunkUpdateArgs, SegmentRecord
from services.knowledge.segments.application import (
ChildChunkDeleteIndexApplicationError,
ChildChunkIndexingApplicationError,
ChildChunkNotFoundError,
ChildChunkPage,
DatasetSegmentApplicationService,
SegmentBatchImport,
SegmentBatchImportDispatchError,
SegmentBatchImportNotFoundError,
SegmentDatasetModelUnavailableError,
SegmentDatasetNotFoundError,
SegmentDetail,
SegmentDocumentIndexingError,
SegmentDocumentNotFoundError,
SegmentEmbeddingModelUnavailableError,
SegmentInvalidFileTypeError,
SegmentListFilter,
SegmentNotFoundError,
SegmentPage,
SegmentPermissionDeniedError,
SegmentStatusUpdateError,
SegmentUploadFileNotFoundError,
)
def _context() -> RequestContext:
return RequestContext(
request_id="request-1",
trace_id=None,
account_id="account-1",
active_workspace_id="tenant-1",
)
def _child_chunk_data() -> ChildChunkRecord:
now = datetime(2026, 1, 1, tzinfo=UTC)
return ChildChunkRecord.model_validate(
{
"id": "child-1",
"segment_id": "segment-1",
"content": "child",
"position": 1,
"word_count": 5,
"type": "customized",
"created_at": now,
"updated_at": now,
}
)
def _segment_data() -> SegmentRecord:
now = datetime(2026, 1, 1, tzinfo=UTC)
return SegmentRecord.model_validate(
{
"id": "segment-1",
"position": 1,
"document_id": "document-1",
"content": "content",
"sign_content": "content",
"answer": None,
"word_count": 7,
"tokens": 2,
"keywords": [],
"index_node_id": "node-1",
"index_node_hash": "hash",
"hit_count": 0,
"enabled": True,
"disabled_at": None,
"disabled_by": None,
"status": "completed",
"created_by": "account-1",
"created_at": now,
"updated_at": now,
"updated_by": None,
"indexing_at": None,
"completed_at": now,
"error": None,
"stopped_at": None,
"child_chunks": [],
"attachments": [],
"summary": None,
}
)
@dataclass(frozen=True)
class KnowledgeServiceStub:
segments: DatasetSegmentApplicationService
@dataclass(frozen=True)
class ApplicationServiceStub:
knowledge: KnowledgeServiceStub
def _patch_services(segments: DatasetSegmentApplicationService) -> AbstractContextManager[object]:
return patch(
"controllers.console.datasets.datasets_segments.application_services",
return_value=ApplicationServiceStub(knowledge=KnowledgeServiceStub(segments=segments)),
)
def test_list_segments_delegates_typed_query_and_serializes_page(app: Flask) -> None:
segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
segments.list_segments.return_value = SegmentPage(
items=(_segment_data(),), total=1, total_pages=1, page=2, limit=10
)
method = unwrap(DatasetDocumentSegmentListApi.get)
with (
app.test_request_context("/?status=completed&limit=10&page=2&enabled=true&keyword=needle"),
_patch_services(segments),
):
response, status = method(DatasetDocumentSegmentListApi(), _context(), "dataset-1", "document-1")
assert status == 200
assert response["data"][0]["id"] == "segment-1"
assert response["data"][0]["created_at"] == 1767225600
assert response["data"][0]["keywords"] == []
assert response["data"][0]["disabled_at"] is None
query = segments.list_segments.call_args.kwargs["query"]
assert query == SegmentListFilter(
page=2,
limit=10,
statuses=("completed",),
enabled="true",
keyword="needle",
)
def test_delete_segments_delegates_all_selected_ids(app: Flask) -> None:
segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
method = unwrap(DatasetDocumentSegmentListApi.delete)
with app.test_request_context("/?segment_id=one&segment_id=two"), _patch_services(segments):
response, status = method(DatasetDocumentSegmentListApi(), _context(), "dataset-1", "document-1")
assert (response, status) == ("", 204)
assert segments.delete_segments.call_args.kwargs["segment_ids"] == ["one", "two"]
@pytest.mark.parametrize("action", ["enable", "disable"])
def test_change_segment_status_delegates_action(app: Flask, action: str) -> None:
segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
method = unwrap(DatasetDocumentSegmentApi.patch)
with app.test_request_context("/?segment_id=one"), _patch_services(segments):
response, status = method(DatasetDocumentSegmentApi(), _context(), "dataset-1", "document-1", action)
assert status == 200
assert response == {"result": "success"}
assert segments.change_segment_status.call_args.kwargs["action"] == action
@pytest.mark.parametrize("action", ["typo", "ENABLE", "enable "])
def test_change_segment_status_rejects_unknown_action_before_service_call(app: Flask, action: str) -> None:
segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
method = unwrap(DatasetDocumentSegmentApi.patch)
with (
app.test_request_context("/?segment_id=one"),
_patch_services(segments),
pytest.raises(InvalidActionError) as error,
):
method(DatasetDocumentSegmentApi(), _context(), "dataset-1", "document-1", action)
assert error.value.code == 400
segments.change_segment_status.assert_not_called()
def test_create_segment_delegates_payload_and_serializes_detail(app: Flask) -> None:
segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
segments.create_segment.return_value = SegmentDetail(data=_segment_data(), doc_form="text_model")
method = unwrap(DatasetDocumentSegmentAddApi.post)
with app.test_request_context("/"), _patch_services(segments):
response, status = method(
DatasetDocumentSegmentAddApi(),
SegmentCreatePayload(content="content"),
_context(),
"dataset-1",
"document-1",
)
assert status == 200
assert response["data"]["id"] == "segment-1"
assert segments.create_segment.call_args.kwargs["values"] == {"content": "content"}
def test_update_and_delete_segment_delegate_owned_ids(app: Flask) -> None:
segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
segments.update_segment.return_value = SegmentDetail(data=_segment_data(), doc_form="text_model")
with app.test_request_context("/"), _patch_services(segments):
update_response, update_status = unwrap(DatasetDocumentSegmentUpdateApi.patch)(
DatasetDocumentSegmentUpdateApi(),
SegmentUpdatePayload(content="updated"),
_context(),
"dataset-1",
"document-1",
"segment-1",
)
delete_response, delete_status = unwrap(DatasetDocumentSegmentUpdateApi.delete)(
DatasetDocumentSegmentUpdateApi(),
_context(),
"dataset-1",
"document-1",
"segment-1",
)
assert update_status == 200
assert update_response["data"]["content"] == "content"
assert (delete_response, delete_status) == ("", 204)
assert segments.update_segment.call_args.kwargs["segment_id"] == "segment-1"
assert segments.delete_segment.call_args.kwargs["segment_id"] == "segment-1"
def test_batch_import_delegates_and_preserves_dispatch_failure_response(app: Flask) -> None:
segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
segments.start_batch_import.return_value = SegmentBatchImport(job_id="job-1", job_status="waiting")
method = unwrap(DatasetDocumentSegmentBatchImportApi.post)
with app.test_request_context("/"), _patch_services(segments):
response, status = method(
DatasetDocumentSegmentBatchImportApi(),
BatchImportPayload(upload_file_id="file-1"),
_context(),
"dataset-1",
"document-1",
)
assert status == 200
assert response == {"job_id": "job-1", "job_status": "waiting"}
segments.start_batch_import.side_effect = SegmentBatchImportDispatchError("redis down")
with app.test_request_context("/"), _patch_services(segments):
response, status = method(
DatasetDocumentSegmentBatchImportApi(),
BatchImportPayload(upload_file_id="file-1"),
_context(),
"dataset-1",
"document-1",
)
assert (response, status) == ({"error": "redis down"}, 500)
def test_batch_import_status_preserves_missing_job_contract(app: Flask) -> None:
segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
method = unwrap(DatasetDocumentSegmentBatchImportStatusApi.get)
segments.get_batch_import_status.side_effect = SegmentBatchImportNotFoundError("The job does not exist.")
with (
app.test_request_context("/"),
_patch_services(segments),
pytest.raises(ValueError, match="The job does not exist\\."),
):
method(DatasetDocumentSegmentBatchImportStatusApi(), _context(), "job-1")
segments.get_batch_import_status.side_effect = None
segments.get_batch_import_status.return_value = SegmentBatchImport(job_id="job-1", job_status="completed")
with app.test_request_context("/"), _patch_services(segments):
response, status = method(DatasetDocumentSegmentBatchImportStatusApi(), _context(), "job-1")
assert status == 200
assert response == {"job_id": "job-1", "job_status": "completed"}
def test_child_chunk_create_and_list_delegate(app: Flask) -> None:
segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
segments.create_child_chunk.return_value = _child_chunk_data()
segments.list_child_chunks.return_value = ChildChunkPage(
items=(_child_chunk_data(),), total=1, total_pages=1, page=1, limit=20
)
with app.test_request_context("/"), _patch_services(segments):
create_response, create_status = unwrap(ChildChunkAddApi.post)(
ChildChunkAddApi(),
ChildChunkCreatePayload(content="child"),
_context(),
"dataset-1",
"document-1",
"segment-1",
)
list_response, list_status = unwrap(ChildChunkAddApi.get)(
ChildChunkAddApi(), _context(), "dataset-1", "document-1", "segment-1"
)
assert create_status == list_status == 200
assert create_response["data"]["id"] == "child-1"
assert create_response["data"]["created_at"] == 1767225600
assert list_response["data"][0]["id"] == "child-1"
def test_child_chunk_mutations_delegate(app: Flask) -> None:
segments = create_autospec(DatasetSegmentApplicationService, instance=True, spec_set=True)
segments.update_child_chunks.return_value = (_child_chunk_data(),)
segments.update_child_chunk.return_value = _child_chunk_data()
chunks = [ChildChunkUpdateArgs(id="child-1", content="updated")]
with app.test_request_context("/"), _patch_services(segments):
batch_response, batch_status = unwrap(ChildChunkAddApi.patch)(
ChildChunkAddApi(),
ChildChunkBatchUpdatePayload(chunks=chunks),
_context(),
"dataset-1",
"document-1",
"segment-1",
)
update_response, update_status = unwrap(ChildChunkUpdateApi.patch)(
ChildChunkUpdateApi(),
ChildChunkUpdatePayload(content="updated"),
_context(),
"dataset-1",
"document-1",
"segment-1",
"child-1",
)
delete_response, delete_status = unwrap(ChildChunkUpdateApi.delete)(
ChildChunkUpdateApi(),
_context(),
"dataset-1",
"document-1",
"segment-1",
"child-1",
)
assert batch_status == update_status == 200
assert batch_response["data"][0]["id"] == "child-1"
assert update_response["data"]["id"] == "child-1"
assert (delete_response, delete_status) == ("", 204)
@pytest.mark.parametrize(
("translate", "error", "expected"),
[
(_raise_segment_error, SegmentDatasetNotFoundError(), NotFound),
(_raise_segment_error, SegmentDocumentNotFoundError(), NotFound),
(_raise_segment_error, SegmentNotFoundError(), NotFound),
(_raise_segment_error, ChildChunkNotFoundError(), NotFound),
(_raise_segment_error, SegmentUploadFileNotFoundError(), NotFound),
(_raise_segment_error, SegmentPermissionDeniedError(), Forbidden),
(_raise_segment_error, SegmentDatasetModelUnavailableError(), ValueError),
(_raise_segment_error, SegmentInvalidFileTypeError(), ValueError),
(_raise_segment_embedding_error, SegmentEmbeddingModelUnavailableError(), ProviderNotInitializeError),
(_raise_segment_status_error, SegmentDocumentIndexingError(), InvalidActionError),
(_raise_segment_status_error, SegmentStatusUpdateError(), InvalidActionError),
(_raise_segment_status_error, SegmentEmbeddingModelUnavailableError(), ProviderNotInitializeError),
(_raise_child_chunk_write_error, ChildChunkIndexingApplicationError(), ChildChunkIndexingError),
(_raise_child_chunk_create_error, ChildChunkIndexingApplicationError(), ChildChunkIndexingError),
(_raise_child_chunk_create_error, SegmentEmbeddingModelUnavailableError(), ProviderNotInitializeError),
(_raise_child_chunk_delete_error, ChildChunkDeleteIndexApplicationError(), ChildChunkDeleteIndexError),
# Every narrow translator falls back to the shared scope mapping.
(_raise_child_chunk_delete_error, SegmentNotFoundError(), NotFound),
],
)
def test_segment_application_errors_map_to_existing_http_contract(
translate: Callable[[Exception], Never], error: Exception, expected: type[Exception]
) -> None:
with pytest.raises(expected):
translate(error)
def test_scope_translator_does_not_map_other_operations_errors() -> None:
error = ChildChunkIndexingApplicationError()
with pytest.raises(ChildChunkIndexingApplicationError) as raised:
_raise_segment_error(error)
assert raised.value is error
@@ -0,0 +1,164 @@
from inspect import unwrap
from types import SimpleNamespace
from unittest.mock import create_autospec
from uuid import UUID
import pytest
from werkzeug.exceptions import Forbidden, InternalServerError, NotFound
from controllers.console.datasets import external as controller
from controllers.console.datasets.error import DatasetNameDuplicateError
from machinery.context import RequestContext
from services.errors.dataset import DatasetNameDuplicateError as DuplicateName
from services.knowledge.dataset_access import DatasetAccessDeniedError, DatasetNotFoundError
from services.knowledge.external.application import (
ExternalHitTestingError,
ExternalKnowledgeApplicationService,
ExternalTemplateNotFoundError,
)
CONTEXT = RequestContext("request-1", None, "actor-1", "tenant-1")
ID = UUID(int=1)
@pytest.fixture
def external(monkeypatch):
service = create_autospec(ExternalKnowledgeApplicationService, instance=True, spec_set=True)
monkeypatch.setattr(
controller, "application_services", lambda: SimpleNamespace(knowledge=SimpleNamespace(external=service))
)
return service
def test_templates_preserve_pagination(external):
page = {"data": [], "total": 0, "has_more": False, "page": 1, "limit": 100}
external.list_templates.return_value = page
result = unwrap(controller.ExternalApiTemplateListApi.get)(
controller.ExternalApiTemplateListApi(),
controller.ExternalApiTemplateListQuery(page=0, limit=1000, keyword="test"),
CONTEXT,
)
assert result == (page, 200)
external.list_templates.assert_called_once_with(CONTEXT, page=0, limit=1000, keyword="test")
@pytest.mark.parametrize(
("resource", "verb", "operation", "payload"),
[
(
controller.ExternalApiTemplateListApi,
controller.ExternalApiTemplateListApi.post,
lambda service: service.create_template,
True,
),
(
controller.ExternalApiTemplateApi,
controller.ExternalApiTemplateApi.get,
lambda service: service.get_template,
False,
),
(
controller.ExternalApiTemplateApi,
controller.ExternalApiTemplateApi.patch,
lambda service: service.update_template,
True,
),
(
controller.ExternalApiTemplateApi,
controller.ExternalApiTemplateApi.delete,
lambda service: service.delete_template,
False,
),
],
)
def test_template_missing_is_mapped_and_context_forwarded(external, resource, verb, operation, payload):
method = operation(external)
method.side_effect = ExternalTemplateNotFoundError("API template not found.")
args = (
[
controller.ExternalKnowledgeApiPayload(
name="API", settings={"endpoint": "https://example", "api_key": "secret"}
)
]
if payload
else []
)
args.append(CONTEXT)
if resource is controller.ExternalApiTemplateApi:
args.append(ID)
with pytest.raises(NotFound):
unwrap(verb)(resource(), *args)
assert method.call_args.args == (CONTEXT,)
if resource is controller.ExternalApiTemplateApi:
assert method.call_args.kwargs["template_id"] == str(ID)
def test_template_serializes_settings_and_timestamp(external):
external.get_template.return_value = {
"id": str(ID),
"name": "API",
"tenant_id": "tenant-1",
"settings": {"endpoint": "https://example", "api_key": "[__HIDDEN__]"},
"description": "",
"created_by": "actor-1",
"created_at": "2024-01-01T00:00:00",
"dataset_bindings": [],
}
result, status = unwrap(controller.ExternalApiTemplateApi.get)(controller.ExternalApiTemplateApi(), CONTEXT, ID)
assert status == 200
assert result == external.get_template.return_value
def test_delete_and_usage_response_contracts(external):
assert unwrap(controller.ExternalApiTemplateApi.delete)(controller.ExternalApiTemplateApi(), CONTEXT, ID) == (
"",
204,
)
external.template_usage.return_value = (True, 3)
assert unwrap(controller.ExternalApiUseCheckApi.get)(controller.ExternalApiUseCheckApi(), CONTEXT, ID) == (
{"is_using": True, "count": 3},
200,
)
def test_external_dataset_duplicate_name_maps_to_409(external):
payload = controller.ExternalDatasetCreatePayload(
name="Dataset", external_knowledge_api_id="api", external_knowledge_id="knowledge"
)
external.create_dataset.side_effect = DuplicateName()
with pytest.raises(DatasetNameDuplicateError):
unwrap(controller.ExternalDatasetCreateApi.post)(controller.ExternalDatasetCreateApi(), payload, CONTEXT)
external.create_dataset.assert_called_once_with(CONTEXT, payload=payload)
@pytest.mark.parametrize(
("error", "http_error"),
[
(DatasetNotFoundError(), NotFound),
(DatasetAccessDeniedError(), Forbidden),
(ExternalHitTestingError("failed"), InternalServerError),
],
)
def test_retrieval_maps_application_errors(external, error, http_error):
external.hit_testing.side_effect = error
with pytest.raises(http_error):
unwrap(controller.ExternalKnowledgeHitTestingApi.post)(
controller.ExternalKnowledgeHitTestingApi(),
controller.ExternalHitTestingPayload(query="query"),
CONTEXT,
ID,
)
external.hit_testing.assert_called_once_with(
CONTEXT, dataset_id=str(ID), query="query", retrieval_model=None, metadata_filters=None
)
def test_retrieval_response_is_serialized(external):
external.hit_testing.return_value = {
"query": {"content": "query"},
"records": [{"content": "answer", "title": "title", "score": 0.8, "metadata": {"source": "doc"}}],
}
result = unwrap(controller.ExternalKnowledgeHitTestingApi.post)(
controller.ExternalKnowledgeHitTestingApi(), controller.ExternalHitTestingPayload(query="query"), CONTEXT, ID
)
assert result == external.hit_testing.return_value
@@ -0,0 +1,237 @@
import uuid
from inspect import unwrap
from unittest.mock import MagicMock, PropertyMock, patch
import pytest
from flask import Flask
from pytest_mock import MockerFixture
from werkzeug.exceptions import NotFound
from controllers.console import console_ns
from controllers.console.datasets.hit_testing import HitTestingApi
from models.account import Account, Tenant, TenantAccountRole
from models.dataset import Dataset
@pytest.fixture
def app():
app = Flask("test_hit_testing")
app.config["TESTING"] = True
return app
@pytest.fixture
def dataset_id():
return uuid.uuid4()
@pytest.fixture
def dataset():
return Dataset(id="dataset-1", tenant_id="tenant-1", name="Dataset", created_by="account-1")
@pytest.fixture
def account() -> Account:
account = Account(name="User", email="user@example.com")
account.id = "account-1"
tenant = Tenant(name="Tenant")
tenant.id = "tenant-1"
account._current_tenant = tenant
account.role = TenantAccountRole.OWNER
return account
def hit_testing_record() -> dict[str, object]:
return {
"segment": {
"id": "segment-1",
"position": 1,
"document_id": "document-1",
"content": "Chunk text",
"sign_content": "Chunk text",
"answer": None,
"word_count": 2,
"tokens": 3,
"keywords": [],
"index_node_id": None,
"index_node_hash": None,
"hit_count": 0,
"enabled": True,
"disabled_at": None,
"disabled_by": None,
"status": "completed",
"created_by": "account-1",
"created_at": 1_700_000_000,
"indexing_at": None,
"completed_at": None,
"error": None,
"stopped_at": None,
"document": {
"id": "document-1",
"data_source_type": "upload_file",
"name": "guide.md",
"doc_type": None,
"doc_metadata": None,
},
},
"child_chunks": [],
"score": None,
"tsne_position": None,
"files": [],
"summary": None,
}
@pytest.fixture(autouse=True)
def bypass_decorators(mocker: MockerFixture):
"""Bypass all decorators on the API method."""
mocker.patch(
"controllers.console.datasets.hit_testing.setup_required",
lambda f: f,
)
mocker.patch(
"controllers.console.datasets.hit_testing.login_required",
return_value=lambda f: f,
)
mocker.patch(
"controllers.console.datasets.hit_testing.account_initialization_required",
return_value=lambda f: f,
)
mocker.patch(
"controllers.console.datasets.hit_testing.cloud_edition_billing_rate_limit_check",
return_value=lambda *_: lambda f: f,
)
class TestHitTestingApi:
def test_hit_testing_success(self, app: Flask, dataset, dataset_id, account: Account):
api = HitTestingApi()
method = unwrap(api.post)
payload = {
"query": "what is vector search",
}
with (
app.test_request_context("/"),
patch.object(
type(console_ns),
"payload",
new_callable=PropertyMock,
return_value=payload,
),
patch.object(
HitTestingApi,
"get_and_validate_dataset",
return_value=dataset,
),
patch.object(
HitTestingApi,
"hit_testing_args_check",
),
patch.object(
HitTestingApi,
"perform_hit_testing",
return_value={"query": {"content": "what is vector search"}, "records": []},
),
):
result = method(api, MagicMock(), account, "tenant-1", dataset_id)
assert "query" in result
assert "records" in result
assert result["records"] == []
def test_hit_testing_success_with_optional_record_fields(self, app: Flask, dataset, dataset_id, account: Account):
api = HitTestingApi()
method = unwrap(api.post)
payload = {
"query": "what is vector search",
}
records = [hit_testing_record()]
with (
app.test_request_context("/"),
patch.object(
type(console_ns),
"payload",
new_callable=PropertyMock,
return_value=payload,
),
patch.object(
HitTestingApi,
"get_and_validate_dataset",
return_value=dataset,
),
patch.object(
HitTestingApi,
"hit_testing_args_check",
),
patch.object(
HitTestingApi,
"perform_hit_testing",
return_value={"query": {"content": payload["query"]}, "records": records},
),
):
result = method(api, MagicMock(), account, "tenant-1", dataset_id)
assert result["query"] == {"content": payload["query"]}
assert result["records"][0]["segment"]["keywords"] == []
assert result["records"][0]["child_chunks"] == []
assert result["records"][0]["files"] == []
assert result["records"][0]["score"] is None
def test_hit_testing_dataset_not_found(self, app: Flask, dataset_id, account: Account):
api = HitTestingApi()
method = unwrap(api.post)
payload = {
"query": "test",
}
with (
app.test_request_context("/"),
patch.object(
type(console_ns),
"payload",
new_callable=PropertyMock,
return_value=payload,
),
patch.object(
HitTestingApi,
"get_and_validate_dataset",
side_effect=NotFound("Dataset not found"),
),
):
with pytest.raises(NotFound, match="Dataset not found"):
method(api, MagicMock(), account, "tenant-1", dataset_id)
def test_hit_testing_invalid_args(self, app: Flask, dataset, dataset_id, account: Account):
api = HitTestingApi()
method = unwrap(api.post)
payload = {
"query": "",
}
with (
app.test_request_context("/"),
patch.object(
type(console_ns),
"payload",
new_callable=PropertyMock,
return_value=payload,
),
patch.object(
HitTestingApi,
"get_and_validate_dataset",
return_value=dataset,
),
patch.object(
HitTestingApi,
"hit_testing_args_check",
side_effect=ValueError("Invalid parameters"),
),
):
with pytest.raises(ValueError, match="Invalid parameters"):
method(api, MagicMock(), account, "tenant-1", dataset_id)
Loaded 100 of 15831 files, more files were not shown because too many files have changed in this diff. Show more