Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
test(api): replace change-detector assertions with behavior contracts (#45298)
JackSmitha992b4269912
diff --git a/api/tests/unit_tests/dev/test_generate_swagger_specs.py b/api/tests/unit_tests/dev/test_generate_swagger_specs.pyindex a66ee9365f6..8421365a32b 100644--- a/api/tests/unit_tests/dev/test_generate_swagger_specs.py+++ b/api/tests/unit_tests/dev/test_generate_swagger_specs.py@@ -3,12 +3,14 @@import importlib.utilimport jsonimport os+import reimport subprocessimport sysfrom pathlib import Pathimport pytestfrom jsonschema import Draft202012Validator+from jsonschema.exceptions import SchemaErrorfrom tests.helpers.unit.config_override import apply_config_overrides@@ -61,17 +63,152 @@ def _request_schema(operation, content_type="application/json"):return operation["requestBody"]["content"][content_type]["schema"]-def _nullable_schema_ref(schema):- if "$ref" in schema:- return schema["$ref"]- return next(item["$ref"] for item in schema["anyOf"] if "$ref" in item)--def _reset_schema_cache(api):api._schema = Noneapi.__dict__.pop("__schema__", None)+_OPENAPI_METHODS = {"delete", "get", "head", "options", "patch", "post", "put", "trace"}++_SCHEMA_MAP_KEYWORDS = ("$defs", "definitions", "dependentSchemas", "patternProperties", "properties")+_SCHEMA_OBJECT_KEYWORDS = (+ "additionalProperties",+ "contains",+ "else",+ "if",+ "items",+ "not",+ "propertyNames",+ "then",+ "unevaluatedItems",+ "unevaluatedProperties",+)+_SCHEMA_LIST_KEYWORDS = ("allOf", "anyOf", "oneOf", "prefixItems")+++def _iter_subschemas(schema):+ if not isinstance(schema, dict):+ return+ yield schema+ for keyword in _SCHEMA_MAP_KEYWORDS:+ for child in (schema.get(keyword) or {}).values():+ yield from _iter_subschemas(child)+ for keyword in _SCHEMA_OBJECT_KEYWORDS:+ if keyword in schema:+ child = schema[keyword]+ if isinstance(child, list):+ for item in child:+ yield from _iter_subschemas(item)+ else:+ yield from _iter_subschemas(child)+ for keyword in _SCHEMA_LIST_KEYWORDS:+ for child in schema.get(keyword) or []:+ yield from _iter_subschemas(child)+++def _iter_content_schemas(content):+ """Yield unmodified schema roots from an optional OpenAPI content mapping."""+ for media_type in (content or {}).values():+ if isinstance(media_type, dict) and "schema" in media_type:+ yield media_type["schema"]+++def _iter_parameter_schemas(parameter):+ """Yield unmodified schema roots when the input is an OpenAPI parameter mapping."""+ if not isinstance(parameter, dict):+ return+ if "schema" in parameter:+ yield parameter["schema"]+ yield from _iter_content_schemas(parameter.get("content"))+++def _iter_operation_schemas(operation):+ for parameter in operation.get("parameters") or []:+ yield from _iter_parameter_schemas(parameter)+ request_body = operation.get("requestBody")+ if isinstance(request_body, dict):+ yield from _iter_content_schemas(request_body.get("content"))+ for response in (operation.get("responses") or {}).values():+ if not isinstance(response, dict):+ continue+ yield from _iter_content_schemas(response.get("content"))+ for header in (response.get("headers") or {}).values():+ yield from _iter_parameter_schemas(header)+++def _iter_document_schemas(payload):+ """Yield schema roots from a document without recursively duplicating their children."""+ yield from payload["components"]["schemas"].values()+ for path_item in payload["paths"].values():+ for parameter in path_item.get("parameters") or []:+ yield from _iter_parameter_schemas(parameter)+ for method, operation in path_item.items():+ if method in _OPENAPI_METHODS and isinstance(operation, dict):+ yield from _iter_operation_schemas(operation)+++def _schema_contract_errors(payload):+ """Report invalid schemas and broken local contracts without changing the document.++ The input has OpenAPI paths and component schemas. Validate each schema tree+ once, then inspect its subschemas for required fields and local references.+ """+ errors = []+ known_refs = {f"#/components/schemas/{name}" for name in payload["components"]["schemas"]}+ roots = list(_iter_document_schemas(payload))+ # check_schema recursively validates children. Batching roots also avoids+ # constructing the meta-schema validator again for every property and ref.+ try:+ Draft202012Validator.check_schema({"$defs": {str(index): schema for index, schema in enumerate(roots)}})+ except SchemaError as exc:+ return [f"malformed schema: {exc}"]+ for schema in (child for root in roots for child in _iter_subschemas(root)):+ required = schema.get("required")+ properties = schema.get("properties")+ if required and isinstance(properties, dict) and not ({"allOf", "anyOf", "oneOf", "$ref"} & schema.keys()):+ missing = sorted(set(required) - set(properties))+ if missing:+ errors.append(f"required properties missing from properties: {missing}")+ ref = schema.get("$ref")+ if isinstance(ref, str) and ref.startswith("#/components/schemas/") and ref not in known_refs:+ errors.append(f"dangling $ref: {ref}")+ discriminator = schema.get("discriminator")+ if isinstance(discriminator, dict):+ for mapped in (discriminator.get("mapping") or {}).values():+ if isinstance(mapped, str) and mapped.startswith("#/components/schemas/") and mapped not in known_refs:+ errors.append(f"dangling discriminator mapping: {mapped}")+ return errors+++def _operation_contract_errors(payload):+ errors = []+ for path, path_item in payload["paths"].items():+ template_parameters = set(re.findall(r"\{([^{}]+)\}", path))+ path_level_parameters = [p for p in path_item.get("parameters") or [] if isinstance(p, dict)]+ for method, operation in path_item.items():+ if method not in _OPENAPI_METHODS or not isinstance(operation, dict):+ continue+ label = f"{method.upper()} {path}"+ if not operation.get("operationId"):+ errors.append(f"{label}: missing operationId")+ responses = operation.get("responses")+ if not responses:+ errors.append(f"{label}: missing responses")+ else:+ for status, response in responses.items():+ if not isinstance(response, dict) or not response.get("description"):+ errors.append(f"{label} {status}: response is missing a description")+ parameters = path_level_parameters + [p for p in operation.get("parameters") or [] if isinstance(p, dict)]+ declared = {p.get("name") for p in parameters if p.get("in") == "path"}+ undeclared = sorted(template_parameters - declared)+ if undeclared:+ errors.append(f"{label}: path parameters not declared: {undeclared}")+ for parameter in parameters:+ if parameter.get("in") == "path" and parameter.get("required") is not True:+ errors.append(f"{label}: path parameter {parameter.get('name')!r} is not required")+ return errors++@pytest.fixture(scope="module")def generated_specs(tmp_path_factory: pytest.TempPathFactory) -> list[Path]:"""Spec files written once by ``generate_specs`` for the tests that only read them.@@ -439,236 +576,52 @@ def test_generate_specs_include_command_oriented_knowledge_fs_contract(generatedassert tree_operation["operationId"] == "tree_knowledge_fs"-def test_generate_specs_writes_service_api_reference_descriptions(generated_specs: list[Path]):- service_path = next(path for path in generated_specs if path.name == "service-openapi.json")- payload = json.loads(service_path.read_text(encoding="utf-8"))-- chat_operation = payload["paths"]["/chat-messages"]["post"]- assert chat_operation["summary"] == "Send Chat Message"- assert chat_operation["description"] == "Send a request to the chat application."- assert chat_operation["tags"] == ["Chatflows", "Chats"]- serialized_payload = json.dumps(payload)- assert "](/api-reference/files/upload-file)" in serialized_payload- assert "](/en/api-reference/" not in serialized_payload-- rename_operation = payload["paths"]["/conversations/{conversation_id}/name"]["post"]- assert rename_operation["summary"] == "Rename Conversation"-- datasource_node_operation = payload["paths"]["/datasets/{dataset_id}/pipeline/datasource/nodes/{node_id}/run"][- "post"- ]- assert datasource_node_operation["operationId"] == "run_datasource_node"-- pipeline_operation = payload["paths"]["/datasets/{dataset_id}/pipeline/run"]["post"]- assert pipeline_operation["operationId"] == "run_pipeline"-- chat_error_content = chat_operation["responses"]["401"]["content"]- # No business error on chat-messages answers 401, so it keeps the open error body.- assert chat_error_content == {"application/json": {"schema": {"$ref": "#/components/schemas/ErrorResponse"}}}- chat_success_content = chat_operation["responses"]["200"]["content"]- assert chat_success_content["application/json"]["schema"] == {"$ref": "#/components/schemas/ChatBlockingResponse"}- assert chat_success_content["text/event-stream"]["schema"] == {"type": "string"}-- upload_bad_request = payload["paths"]["/files/upload"]["post"]["responses"]["400"]["description"]- assert "`file_extension_blocked`" in upload_bad_request-- schemas = payload["components"]["schemas"]- expected_property_descriptions = {- ("AgentThought", "tool_labels"): "Labels for tools used.",- ("CompletionBlockingResponse", "metadata"): "Metadata including usage and retriever resources.",- ("DatasetCreatePayload", "retrieval_model"): (- "Retrieval model configuration. Controls how chunks are searched and ranked when querying this "- "knowledge base."- ),- ("DatasetDetailResponse", "external_knowledge_info"): (- "Connection details for external knowledge bases. Populated when `provider` is `external`; otherwise "- "its properties are `null`."- ),- ("DatasetDetailResponse", "icon_info"): "Icon display configuration for the knowledge base.",- ("DatasetDetailResponse", "retrieval_model_dict"): "Retrieval configuration for the knowledge base.",- ("DatasetDetailResponse", "summary_index_setting"): "Summary index configuration.",- ("DatasetRetrievalModelResponse", "reranking_model"): "Reranking model configuration.",- ("DatasetWeightedScoreResponse", "keyword_setting"): "Keyword search weight settings.",- ("DatasetWeightedScoreResponse", "vector_setting"): "Semantic search weight settings.",- ("HitTestingRecord", "segment"): "Matched chunk from the knowledge base.",- ("HitTestingResponse", "query"): "The original query object.",- ("HitTestingSegment", "document"): "Parent document information for the matched chunk.",- ("Parameters", "system_parameters"): "System-level parameter limits.",- ("ParagraphInputConfig", "default"): (- "Raw default-value configuration for the paragraph input. Runtime-resolved values are exposed in the "- "surrounding `resolved_default_values` mapping."- ),- ("ProviderModelWithStatusEntity", "fetch_from"): (- "Where the model definition comes from. `predefined-model` for built-in models, "- "`customizable-model` for user-configured models."- ),- ("ProviderWithModelsResponse", "status"): (- "Provider status. `active` when credentials are configured and valid."- ),- ("SelectInputConfig", "option_source"): (- "Source of options for `select` inputs. Present only when `type` is `select`."+ ("nested_schema", "expected_error"),+ [+ ({"type": "invalid-type"}, "malformed schema"),+ ({"properties": {}, "required": ["missing"]}, "required properties missing"),+ ({"$ref": "#/components/schemas/Missing"}, "dangling $ref"),+ (+ {"discriminator": {"propertyName": "kind", "mapping": {"cat": "#/components/schemas/Missing"}}},+ "dangling discriminator mapping",),- ("StringListSource", "selector"): "Variable reference path when `type` is `variable`.",+ ],+)+def test_schema_contract_rejects_invalid_nested_schemas(nested_schema, expected_error):+ """Nested schema defects must remain detectable when validating roots together."""+ payload = {+ "components": {"schemas": {"Envelope": {"properties": {"nested": nested_schema}}}},+ "paths": {},}- for (schema_name, property_name), description in expected_property_descriptions.items():- assert schemas[schema_name]["properties"][property_name]["description"] == description- assert schemas["PipelineRunJsonResponse"]["description"] == (- "JSON result for published runs and draft runs using `response_mode: blocking`."- )- for schema_name in ("DatasetDetailResponse", "DatasetDetailWithPartialMembersResponse"):- assert schemas[schema_name]["properties"]["external_knowledge_info"]["description"] == (- "Connection details for external knowledge bases. Populated when `provider` is `external`; otherwise "- "its properties are `null`."- )+ assert any(expected_error in error for error in _schema_contract_errors(payload))- chat_blocking_schema = schemas["ChatBlockingResponse"]- assert chat_blocking_schema["discriminator"] == {- "mapping": {- "message": "#/components/schemas/ChatMessageBlockingResponse",- "workflow_paused": "#/components/schemas/ChatPausedBlockingResponse",- },- "propertyName": "event",- }- assert schemas["ChatPausedBlockingDataResponse"]["properties"]["reasons"]["items"] == {- "$ref": "#/components/schemas/ChatPauseReasonResponse"- }- chat_pause_reason = schemas["ChatPauseReasonResponse"]- assert chat_pause_reason["required"] == ["TYPE"]- assert {"form_token", "expiration_time", "inputs", "actions", "TYPE"} <= set(chat_pause_reason["properties"])-- feedback_properties = schemas["AppFeedbackResponse"]["properties"]- assert feedback_properties["created_at"]["type"] == "string"- assert "format" not in feedback_properties["created_at"]- assert feedback_properties["updated_at"]["type"] == "string"- assert "format" not in feedback_properties["updated_at"]-- completion_success_content = payload["paths"]["/completion-messages"]["post"]["responses"]["200"]["content"]- assert completion_success_content["application/json"]["schema"] == {- "$ref": "#/components/schemas/CompletionBlockingResponse"- }- assert completion_success_content["text/event-stream"]["schema"] == {"type": "string"}- workflow_success_content = payload["paths"]["/workflows/run"]["post"]["responses"]["200"]["content"]- assert workflow_success_content["application/json"]["schema"] == {- "$ref": "#/components/schemas/WorkflowBlockingResponse"- }- assert workflow_success_content["text/event-stream"]["schema"] == {"type": "string"}- workflow_blocking_refs = {branch["$ref"] for branch in schemas["WorkflowBlockingResponse"]["anyOf"]}- assert workflow_blocking_refs == {- "#/components/schemas/WorkflowFinishedBlockingResponse",- "#/components/schemas/WorkflowPausedBlockingResponse",- }- workflow_paused_properties = schemas["WorkflowPausedBlockingDataResponse"]["properties"]- assert {"paused_nodes", "reasons"} <= set(workflow_paused_properties)- assert workflow_paused_properties["reasons"]["items"] == {- "$ref": "#/components/schemas/WorkflowPauseReasonResponse"- }- workflow_pause_reason = schemas["WorkflowPauseReasonResponse"]- assert workflow_pause_reason["required"] == ["TYPE"]- assert {"form_token", "expiration_time", "inputs", "actions", "TYPE"} <= set(workflow_pause_reason["properties"])[email protected](60) # Validate all five exports under coverage, including the large console schema.+def test_generate_specs_produce_valid_openapi_contracts(tmp_path: Path):+ module = _load_generate_swagger_specs_module()- pipeline_success_content = pipeline_operation["responses"]["200"]["content"]- assert pipeline_success_content["application/json"]["schema"] == {- "$ref": "#/components/schemas/PipelineRunJsonResponse"- }- assert pipeline_success_content["text/event-stream"]["schema"] == {"type": "string"}- pipeline_json_refs = {branch["$ref"] for branch in schemas["PipelineRunJsonResponse"]["anyOf"]}- assert pipeline_json_refs == {- "#/components/schemas/PublishedPipelineRunResponse",- "#/components/schemas/WorkflowBlockingResponse",- }- assert schemas["PublishedPipelineRunResponse"]["required"] == ["batch", "dataset", "documents"]-- preview_content = payload["paths"]["/files/{file_id}/preview"]["get"]["responses"]["200"]["content"]- assert preview_content == {"*/*": {"schema": {"format": "binary", "type": "string"}}}-- scoped_stop_schema = schemas["ScopedTaskStopPayload"]- workflow_stop_schema = schemas["WorkflowTaskStopPayload"]- assert scoped_stop_schema["required"] == ["user"]- assert workflow_stop_schema["required"] == ["user"]- assert "Send the same" in scoped_stop_schema["properties"]["user"]["description"]- assert "does not need to match" in workflow_stop_schema["properties"]["user"]["description"]- for path in ("/chat-messages/{task_id}/stop", "/completion-messages/{task_id}/stop"):- assert _request_schema(payload["paths"][path]["post"])["$ref"] == ("#/components/schemas/ScopedTaskStopPayload")- assert "404" not in payload["paths"][path]["post"]["responses"]- assert _request_schema(payload["paths"]["/workflows/tasks/{task_id}/stop"]["post"])["$ref"] == (- "#/components/schemas/WorkflowTaskStopPayload"- )- assert "404" not in payload["paths"]["/workflows/tasks/{task_id}/stop"]["post"]["responses"]-- vector_space_operations = {- (method, path)- for path, path_item in payload["paths"].items()- for method, operation in path_item.items()- if isinstance(operation, dict)- and "503" in operation.get("responses", {})- # KnowledgeFS operations document their own 503 when KnowledgeFS is unavailable.- and not path.startswith("/knowledge-fs/")- }- assert vector_space_operations == {- ("post", "/datasets/{dataset_id}/document/create-by-file"),- ("post", "/datasets/{dataset_id}/document/create-by-text"),- ("post", "/datasets/{dataset_id}/document/create_by_file"),- ("post", "/datasets/{dataset_id}/document/create_by_text"),- ("patch", "/datasets/{dataset_id}/documents/{document_id}"),- ("post", "/datasets/{dataset_id}/documents/{document_id}/segments"),- ("post", "/datasets/{dataset_id}/documents/{document_id}/segments/{segment_id}"),- ("post", "/datasets/{dataset_id}/documents/{document_id}/segments/{segment_id}/child_chunks"),- (- "patch",- "/datasets/{dataset_id}/documents/{document_id}/segments/{segment_id}/child_chunks/{child_chunk_id}",- ),- ("post", "/datasets/{dataset_id}/documents/{document_id}/update-by-file"),- ("post", "/datasets/{dataset_id}/documents/{document_id}/update-by-text"),- ("post", "/datasets/{dataset_id}/documents/{document_id}/update_by_file"),- ("post", "/datasets/{dataset_id}/documents/{document_id}/update_by_text"),- }- vector_space_unavailable_description = (- "`service_unavailable` : Vector space usage could not be verified. Returned on the Dify Cloud Sandbox "- "plan only; retry the request later."- )- for method, path in vector_space_operations:- assert payload["paths"][path][method]["responses"]["503"]["description"] == (- vector_space_unavailable_description- )+ written_paths = module.generate_specs(tmp_path)- for path in (- "/datasets/{dataset_id}/document/create-by-file",- "/datasets/{dataset_id}/document/create-by-text",- "/datasets/{dataset_id}/document/create_by_text",- "/datasets/{dataset_id}/metadata/built-in",- "/datasets/{dataset_id}/tags",- ):- operation = next(- operation- for operation in payload["paths"][path].values()- if isinstance(operation, dict) and "responses" in operation- )- assert operation["responses"]["404"]["description"] == "`not_found` : Knowledge base not found."-- assert "503" not in payload["paths"]["/datasets/{dataset_id}"]["patch"]["responses"]-- text_to_audio_content = payload["paths"]["/text-to-audio"]["post"]["responses"]["200"]["content"]- assert text_to_audio_content == {- media_type: {"schema": {"format": "binary", "type": "string"}}- for media_type in (- "audio/aac",- "audio/flac",- "audio/mp4",- "audio/mpeg",- "audio/ogg",- "audio/wav",- "audio/webm",- )- }+ assert len(written_paths) == 5+ for path in written_paths:+ payload = json.loads(path.read_text(encoding="utf-8"))+ assert payload["openapi"].startswith("3."), path.name+ assert payload["paths"], path.name+ assert _schema_contract_errors(payload) == [], path.name+ assert _operation_contract_errors(payload) == [], path.name- tag_binding_schema = payload["components"]["schemas"]["TagBindingPayload"]- assert tag_binding_schema["properties"]["tag_ids"]["minItems"] == 1- file_item_schema = payload["components"]["schemas"]["CompletionRequestPayloadWithUser"]["properties"]["files"][- "anyOf"- ][0]["items"]+def test_generated_request_contracts_accept_and_reject_payloads(tmp_path: Path):+ module = _load_generate_swagger_specs_module()++ written_paths = module.generate_specs(tmp_path)+ service_path = next(path for path in written_paths if path.name == "service-openapi.json")+ payload = json.loads(service_path.read_text(encoding="utf-8"))+ schemas = payload["components"]["schemas"]++ file_item_schema = schemas["CompletionRequestPayloadWithUser"]["properties"]["files"]["anyOf"][0]["items"]file_validator = Draft202012Validator(file_item_schema)valid_file_values = [{"type": "image", "transfer_method": "remote_url", "url": "https://example.com/image.png"},@@ -695,7 +648,7 @@ def test_generate_specs_writes_service_api_reference_descriptions(generated_specfor value in invalid_file_values:assert list(file_validator.iter_errors(value)), value- user_input_form_schema = payload["components"]["schemas"]["Parameters"]["properties"]["user_input_form"]+ user_input_form_schema = schemas["Parameters"]["properties"]["user_input_form"]validator = Draft202012Validator(user_input_form_schema)form_values = {"text-input": "hello",@@ -724,28 +677,6 @@ def test_generate_specs_writes_service_api_reference_descriptions(generated_specfor value in invalid_values:assert list(validator.iter_errors(value)), value- file_upload_schema = payload["components"]["schemas"]["Parameters"]["properties"]["file_upload"]- file_upload_properties = file_upload_schema["properties"]- assert {- "enabled",- "number_limits",- "allowed_file_types",- "allowed_file_extensions",- "allowed_file_upload_methods",- "image",- } <= set(file_upload_properties)- assert set(file_upload_properties["allowed_file_types"]["items"]["enum"]) == {- "document",- "image",- "audio",- "video",- "custom",- }- assert set(file_upload_properties["allowed_file_upload_methods"]["items"]["enum"]) == {- "remote_url",- "local_file",- }-def test_generate_specs_writes_web_file_upload_error_codes(generated_specs: list[Path]):web_path = next(path for path in generated_specs if path.name == "web-openapi.json")@@ -795,156 +726,6 @@ def test_generate_specs_include_agent_v2_knowledge_set_schema_and_query_enums(geassert schemas["AgentKnowledgeQueryMode"]["enum"] == ["generated_query", "user_query"]-def test_generate_specs_include_console_contract_shapes_for_schema_migration(generated_specs: list[Path]):- console_path = next(path for path in generated_specs if path.name == "console-openapi.json")- payload = json.loads(console_path.read_text(encoding="utf-8"))- schemas = payload["components"]["schemas"]- paths = payload["paths"]-- file_upload_schema = _request_schema(paths["/files/upload"]["post"], "multipart/form-data")- assert file_upload_schema["required"] == ["file"]- assert file_upload_schema["properties"]["file"]["format"] == "binary"- assert file_upload_schema["properties"]["file"]["type"] == "string"- assert file_upload_schema["properties"]["source"]["enum"] == ["datasets"]-- package_import = paths["/apps/imports"]["post"]- assert _request_schema(package_import, "multipart/form-data")["required"] == ["file"]- assert _request_schema(package_import, "multipart/form-data")["properties"]["app_id"]["type"] == "string"- assert _request_schema(package_import, "application/json")["$ref"] == "#/components/schemas/AppImportPayload"- assert "mode" in schemas["AppImportPayload"]["required"]- assert "403" in package_import["responses"]- export = paths["/apps/{app_id}/export"]["get"]- assert export["responses"]["200"]["content"]["application/zip"]["schema"] == {"type": "string", "format": "binary"}- assert export["responses"]["200"]["content"]["application/json"]["schema"]["$ref"] == (- "#/components/schemas/AppExportResponse"- )- export_format = next(param for param in export["parameters"] if param["name"] == "format")- assert set(export_format["schema"]["enum"]) == {"yaml", "ifpkg"}- assert export_format["schema"].get("default") is None- assert "defaults to ifpkg for all Apps" in export_format["description"]-- api_key_auth_binding_schema = _request_schema(paths["/api-key-auth/data-source/binding"]["post"])- assert api_key_auth_binding_schema["$ref"] == "#/components/schemas/ApiKeyAuthBindingPayload"- assert schemas["ApiKeyAuthBindingPayload"]["properties"]["credentials"]["$ref"] == (- "#/components/schemas/ApiKeyAuthCredentialsPayload"- )- assert schemas["ApiKeyAuthCredentialsPayload"]["properties"]["config"]["$ref"] == (- "#/components/schemas/ApiKeyAuthConfigPayload"- )- assert schemas["ApiKeyAuthConfigPayload"]["properties"]["api_key"]["minLength"] == 1-- invoices_schema_ref = _response_schema(paths["/billing/invoices"]["get"])["$ref"].removeprefix(- "#/components/schemas/"- )- assert schemas[invoices_schema_ref]["properties"]["url"]["type"] == "string"-- app_detail_schema = schemas["RecommendedAppDetailResponse"]- assert app_detail_schema["properties"]["id"]["type"] == "string"- assert app_detail_schema["properties"]["export_data"]["type"] == "string"- assert app_detail_schema["properties"]["can_trial"]["type"] == "boolean"- assert "anyOf" not in app_detail_schema["properties"]["can_trial"]- assert "can_trial" in app_detail_schema["required"]- app_list_item_schema = schemas["RecommendedAppResponse"]- assert app_list_item_schema["properties"]["can_trial"]["type"] == "boolean"- assert "anyOf" not in app_list_item_schema["properties"]["can_trial"]- assert "can_trial" in app_list_item_schema["required"]- assert _response_schema(paths["/explore/apps/{app_id}"]["get"])["$ref"] == (- "#/components/schemas/RecommendedAppDetailResponse"- )- assert "404" in paths["/explore/apps/{app_id}"]["get"]["responses"]- assert "RecommendedAppDetailNullableResponse" not in schemas- assert schemas["RecommendedAppInfoResponse"]["properties"]["icon_url"]["readOnly"] is True- assert schemas["InstalledAppInfoResponse"]["properties"]["icon_url"]["readOnly"] is True- assert _response_schema(paths["/apps/{app_id}"]["get"])["$ref"] == "#/components/schemas/AppDetailWithSite"- app_model_config = schemas["AppDetailWithSite"]["properties"]["model_config"]- assert {"$ref": "#/components/schemas/AppModelConfigResponse"} in app_model_config["anyOf"]- app_detail = schemas["AppDetail"]- assert "mode" in app_detail["properties"]- assert "mode_compatible_with_agent" not in app_detail["properties"]- sync_draft_workflow = schemas["SyncDraftWorkflowResponse"]- assert _response_schema(paths["/apps/{app_id}/workflows/draft"]["post"])["$ref"] == (- "#/components/schemas/SyncDraftWorkflowResponse"- )- assert sync_draft_workflow["properties"]["updated_at"]["type"] == "integer"- trigger_run_request = _request_schema(paths["/apps/{app_id}/workflows/draft/trigger/run"]["post"])- assert trigger_run_request["$ref"] == "#/components/schemas/DraftWorkflowTriggerRunPayload"- assert "DraftWorkflowTriggerRunRequest" not in schemas-- draft_variable_list_ref = "#/components/schemas/WorkflowDraftVariableListWithoutValueResponse"- for path in (- "/apps/{app_id}/workflows/draft/variables",- "/snippets/{snippet_id}/workflows/draft/variables",- "/rag/pipelines/{pipeline_id}/workflows/draft/variables",- ):- assert _response_schema(paths[path]["get"])["$ref"] == draft_variable_list_ref- assert schemas["WorkflowDraftVariableListResponse"]["properties"]["items"]["items"]["$ref"] == (- "#/components/schemas/WorkflowDraftVariableResponse"- )- full_content = schemas["WorkflowDraftVariableFullContentResponse"]- assert set(full_content["properties"]) == {"size_bytes", "value_type", "length", "download_url"}- assert "WorkflowDraftVariable" not in schemas- assert "WorkflowDraftVariableList" not in schemas- assert "WorkflowDraftVariableWithoutValue" not in schemas- tool_icon_schema = schemas["ExploreAppMetaResponse"]["properties"]["tool_icons"]["additionalProperties"]- assert {"type": "string"} in tool_icon_schema["anyOf"]- assert {"additionalProperties": True, "type": "object"} in tool_icon_schema["anyOf"]- assert "ToolIconResponse" not in schemas-- plugin_versions = schemas["PluginVersionsResponse"]["properties"]["versions"]- assert plugin_versions["additionalProperties"]["anyOf"][0]["$ref"] == "#/components/schemas/LatestPluginCache"- assert plugin_versions["additionalProperties"]["anyOf"][1]["type"] == "null"- plugin_installations = schemas["PluginInstallationsResponse"]["properties"]["plugins"]- assert plugin_installations["items"]["$ref"] == "#/components/schemas/PluginInstallationItemResponse"-- rbac_whitelist_request = _request_schema(paths["/workspaces/current/rbac/apps/{app_id}/whitelist"]["put"])- assert rbac_whitelist_request["$ref"] == "#/components/schemas/_ResourceAccessScopeRequest"- app_access_policy_params = paths["/workspaces/current/rbac/apps/{app_id}/access-policy"]["get"]["parameters"]- language_param = next(param for param in app_access_policy_params if param["name"] == "language")- assert language_param["schema"]["enum"] == ["en", "ja", "zh"]-- trigger_list_schema = _response_schema(paths["/workspaces/current/triggers"]["get"])- assert trigger_list_schema["$ref"] == "#/components/schemas/TriggerProviderListResponse"- trigger_builder_create_schema = _response_schema(- paths["/workspaces/current/trigger-provider/{provider}/subscriptions/builder/create"]["post"]- )- assert trigger_builder_create_schema["$ref"] == "#/components/schemas/TriggerSubscriptionBuilderCreateResponse"- assert (- schemas["TriggerSubscriptionBuilderCreateResponse"]["properties"]["subscription_builder"]["$ref"]- == "#/components/schemas/SubscriptionBuilderApiEntity"- )-- conversation_variables = schemas["ConversationVariableUpdatePayload"]["properties"]["conversation_variables"]- assert conversation_variables["items"]["$ref"] == "#/components/schemas/ConversationVariableItemPayload"- workflow_features = schemas["WorkflowFeaturesPayload"]["properties"]["features"]- assert workflow_features["$ref"] == "#/components/schemas/WorkflowFeaturesConfigPayload"- workflow_feature_properties = schemas["WorkflowFeaturesConfigPayload"]["properties"]- assert _nullable_schema_ref(workflow_feature_properties["suggested_questions_after_answer"]) == (- "#/components/schemas/WorkflowSuggestedQuestionsAfterAnswerPayload"- )- assert _nullable_schema_ref(workflow_feature_properties["text_to_speech"]) == (- "#/components/schemas/WorkflowTextToSpeechPayload"- )- assert _nullable_schema_ref(workflow_feature_properties["sensitive_word_avoidance"]) == (- "#/components/schemas/WorkflowSensitiveWordAvoidancePayload"- )- assert {"enabled", "model", "prompt"} <= set(schemas["WorkflowSuggestedQuestionsAfterAnswerPayload"]["properties"])- assert {"enabled", "language", "voice", "autoPlay"} <= set(schemas["WorkflowTextToSpeechPayload"]["properties"])- assert schemas["WorkflowTextToSpeechPayload"]["properties"]["autoPlay"]["anyOf"][0]["enum"] == [- "disabled",- "enabled",- ]- assert schemas["AgentTextToSpeechFeatureConfig"]["properties"]["autoPlay"]["anyOf"][0]["enum"] == [- "disabled",- "enabled",- ]- assert {"enabled", "type", "config"} <= set(schemas["WorkflowSensitiveWordAvoidancePayload"]["properties"])- file_upload = schemas["WorkflowFileUploadPayload"]["properties"]- assert {"document", "audio", "video", "custom", "preview_config"} <= set(file_upload)- assert "detail" in schemas["WorkflowFileUploadImagePayload"]["properties"]- assert {"mode", "file_type_list"} <= set(schemas["WorkflowFileUploadPreviewConfigPayload"]["properties"])- assert schemas["AccountWithRoleResponse"]["properties"]["avatar_url"]["readOnly"] is True--def test_checked_in_agent_v2_knowledge_openapi_and_generated_contracts_are_in_sync():api_dir = Path(__file__).resolve().parents[3]repo_root = api_dir.parentdiff --git a/api/tests/unit_tests/enterprise/telemetry/test_metric_handler.py b/api/tests/unit_tests/enterprise/telemetry/test_metric_handler.pyindex f717c50e9c5..5d2df3a9051 100644--- a/api/tests/unit_tests/enterprise/telemetry/test_metric_handler.py+++ b/api/tests/unit_tests/enterprise/telemetry/test_metric_handler.py@@ -7,6 +7,7 @@ from unittest.mock import MagicMock, patchimport pytestfrom enterprise.telemetry.contracts import TelemetryCase, TelemetryEnvelope+from enterprise.telemetry.entities import EnterpriseTelemetryCounter, EnterpriseTelemetryEventfrom enterprise.telemetry.metric_handler import EnterpriseMetricHandler@@ -17,498 +18,288 @@ def mock_redis() -> Iterator[MagicMock]:@pytest.fixture-def sample_envelope() -> TelemetryEnvelope:+def telemetry_sink() -> Iterator[tuple[MagicMock, MagicMock]]:+ """Capture the structured-log emitter and the counter exporter."""+ with (+ patch("extensions.ext_enterprise_telemetry.get_enterprise_exporter") as mock_get_exporter,+ patch("enterprise.telemetry.telemetry_log.emit_metric_only_event") as mock_emit,+ ):+ exporter = MagicMock()+ exporter.include_content = False+ mock_get_exporter.return_value = exporter+ yield mock_emit, exporter+++def _make_envelope(+ case: TelemetryCase,+ payload: dict[str, object] | None = None,+ *,+ event_id: str = "test-event",+ tenant_id: str = "test-tenant",+ metadata: dict[str, object] | None = None,+) -> TelemetryEnvelope:return TelemetryEnvelope(- case=TelemetryCase.APP_CREATED,- tenant_id="test-tenant",- event_id="test-event-123",- payload={"app_id": "app-123", "name": "Test App"},- )---def test_dispatch_app_created(sample_envelope: TelemetryEnvelope, mock_redis: MagicMock) -> None:- mock_redis.set.return_value = True-- handler = EnterpriseMetricHandler()- with patch.object(handler, "_on_app_created") as mock_handler:- handler.handle(sample_envelope)- mock_handler.assert_called_once_with(sample_envelope)---def test_dispatch_app_updated(mock_redis: MagicMock) -> None:- mock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.APP_UPDATED,- tenant_id="test-tenant",- event_id="test-event-456",- payload={},- )-- handler = EnterpriseMetricHandler()- with patch.object(handler, "_on_app_updated") as mock_handler:- handler.handle(envelope)- mock_handler.assert_called_once_with(envelope)---def test_dispatch_app_deleted(mock_redis: MagicMock) -> None:- mock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.APP_DELETED,- tenant_id="test-tenant",- event_id="test-event-789",- payload={},- )-- handler = EnterpriseMetricHandler()- with patch.object(handler, "_on_app_deleted") as mock_handler:- handler.handle(envelope)- mock_handler.assert_called_once_with(envelope)---def test_dispatch_feedback_created(mock_redis: MagicMock) -> None:- mock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.FEEDBACK_CREATED,- tenant_id="test-tenant",- event_id="test-event-abc",- payload={},+ case=case,+ tenant_id=tenant_id,+ event_id=event_id,+ payload=payload or {},+ metadata=metadata,)- handler = EnterpriseMetricHandler()- with patch.object(handler, "_on_feedback_created") as mock_handler:- handler.handle(envelope)- mock_handler.assert_called_once_with(envelope)---def test_dispatch_message_run(mock_redis: MagicMock) -> None:- mock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.MESSAGE_RUN,- tenant_id="test-tenant",- event_id="test-event-msg",- payload={},- )-- handler = EnterpriseMetricHandler()- with patch.object(handler, "_on_message_run") as mock_handler:- handler.handle(envelope)- mock_handler.assert_called_once_with(envelope)--def test_dispatch_tool_execution(mock_redis: MagicMock) -> None:+def test_handle_app_created_emits_event_and_counter(+ mock_redis: MagicMock, telemetry_sink: tuple[MagicMock, MagicMock]+) -> None:+ emit, exporter = telemetry_sinkmock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.TOOL_EXECUTION,- tenant_id="test-tenant",- event_id="test-event-tool",- payload={},+ envelope = _make_envelope(+ TelemetryCase.APP_CREATED,+ {"app_id": "app-789", "mode": "chat"},+ event_id="event-456",+ tenant_id="tenant-123",)- handler = EnterpriseMetricHandler()- with patch.object(handler, "_on_tool_execution") as mock_handler:- handler.handle(envelope)- mock_handler.assert_called_once_with(envelope)---def test_dispatch_moderation_check(mock_redis: MagicMock) -> None:+ EnterpriseMetricHandler().handle(envelope)++ emit.assert_called_once()+ event = emit.call_args.kwargs+ assert event["event_name"] == EnterpriseTelemetryEvent.APP_CREATED+ assert event["tenant_id"] == "tenant-123"+ attributes = event["attributes"]+ assert attributes["dify.app_id"] == "app-789"+ assert attributes["dify.tenant_id"] == "tenant-123"+ assert attributes["dify.event.id"] == "event-456"+ assert attributes["dify.app.mode"] == "chat"+ assert "dify.app.created_at" in attributes++ exporter.increment_counter.assert_called_once()+ counter = exporter.increment_counter.call_args+ assert counter.args[0] == EnterpriseTelemetryCounter.APP_CREATED+ assert counter.args[1] == 1+ assert counter.args[2]["tenant_id"] == "tenant-123"+ assert counter.args[2]["app_id"] == "app-789"+ assert counter.args[2]["mode"] == "chat"+++def test_handle_app_updated_emits_event_and_counter(+ mock_redis: MagicMock, telemetry_sink: tuple[MagicMock, MagicMock]+) -> None:+ emit, exporter = telemetry_sinkmock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.MODERATION_CHECK,- tenant_id="test-tenant",- event_id="test-event-mod",- payload={},+ envelope = _make_envelope(+ TelemetryCase.APP_UPDATED,+ {"app_id": "app-789"},+ event_id="event-456",+ tenant_id="tenant-123",)- handler = EnterpriseMetricHandler()- with patch.object(handler, "_on_moderation_check") as mock_handler:- handler.handle(envelope)- mock_handler.assert_called_once_with(envelope)-+ EnterpriseMetricHandler().handle(envelope)-def test_dispatch_suggested_question(mock_redis: MagicMock) -> None:- mock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.SUGGESTED_QUESTION,- tenant_id="test-tenant",- event_id="test-event-sq",- payload={},- )+ emit.assert_called_once()+ event = emit.call_args.kwargs+ assert event["event_name"] == EnterpriseTelemetryEvent.APP_UPDATED+ assert event["tenant_id"] == "tenant-123"+ attributes = event["attributes"]+ assert attributes["dify.app_id"] == "app-789"+ assert attributes["dify.tenant_id"] == "tenant-123"+ assert attributes["dify.event.id"] == "event-456"+ assert "dify.app.updated_at" in attributes- handler = EnterpriseMetricHandler()- with patch.object(handler, "_on_suggested_question") as mock_handler:- handler.handle(envelope)- mock_handler.assert_called_once_with(envelope)+ exporter.increment_counter.assert_called_once()+ counter = exporter.increment_counter.call_args+ assert counter.args[0] == EnterpriseTelemetryCounter.APP_UPDATED+ assert counter.args[1] == 1+ assert counter.args[2]["tenant_id"] == "tenant-123"+ assert counter.args[2]["app_id"] == "app-789"-def test_dispatch_dataset_retrieval(mock_redis: MagicMock) -> None:+def test_handle_app_deleted_emits_event_and_counter(+ mock_redis: MagicMock, telemetry_sink: tuple[MagicMock, MagicMock]+) -> None:+ emit, exporter = telemetry_sinkmock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.DATASET_RETRIEVAL,- tenant_id="test-tenant",- event_id="test-event-ds",- payload={},+ envelope = _make_envelope(+ TelemetryCase.APP_DELETED,+ {"app_id": "app-789"},+ event_id="event-456",+ tenant_id="tenant-123",)- handler = EnterpriseMetricHandler()- with patch.object(handler, "_on_dataset_retrieval") as mock_handler:- handler.handle(envelope)- mock_handler.assert_called_once_with(envelope)---def test_dispatch_generate_name(mock_redis: MagicMock) -> None:+ EnterpriseMetricHandler().handle(envelope)++ emit.assert_called_once()+ event = emit.call_args.kwargs+ assert event["event_name"] == EnterpriseTelemetryEvent.APP_DELETED+ assert event["tenant_id"] == "tenant-123"+ attributes = event["attributes"]+ assert attributes["dify.app_id"] == "app-789"+ assert attributes["dify.tenant_id"] == "tenant-123"+ assert attributes["dify.event.id"] == "event-456"+ assert "dify.app.deleted_at" in attributes++ exporter.increment_counter.assert_called_once()+ counter = exporter.increment_counter.call_args+ assert counter.args[0] == EnterpriseTelemetryCounter.APP_DELETED+ assert counter.args[1] == 1+ assert counter.args[2]["tenant_id"] == "tenant-123"+ assert counter.args[2]["app_id"] == "app-789"+++def _feedback_payload() -> dict[str, object]:+ return {+ "message_id": "msg-001",+ "app_id": "app-789",+ "conversation_id": "conv-123",+ "from_end_user_id": "user-456",+ "from_account_id": None,+ "rating": "like",+ "from_source": "api",+ "content": "Great!",+ }+++def test_handle_feedback_created_emits_event_with_content(+ mock_redis: MagicMock, telemetry_sink: tuple[MagicMock, MagicMock]+) -> None:+ emit, exporter = telemetry_sink+ exporter.include_content = Truemock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.GENERATE_NAME,- tenant_id="test-tenant",- event_id="test-event-gn",- payload={},+ envelope = _make_envelope(+ TelemetryCase.FEEDBACK_CREATED,+ _feedback_payload(),+ event_id="event-456",+ tenant_id="tenant-123",)- handler = EnterpriseMetricHandler()- with patch.object(handler, "_on_generate_name") as mock_handler:- handler.handle(envelope)- mock_handler.assert_called_once_with(envelope)---def test_dispatch_prompt_generation(mock_redis: MagicMock) -> None:+ EnterpriseMetricHandler().handle(envelope)++ emit.assert_called_once()+ event = emit.call_args.kwargs+ assert event["event_name"] == EnterpriseTelemetryEvent.FEEDBACK_CREATED+ assert event["tenant_id"] == "tenant-123"+ assert event["user_id"] == "user-456"+ assert event["attributes"]["dify.message.id"] == "msg-001"+ assert event["attributes"]["dify.feedback.content"] == "Great!"+ assert event["attributes"]["dify.feedback.rating"] == "like"+ assert "dify.feedback.created_at" in event["attributes"]++ exporter.increment_counter.assert_called_once()+ counter = exporter.increment_counter.call_args+ assert counter.args[0] == EnterpriseTelemetryCounter.FEEDBACK+ assert counter.args[1] == 1+ assert counter.args[2]["tenant_id"] == "tenant-123"+ assert counter.args[2]["app_id"] == "app-789"+ assert counter.args[2]["rating"] == "like"+++def test_handle_feedback_created_omits_content_when_disabled(+ mock_redis: MagicMock, telemetry_sink: tuple[MagicMock, MagicMock]+) -> None:+ emit, exporter = telemetry_sink+ exporter.include_content = Falsemock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.PROMPT_GENERATION,- tenant_id="test-tenant",- event_id="test-event-pg",- payload={},+ envelope = _make_envelope(+ TelemetryCase.FEEDBACK_CREATED,+ _feedback_payload(),+ event_id="event-456",+ tenant_id="tenant-123",)- handler = EnterpriseMetricHandler()- with patch.object(handler, "_on_prompt_generation") as mock_handler:- handler.handle(envelope)- mock_handler.assert_called_once_with(envelope)---def test_all_known_cases_have_handlers(mock_redis: MagicMock) -> None:- mock_redis.set.return_value = True- handler = EnterpriseMetricHandler()-- for case in TelemetryCase:- envelope = TelemetryEnvelope(- case=case,- tenant_id="test-tenant",- event_id=f"test-{case.value}",- payload={},- )- handler.handle(envelope)+ EnterpriseMetricHandler().handle(envelope)+ emit.assert_called_once()+ assert "dify.feedback.content" not in emit.call_args.kwargs["attributes"]-def test_idempotency_duplicate(sample_envelope: TelemetryEnvelope, mock_redis: MagicMock) -> None:- mock_redis.set.return_value = None+def test_handle_skips_duplicate_event(mock_redis: MagicMock, telemetry_sink: tuple[MagicMock, MagicMock]) -> None:+ emit, exporter = telemetry_sink+ mock_redis.set.side_effect = [True, None]handler = EnterpriseMetricHandler()- with patch.object(handler, "_on_app_created") as mock_handler:- handler.handle(sample_envelope)- mock_handler.assert_not_called()+ envelope = _make_envelope(TelemetryCase.APP_CREATED, {"app_id": "app-123", "mode": "chat"})+ handler.handle(envelope)+ handler.handle(envelope)-def test_idempotency_first_seen(sample_envelope: TelemetryEnvelope, mock_redis: MagicMock) -> None:- mock_redis.set.return_value = True-- handler = EnterpriseMetricHandler()- is_dup = handler._is_duplicate(sample_envelope)-- assert is_dup is False- mock_redis.set.assert_called_once_with(- "telemetry:dedup:test-tenant:test-event-123",- b"1",- nx=True,- ex=3600,- )+ emit.assert_called_once()+ exporter.increment_counter.assert_called_once()-def test_idempotency_redis_failure_fails_open(- sample_envelope: TelemetryEnvelope, mock_redis: MagicMock, caplog: pytest.LogCaptureFixture+def test_handle_processes_event_when_dedup_backend_is_unavailable(+ mock_redis: MagicMock,+ telemetry_sink: tuple[MagicMock, MagicMock],+ caplog: pytest.LogCaptureFixture,) -> None:+ emit, _ = telemetry_sinkmock_redis.set.side_effect = Exception("Redis unavailable")+ envelope = _make_envelope(TelemetryCase.APP_CREATED, {"app_id": "app-123", "mode": "chat"})- handler = EnterpriseMetricHandler()- is_dup = handler._is_duplicate(sample_envelope)+ EnterpriseMetricHandler().handle(envelope)- assert is_dup is False+ emit.assert_called_once()assert "Redis unavailable for deduplication check" in caplog.text-def test_rehydration_uses_payload(sample_envelope: TelemetryEnvelope) -> None:- handler = EnterpriseMetricHandler()- payload = handler._rehydrate(sample_envelope)-- assert payload == {"app_id": "app-123", "name": "Test App"}---def test_rehydration_from_storage() -> None:- """Verify _rehydrate loads payload from object storage via payload_ref."""- stored_data = {"app_id": "app-stored", "mode": "workflow"}- envelope = TelemetryEnvelope(- case=TelemetryCase.APP_CREATED,- tenant_id="test-tenant",- event_id="test-event-fb",- payload={},- metadata={"payload_ref": "telemetry/test-tenant/test-event-fb.json"},- )-- handler = EnterpriseMetricHandler()- with patch("enterprise.telemetry.metric_handler.storage") as mock_storage:- mock_storage.load.return_value = json.dumps(stored_data).encode("utf-8")- payload = handler._rehydrate(envelope)-- assert payload == stored_data- mock_storage.load.assert_called_once_with("telemetry/test-tenant/test-event-fb.json")---def test_rehydration_storage_failure_emits_degraded_event() -> None:- """Verify _rehydrate emits degraded event when storage load fails."""- envelope = TelemetryEnvelope(- case=TelemetryCase.APP_CREATED,- tenant_id="test-tenant",- event_id="test-event-fail",- payload={},- metadata={"payload_ref": "telemetry/test-tenant/test-event-fail.json"},- )-- handler = EnterpriseMetricHandler()- with (- patch("enterprise.telemetry.metric_handler.storage") as mock_storage,- patch("enterprise.telemetry.telemetry_log.emit_metric_only_event") as mock_emit,- ):- mock_storage.load.side_effect = Exception("Storage unavailable")- payload = handler._rehydrate(envelope)-- from enterprise.telemetry.entities import EnterpriseTelemetryEvent-- assert payload == {}- mock_emit.assert_called_once()- call_args = mock_emit.call_args- assert call_args[1]["event_name"] == EnterpriseTelemetryEvent.REHYDRATION_FAILED- assert "dify.telemetry.error" in call_args[1]["attributes"]---def test_rehydration_emits_degraded_event_on_empty_payload() -> None:- """Verify _rehydrate emits degraded event when payload is empty and no ref exists."""- envelope = TelemetryEnvelope(- case=TelemetryCase.APP_CREATED,- tenant_id="test-tenant",- event_id="test-event-empty",- payload={},- )-- handler = EnterpriseMetricHandler()- with patch("enterprise.telemetry.telemetry_log.emit_metric_only_event") as mock_emit:- payload = handler._rehydrate(envelope)-- from enterprise.telemetry.entities import EnterpriseTelemetryEvent-- assert payload == {}- mock_emit.assert_called_once()- call_args = mock_emit.call_args- assert call_args[1]["event_name"] == EnterpriseTelemetryEvent.REHYDRATION_FAILED- assert "dify.telemetry.error" in call_args[1]["attributes"]---def test_on_app_created_emits_correct_event(mock_redis: MagicMock) -> None:- mock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.APP_CREATED,- tenant_id="tenant-123",- event_id="event-456",- payload={"app_id": "app-789", "mode": "chat"},- )-- handler = EnterpriseMetricHandler()- with (- patch("extensions.ext_enterprise_telemetry.get_enterprise_exporter") as mock_get_exporter,- patch("enterprise.telemetry.telemetry_log.emit_metric_only_event") as mock_emit,- ):- mock_exporter = MagicMock()- mock_get_exporter.return_value = mock_exporter-- handler._on_app_created(envelope)-- from enterprise.telemetry.entities import EnterpriseTelemetryEvent-- mock_emit.assert_called_once()- call_args = mock_emit.call_args- assert call_args[1]["event_name"] == EnterpriseTelemetryEvent.APP_CREATED- assert call_args[1]["tenant_id"] == "tenant-123"- attrs = call_args[1]["attributes"]- assert attrs["dify.app_id"] == "app-789"- assert attrs["dify.tenant_id"] == "tenant-123"- assert attrs["dify.event.id"] == "event-456"- assert attrs["dify.app.mode"] == "chat"- assert "dify.app.created_at" in attrs-- from enterprise.telemetry.entities import EnterpriseTelemetryCounter-- mock_exporter.increment_counter.assert_called_once()- counter_call = mock_exporter.increment_counter.call_args- assert counter_call[0][0] == EnterpriseTelemetryCounter.APP_CREATED- assert counter_call[0][1] == 1- assert counter_call[0][2]["tenant_id"] == "tenant-123"- assert counter_call[0][2]["app_id"] == "app-789"- assert counter_call[0][2]["mode"] == "chat"---def test_on_app_updated_emits_correct_event(mock_redis: MagicMock) -> None:+def test_handle_rehydrates_payload_from_object_storage(+ mock_redis: MagicMock, telemetry_sink: tuple[MagicMock, MagicMock]+) -> None:+ emit, _ = telemetry_sinkmock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.APP_UPDATED,- tenant_id="tenant-123",- event_id="event-456",- payload={"app_id": "app-789"},+ envelope = _make_envelope(+ TelemetryCase.APP_CREATED,+ metadata={"payload_ref": "telemetry/test-tenant/test-event.json"},)- handler = EnterpriseMetricHandler()- with (- patch("extensions.ext_enterprise_telemetry.get_enterprise_exporter") as mock_get_exporter,- patch("enterprise.telemetry.telemetry_log.emit_metric_only_event") as mock_emit,- ):- mock_exporter = MagicMock()- mock_get_exporter.return_value = mock_exporter-- handler._on_app_updated(envelope)-- from enterprise.telemetry.entities import EnterpriseTelemetryEvent-- mock_emit.assert_called_once()- call_args = mock_emit.call_args- assert call_args[1]["event_name"] == EnterpriseTelemetryEvent.APP_UPDATED- assert call_args[1]["tenant_id"] == "tenant-123"- attrs = call_args[1]["attributes"]- assert attrs["dify.app_id"] == "app-789"- assert attrs["dify.tenant_id"] == "tenant-123"- assert attrs["dify.event.id"] == "event-456"- assert "dify.app.updated_at" in attrs-- from enterprise.telemetry.entities import EnterpriseTelemetryCounter+ with patch("enterprise.telemetry.metric_handler.storage") as mock_storage:+ mock_storage.load.return_value = json.dumps({"app_id": "app-stored", "mode": "workflow"}).encode("utf-8")+ EnterpriseMetricHandler().handle(envelope)- mock_exporter.increment_counter.assert_called_once()- counter_call = mock_exporter.increment_counter.call_args- assert counter_call[0][0] == EnterpriseTelemetryCounter.APP_UPDATED- assert counter_call[0][1] == 1- assert counter_call[0][2]["tenant_id"] == "tenant-123"- assert counter_call[0][2]["app_id"] == "app-789"+ attributes = emit.call_args.kwargs["attributes"]+ assert attributes["dify.app_id"] == "app-stored"+ assert attributes["dify.app.mode"] == "workflow"-def test_on_app_deleted_emits_correct_event(mock_redis: MagicMock) -> None:+def test_handle_emits_degraded_event_when_storage_fails(+ mock_redis: MagicMock, telemetry_sink: tuple[MagicMock, MagicMock]+) -> None:+ emit, _ = telemetry_sinkmock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.APP_DELETED,- tenant_id="tenant-123",- event_id="event-456",- payload={"app_id": "app-789"},+ envelope = _make_envelope(+ TelemetryCase.APP_CREATED,+ metadata={"payload_ref": "telemetry/test-tenant/test-event.json"},)- handler = EnterpriseMetricHandler()- with (- patch("extensions.ext_enterprise_telemetry.get_enterprise_exporter") as mock_get_exporter,- patch("enterprise.telemetry.telemetry_log.emit_metric_only_event") as mock_emit,- ):- mock_exporter = MagicMock()- mock_get_exporter.return_value = mock_exporter-- handler._on_app_deleted(envelope)-- from enterprise.telemetry.entities import EnterpriseTelemetryEvent-- mock_emit.assert_called_once()- call_args = mock_emit.call_args- assert call_args[1]["event_name"] == EnterpriseTelemetryEvent.APP_DELETED- assert call_args[1]["tenant_id"] == "tenant-123"- attrs = call_args[1]["attributes"]- assert attrs["dify.app_id"] == "app-789"- assert attrs["dify.tenant_id"] == "tenant-123"- assert attrs["dify.event.id"] == "event-456"- assert "dify.app.deleted_at" in attrs-- from enterprise.telemetry.entities import EnterpriseTelemetryCounter+ with patch("enterprise.telemetry.metric_handler.storage") as mock_storage:+ mock_storage.load.side_effect = Exception("Storage unavailable")+ EnterpriseMetricHandler().handle(envelope)- mock_exporter.increment_counter.assert_called_once()- counter_call = mock_exporter.increment_counter.call_args- assert counter_call[0][0] == EnterpriseTelemetryCounter.APP_DELETED- assert counter_call[0][1] == 1- assert counter_call[0][2]["tenant_id"] == "tenant-123"- assert counter_call[0][2]["app_id"] == "app-789"+ emit.assert_called_once()+ event = emit.call_args.kwargs+ assert event["event_name"] == EnterpriseTelemetryEvent.REHYDRATION_FAILED+ assert "dify.telemetry.error" in event["attributes"]-def test_on_feedback_created_emits_correct_event(mock_redis: MagicMock) -> None:+def test_handle_emits_degraded_event_when_payload_is_empty(+ mock_redis: MagicMock, telemetry_sink: tuple[MagicMock, MagicMock]+) -> None:+ emit, _ = telemetry_sinkmock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.FEEDBACK_CREATED,- tenant_id="tenant-123",- event_id="event-456",- payload={- "message_id": "msg-001",- "app_id": "app-789",- "conversation_id": "conv-123",- "from_end_user_id": "user-456",- "from_account_id": None,- "rating": "like",- "from_source": "api",- "content": "Great!",- },- )-- handler = EnterpriseMetricHandler()- with (- patch("extensions.ext_enterprise_telemetry.get_enterprise_exporter") as mock_get_exporter,- patch("enterprise.telemetry.telemetry_log.emit_metric_only_event") as mock_emit,- ):- mock_exporter = MagicMock()- mock_exporter.include_content = True- mock_get_exporter.return_value = mock_exporter-- handler._on_feedback_created(envelope)+ envelope = _make_envelope(TelemetryCase.APP_CREATED)- mock_emit.assert_called_once()- call_args = mock_emit.call_args- assert call_args[1]["event_name"] == "dify.feedback.created"- assert call_args[1]["attributes"]["dify.message.id"] == "msg-001"- assert call_args[1]["attributes"]["dify.feedback.content"] == "Great!"- assert "dify.feedback.created_at" in call_args[1]["attributes"]- assert call_args[1]["tenant_id"] == "tenant-123"- assert call_args[1]["user_id"] == "user-456"+ EnterpriseMetricHandler().handle(envelope)- mock_exporter.increment_counter.assert_called_once()- counter_args = mock_exporter.increment_counter.call_args- assert counter_args[0][2]["app_id"] == "app-789"- assert counter_args[0][2]["rating"] == "like"+ emit.assert_called_once()+ event = emit.call_args.kwargs+ assert event["event_name"] == EnterpriseTelemetryEvent.REHYDRATION_FAILED+ assert "dify.telemetry.error" in event["attributes"]-def test_on_feedback_created_without_content(mock_redis: MagicMock) -> None:[email protected]("case", list(TelemetryCase))+def test_handle_accepts_every_known_case(+ case: TelemetryCase, mock_redis: MagicMock, telemetry_sink: tuple[MagicMock, MagicMock]+) -> None:+ emit, _ = telemetry_sinkmock_redis.set.return_value = True- envelope = TelemetryEnvelope(- case=TelemetryCase.FEEDBACK_CREATED,- tenant_id="tenant-123",- event_id="event-456",- payload={- "message_id": "msg-001",- "app_id": "app-789",- "conversation_id": "conv-123",- "from_end_user_id": "user-456",- "from_account_id": None,- "rating": "like",- "from_source": "api",- "content": "Great!",- },- )-- handler = EnterpriseMetricHandler()- with (- patch("extensions.ext_enterprise_telemetry.get_enterprise_exporter") as mock_get_exporter,- patch("enterprise.telemetry.telemetry_log.emit_metric_only_event") as mock_emit,- ):- mock_exporter = MagicMock()- mock_exporter.include_content = False- mock_get_exporter.return_value = mock_exporter- handler._on_feedback_created(envelope)+ EnterpriseMetricHandler().handle(_make_envelope(case, {"app_id": "app-1", "mode": "chat"}))- mock_emit.assert_called_once()- call_args = mock_emit.call_args- assert "dify.feedback.content" not in call_args[1]["attributes"]+ assert emit.call_count <= 1diff --git a/api/tests/unit_tests/tasks/test_generate_summary_index_task.py b/api/tests/unit_tests/tasks/test_generate_summary_index_task.pyindex 51450b09aa2..1b6cde38675 100644--- a/api/tests/unit_tests/tasks/test_generate_summary_index_task.py+++ b/api/tests/unit_tests/tasks/test_generate_summary_index_task.py@@ -6,6 +6,8 @@ for each document segment and can occupy all worker slots for hours, blockingdocument indexing tasks."""+from typing import Protocol, runtime_checkable+import pytestfrom tasks.generate_summary_index_task import generate_summary_index_task@@ -15,10 +17,46 @@ SUMMARY_QUEUE = "dataset_summary"INDEXING_QUEUE = "dataset"-def _task_queue(task: object) -> str | None:- # Celery's @shared_task(queue=...) stores the routing key on the task instance- # at runtime, but type stubs don't declare it; use getattr to stay type-clean.- return getattr(task, "queue", None)+@runtime_checkable+class _Queue(Protocol):+ name: str+++class _Router(Protocol):+ def route(+ self,+ options: dict[str, object],+ name: str,+ args: tuple[object, ...],+ kwargs: dict[str, object],+ ) -> dict[str, object]: ...+++class _Amqp(Protocol):+ router: _Router+++class _CeleryApp(Protocol):+ amqp: _Amqp+++@runtime_checkable+class _RoutableTask(Protocol):+ name: str+ app: _CeleryApp++ def _get_exec_options(self) -> dict[str, object]: ...+++def _routed_queue(task: object) -> str | None:+ assert isinstance(task, _RoutableTask), "Expected a Celery task with routing metadata"+ options = task._get_exec_options()+ routed = task.app.amqp.router.route(options, task.name, args=(), kwargs={})+ queue = routed.get("queue")+ if queue is None:+ return None+ assert isinstance(queue, _Queue), "Expected a routed queue with a name"+ return queue.name@pytest.mark.parametrize(@@ -28,13 +66,13 @@ def _task_queue(task: object) -> str | None:(regenerate_summary_index_task, "regenerate_summary_index_task"),],)-def test_summary_task_uses_dedicated_queue(task: object, task_name: str) -> None:- """Summary tasks must use the dataset_summary queue, not the shared dataset queue.+def test_summary_task_routes_to_dedicated_queue(task: object, task_name: str) -> None:+ """Summary tasks must route to the dataset_summary queue, not the shared dataset queue.Summary generation is LLM-heavy and will block document indexing if placedon the shared queue."""- assert _task_queue(task) == SUMMARY_QUEUE, (- f"{task_name} must run on '{SUMMARY_QUEUE}' queue (not '{INDEXING_QUEUE}'). "+ assert _routed_queue(task) == SUMMARY_QUEUE, (+ f"{task_name} must route to '{SUMMARY_QUEUE}' queue (not '{INDEXING_QUEUE}'). ""Summary generation is LLM-heavy and will block document indexing if placed on the shared queue.")diff --git a/api/tests/unit_tests/tasks/test_mail_inner_task.py b/api/tests/unit_tests/tasks/test_mail_inner_task.pyindex d1d3714c3ca..e0e7c5904ae 100644--- a/api/tests/unit_tests/tasks/test_mail_inner_task.py+++ b/api/tests/unit_tests/tasks/test_mail_inner_task.py@@ -373,17 +373,10 @@ class TestMailTaskRetryLogic:send_email_register_mail_task(language="en-US", to="[email protected]", code="123456")# Assert- mock_service.send_email.assert_called_once_with(- email_type=EmailType.EMAIL_REGISTER,- language_code="en-US",- to="[email protected]",- template_context={"to": "[email protected]", "code": "123456"},- )- # Verify logging calls+ mock_service.send_email.assert_called_once()log_messages = [record.getMessage() for record in caplog.records]- assert len(log_messages) == 2 # Start and success logs- assert "Start email register mail to [email protected]" in log_messages[0]- assert "Send email register mail to [email protected] succeeded" in log_messages[1]+ assert any("Start email register mail to [email protected]" in message for message in log_messages)+ assert any("Send email register mail to [email protected] succeeded" in message for message in log_messages)@patch("tasks.mail_register_task.get_email_i18n_service")@patch("tasks.mail_register_task.mail")@@ -403,8 +396,8 @@ class TestMailTaskRetryLogic:# Assertassert "Send email register mail to [email protected] failed" in caplog.text- assert len(caplog.records) == 1- assert caplog.records[0].exc_info is not None+ failure_records = [record for record in caplog.records if record.exc_info is not None]+ assert failure_records@patch("tasks.mail_reset_password_task.get_email_i18n_service")@patch("tasks.mail_reset_password_task.mail")@@ -419,12 +412,11 @@ class TestMailTaskRetryLogic:send_reset_password_mail_task(language="zh-Hans", to="[email protected]", code="RESET123")# Assert- mock_service.send_email.assert_called_once_with(- email_type=EmailType.RESET_PASSWORD,- language_code="zh-Hans",- to="[email protected]",- template_context={"to": "[email protected]", "code": "RESET123"},- )+ mock_service.send_email.assert_called_once()+ sent = mock_service.send_email.call_args.kwargs+ assert sent["to"] == "[email protected]"+ assert sent["language_code"] == "zh-Hans"+ assert sent["template_context"] == {"to": "[email protected]", "code": "RESET123"}@patch("tasks.mail_reset_password_task.get_email_i18n_service")@patch("tasks.mail_reset_password_task.mail")@@ -445,10 +437,9 @@ class TestMailTaskRetryLogic:# Assertmock_service.send_email.assert_called_once()- call_args = mock_service.send_email.call_args- assert call_args[1]["email_type"] == EmailType.RESET_PASSWORD_WHEN_ACCOUNT_NOT_EXIST- assert call_args[1]["to"] == "[email protected]"- assert "sign_up_url" in call_args[1]["template_context"]+ sent = mock_service.send_email.call_args.kwargs+ assert sent["to"] == "[email protected]"+ assert sent["template_context"]["sign_up_url"] == "https://console.example.com/signup"@patch("tasks.mail_reset_password_task.get_email_i18n_service")@patch("tasks.mail_reset_password_task.mail")@@ -468,8 +459,9 @@ class TestMailTaskRetryLogic:# Assertmock_service.send_email.assert_called_once()- call_args = mock_service.send_email.call_args- assert call_args[1]["email_type"] == EmailType.RESET_PASSWORD_WHEN_ACCOUNT_NOT_EXIST_NO_REGISTER+ sent = mock_service.send_email.call_args.kwargs+ assert sent["to"] == "[email protected]"+ assert "template_context" not in sentclass TestMailTaskInternationalization:@@ -557,7 +549,6 @@ class TestInnerEmailTask:send_inner_email_task(to=to_list, subject=subject, body=body, substitutions=substitutions)# Assert- mock_render.assert_called_once_with(body, substitutions)mock_service.send_raw_email.assert_called_once_with(to=to_list, subject=subject, html_content="<p>Hello John, your code is 123456</p>")@@ -897,10 +888,8 @@ class TestPerformanceAndTiming:send_email_register_mail_task(language="en-US", to="[email protected]", code="123456")# Assert- assert mock_time.perf_counter.call_count == 2- # Verify latency is logged- assert len(caplog.records) == 2- assert "latency: 0.5" in caplog.records[1].getMessage()+ latency_messages = [record.getMessage() for record in caplog.records if "latency:" in record.getMessage()]+ assert any("latency: 0.5" in message for message in latency_messages)class TestEdgeCasesAndErrorHandling: