Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

test(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.py
index 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.util
import json
import os
+import re
import subprocess
import sys
from pathlib import Path
import pytest
from jsonschema import Draft202012Validator
+from jsonschema.exceptions import SchemaError
from 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 = None
api.__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(generated
assert 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_spec
for 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_spec
for 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(ge
assert 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.parent
diff --git a/api/tests/unit_tests/enterprise/telemetry/test_metric_handler.py b/api/tests/unit_tests/enterprise/telemetry/test_metric_handler.py
index 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, patch
import pytest
from enterprise.telemetry.contracts import TelemetryCase, TelemetryEnvelope
+from enterprise.telemetry.entities import EnterpriseTelemetryCounter, EnterpriseTelemetryEvent
from 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_sink
mock_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_sink
mock_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_sink
mock_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 = True
mock_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 = False
mock_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_sink
mock_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_sink
mock_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_sink
mock_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_sink
mock_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_sink
mock_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 <= 1
diff --git a/api/tests/unit_tests/tasks/test_generate_summary_index_task.py b/api/tests/unit_tests/tasks/test_generate_summary_index_task.py
index 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, blocking
document indexing tasks.
"""
+from typing import Protocol, runtime_checkable
+
import pytest
from 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 placed
on 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.py
index 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",
- 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:
# Assert
assert "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",
- 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:
# Assert
mock_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:
# Assert
mock_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 sent
class 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: