chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动
演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。 Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
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
|
||||
+20
@@ -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"
|
||||
+39
@@ -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)
|
||||
+49
@@ -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"
|
||||
+400
@@ -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
|
||||
+347
@@ -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.
+32
@@ -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"}
|
||||
+182
@@ -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)
|
||||
+627
@@ -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"
|
||||
+245
@@ -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
|
||||
+481
@@ -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()
|
||||
+239
@@ -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
|
||||
+172
@@ -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."""
|
||||
Whitespace-only changes.
+988
@@ -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")
|
||||
+117
@@ -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}
|
||||
+513
@@ -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()
|
||||
+189
@@ -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)
|
||||
+470
@@ -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"]
|
||||
+402
@@ -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()
|
||||
+1647
File diff suppressed because it is too large.
Load diff
@@ -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."
|
||||
+784
@@ -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"
|
||||
)
|
||||
+402
@@ -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
Reference in new issue
Block a user