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: move webhook service coverage to unit tests (#38945)
Asuka Minato7edd05100a99
diff --git a/api/tests/test_containers_integration_tests/services/test_webhook_service.py b/api/tests/test_containers_integration_tests/services/test_webhook_service.pyindex b4022e44f56..3aca53f78c8 100644--- a/api/tests/test_containers_integration_tests/services/test_webhook_service.py+++ b/api/tests/test_containers_integration_tests/services/test_webhook_service.py@@ -1,577 +1,171 @@+"""Database integration tests for webhook trigger and workflow lookup."""+import json-from io import BytesIO-from unittest.mock import MagicMock, patch+from typing import TypedDictimport pytestfrom faker import Fakerfrom flask import Flaskfrom sqlalchemy.orm import Session-from werkzeug.datastructures import FileStorage+from enums.deployment_edition import DeploymentEdition+from models.account import Account, Tenantfrom models.enums import AppTriggerStatus, AppTriggerTypefrom models.model import Appfrom models.trigger import AppTrigger, WorkflowWebhookTriggerfrom models.workflow import Workflowfrom services.account_service import AccountService, TenantService+from services.feature_service import SystemFeatureModelfrom services.trigger.webhook_service import WebhookServicefrom tests.test_containers_integration_tests.helpers import generate_valid_password-class TestWebhookService:- """Integration tests for WebhookService using testcontainers."""-- @pytest.fixture- def mock_external_dependencies(self):- """Mock external service dependencies."""- with (- patch("services.trigger.webhook_service.AsyncWorkflowService", autospec=True) as mock_async_service,- patch("services.trigger.webhook_service.ToolFileManager", autospec=True) as mock_tool_file_manager,- patch("services.trigger.webhook_service.file_factory", autospec=True) as mock_file_factory,- patch("services.account_service.FeatureService", autospec=True) as mock_feature_service,- ):- # Mock ToolFileManager- mock_tool_file_instance = mock_tool_file_manager.return_value # Mock file creation- mock_tool_file = MagicMock()- mock_tool_file.id = "test_file_id"- mock_tool_file_instance.create_file_by_raw.return_value = mock_tool_file-- # Mock file factory- mock_file_obj = MagicMock()- mock_file_factory.build_from_mapping.return_value = mock_file_obj-- # Mock feature service- mock_feature_service.get_system_features.return_value.is_allow_register = True- mock_feature_service.is_workspace_creation_allowed.return_value = True-- yield {- "async_service": mock_async_service,- "tool_file_manager": mock_tool_file_manager,- "file_factory": mock_file_factory,- "tool_file": mock_tool_file,- "file_obj": mock_file_obj,- "feature_service": mock_feature_service,- }-- @pytest.fixture- def test_data(self, db_session_with_containers: Session, mock_external_dependencies):- """Create test data for webhook service tests."""- fake = Faker()-- # Create account and tenant- account = AccountService.create_account(- email=fake.email(),- name=fake.name(),- interface_language="en-US",- password=generate_valid_password(fake),- session=db_session_with_containers,- )- TenantService.create_owner_tenant_if_not_exist(account, name=fake.company(), session=db_session_with_containers)- tenant = account.current_tenant- assert tenant is not None-- # Create app- app = App(- tenant_id=tenant.id,- name=fake.company(),- description=fake.text(),- mode="workflow",- icon="",- icon_background="",- enable_site=True,- enable_api=True,- )- db_session_with_containers.add(app)- db_session_with_containers.flush()-- # Create workflow- workflow_data = {- "nodes": [- {- "id": "webhook_node",- "type": "webhook",- "data": {- "type": "trigger-webhook",- "title": "Test Webhook",- "method": "post",- "content_type": "application/json",- "headers": [- {"name": "Authorization", "required": True},- {"name": "Content-Type", "required": False},- ],- "params": [{"name": "version", "required": True}, {"name": "format", "required": False}],- "body": [- {"name": "message", "type": "string", "required": True},- {"name": "count", "type": "number", "required": False},- {"name": "upload", "type": "file", "required": False},- ],- "status_code": 200,- "response_body": '{"status": "success"}',- "timeout": 30,- },- }- ],- "edges": [],- }-- workflow = Workflow(- tenant_id=tenant.id,- app_id=app.id,- type="workflow",- graph=json.dumps(workflow_data),- features=json.dumps({}),- created_by=account.id,- environment_variables=[],- conversation_variables=[],- version="1.0",- )- db_session_with_containers.add(workflow)- db_session_with_containers.flush()-- app.workflow_id = workflow.id- db_session_with_containers.flush()-- # Create webhook trigger- webhook_id = fake.uuid4()[:16]- webhook_trigger = WorkflowWebhookTrigger(- app_id=app.id,- node_id="webhook_node",- tenant_id=tenant.id,- webhook_id=str(webhook_id),- created_by=account.id,- )- db_session_with_containers.add(webhook_trigger)- db_session_with_containers.flush()-- # Create app trigger (required for non-debug mode)- app_trigger = AppTrigger(- tenant_id=tenant.id,- app_id=app.id,- node_id="webhook_node",- trigger_type=AppTriggerType.TRIGGER_WEBHOOK,- provider_name="webhook",- title="Test Webhook",- status=AppTriggerStatus.ENABLED,- )- db_session_with_containers.add(app_trigger)- db_session_with_containers.commit()-- return {- "tenant": tenant,- "account": account,- "app": app,- "workflow": workflow,- "webhook_trigger": webhook_trigger,- "webhook_id": webhook_id,- "app_trigger": app_trigger,- }-- def test_get_webhook_trigger_and_workflow_success(self, test_data, flask_app_with_containers: Flask):- """Test successful retrieval of webhook trigger and workflow."""- webhook_id = test_data["webhook_id"]-- with flask_app_with_containers.app_context():- webhook_trigger, workflow, node_config = WebhookService.get_webhook_trigger_and_workflow(webhook_id)-- assert webhook_trigger is not None- assert webhook_trigger.webhook_id == webhook_id- assert workflow is not None- assert workflow.app_id == test_data["app"].id- assert node_config is not None- assert node_config["id"] == "webhook_node"- assert node_config["data"].title == "Test Webhook"-- def test_get_webhook_trigger_and_workflow_not_found(self, flask_app_with_containers: Flask):- """Test webhook trigger not found scenario."""- with flask_app_with_containers.app_context():- with pytest.raises(ValueError, match="Webhook not found"):- WebhookService.get_webhook_trigger_and_workflow("nonexistent_webhook")-- def test_extract_webhook_data_json(self):- """Test webhook data extraction from JSON request."""- app = Flask(__name__)-- with app.test_request_context(- "/webhook",- method="POST",- headers={"Content-Type": "application/json", "Authorization": "Bearer token"},- query_string="version=1&format=json",- json={"message": "hello", "count": 42},- ):- webhook_trigger = MagicMock()- webhook_data = WebhookService.extract_webhook_data(webhook_trigger)-- assert webhook_data["method"] == "POST"- assert webhook_data["headers"]["Authorization"] == "Bearer token"- assert webhook_data["query_params"]["version"] == "1"- assert webhook_data["query_params"]["format"] == "json"- assert webhook_data["body"]["message"] == "hello"- assert webhook_data["body"]["count"] == 42- assert webhook_data["files"] == {}-- def test_extract_webhook_data_form_urlencoded(self):- """Test webhook data extraction from form URL encoded request."""- app = Flask(__name__)-- with app.test_request_context(- "/webhook",- method="POST",- headers={"Content-Type": "application/x-www-form-urlencoded"},- data={"username": "test", "password": "secret"},- ):- webhook_trigger = MagicMock()- webhook_data = WebhookService.extract_webhook_data(webhook_trigger)-- assert webhook_data["method"] == "POST"- assert webhook_data["body"]["username"] == "test"- assert webhook_data["body"]["password"] == "secret"-- def test_extract_webhook_data_multipart_with_files(self, mock_external_dependencies):- """Test webhook data extraction from multipart form with files."""- app = Flask(__name__)-- # Create a mock file- file_content = b"test file content"- file_storage = FileStorage(stream=BytesIO(file_content), filename="test.txt", content_type="text/plain")-- with app.test_request_context(- "/webhook",- method="POST",- headers={"Content-Type": "multipart/form-data"},- data={"message": "test", "file": file_storage},- ):- webhook_trigger = MagicMock()- webhook_trigger.tenant_id = "test_tenant"-- webhook_data = WebhookService.extract_webhook_data(webhook_trigger)-- assert webhook_data["method"] == "POST"- assert webhook_data["body"]["message"] == "test"- assert "file" in webhook_data["files"]-- # Verify file processing was called- mock_external_dependencies["tool_file_manager"].assert_called_once()- mock_external_dependencies["file_factory"].build_from_mapping.assert_called_once()-- def test_extract_webhook_data_raw_text(self):- """Test webhook data extraction from raw text request."""- app = Flask(__name__)-- with app.test_request_context(- "/webhook", method="POST", headers={"Content-Type": "text/plain"}, data="raw text content"- ):- webhook_trigger = MagicMock()- webhook_data = WebhookService.extract_webhook_data(webhook_trigger)-- assert webhook_data["method"] == "POST"- assert webhook_data["body"]["raw"] == "raw text content"-- def test_extract_and_validate_webhook_request_success(self):- """Test successful webhook request validation and type conversion."""- app = Flask(__name__)-- with app.test_request_context(- "/webhook",- method="POST",- headers={"Content-Type": "application/json", "Authorization": "Bearer token"},- query_string="version=1",- json={"message": "hello"},- ):- webhook_trigger = MagicMock()- node_config = {+class WebhookIntegrationData(TypedDict):+ tenant: Tenant+ account: Account+ app: App+ workflow: Workflow+ webhook_trigger: WorkflowWebhookTrigger+ webhook_id: str+ app_trigger: AppTrigger+++def test_data(+ db_session_with_containers: Session,+ monkeypatch: pytest.MonkeyPatch,+) -> WebhookIntegrationData:+ """Persist the webhook graph with account and workspace creation enabled."""++ fake = Faker()+ system_features = SystemFeatureModel(+ deployment_edition=DeploymentEdition.COMMUNITY,+ is_allow_register=True,+ )+ monkeypatch.setattr(+ "services.account_service.FeatureService.get_system_features",+ lambda: system_features,+ )+ monkeypatch.setattr(+ "services.account_service.FeatureService.is_workspace_creation_allowed",+ lambda: True,+ )+ account = AccountService.create_account(+ email=fake.email(),+ name=fake.name(),+ interface_language="en-US",+ password=generate_valid_password(fake),+ session=db_session_with_containers,+ )+ TenantService.create_owner_tenant_if_not_exist(account, name=fake.company(), session=db_session_with_containers)+ tenant = account.current_tenant+ assert tenant is not None+ app = App(+ tenant_id=tenant.id,+ name=fake.company(),+ description=fake.text(),+ mode="workflow",+ icon="",+ icon_background="",+ enable_site=True,+ enable_api=True,+ )+ db_session_with_containers.add(app)+ db_session_with_containers.flush()+ workflow_data = {+ "nodes": [+ {+ "id": "webhook_node",+ "type": "webhook","data": {+ "type": "trigger-webhook",+ "title": "Test Webhook","method": "post","content_type": "application/json","headers": [{"name": "Authorization", "required": True},{"name": "Content-Type", "required": False},],- "params": [{"name": "version", "required": True}],- "body": [{"name": "message", "type": "string", "required": True}],- }- }-- result = WebhookService.extract_and_validate_webhook_data(webhook_trigger, node_config)-- assert result["headers"]["Authorization"] == "Bearer token"- assert result["query_params"]["version"] == "1"- assert result["body"]["message"] == "hello"-- def test_extract_and_validate_webhook_request_method_mismatch(self):- """Test webhook validation with HTTP method mismatch."""- app = Flask(__name__)-- with app.test_request_context(- "/webhook",- method="GET",- headers={"Content-Type": "application/json"},- ):- webhook_trigger = MagicMock()- node_config = {"data": {"method": "post", "content_type": "application/json"}}-- with pytest.raises(ValueError, match="HTTP method mismatch"):- WebhookService.extract_and_validate_webhook_data(webhook_trigger, node_config)-- def test_extract_and_validate_webhook_request_missing_required_header(self):- """Test webhook validation with missing required header."""- app = Flask(__name__)-- with app.test_request_context(- "/webhook",- method="POST",- headers={"Content-Type": "application/json"},- ):- webhook_trigger = MagicMock()- node_config = {- "data": {- "method": "post",- "content_type": "application/json",- "headers": [{"name": "Authorization", "required": True}],- }- }-- with pytest.raises(ValueError, match="Required header missing: Authorization"):- WebhookService.extract_and_validate_webhook_data(webhook_trigger, node_config)-- def test_extract_and_validate_webhook_request_case_insensitive_headers(self):- """Test webhook validation with case-insensitive header matching."""- app = Flask(__name__)-- with app.test_request_context(- "/webhook",- method="POST",- headers={"Content-Type": "application/json", "authorization": "Bearer token"},- json={"message": "hello"},- ):- webhook_trigger = MagicMock()- node_config = {- "data": {- "method": "post",- "content_type": "application/json",- "headers": [{"name": "Authorization", "required": True}],- "body": [{"name": "message", "type": "string", "required": True}],- }- }-- result = WebhookService.extract_and_validate_webhook_data(webhook_trigger, node_config)-- assert result["headers"].get("Authorization") == "Bearer token"-- def test_extract_and_validate_webhook_request_missing_required_param(self):- """Test webhook validation with missing required query parameter."""- app = Flask(__name__)-- with app.test_request_context(- "/webhook",- method="POST",- headers={"Content-Type": "application/json"},- json={"message": "hello"},- ):- webhook_trigger = MagicMock()- node_config = {- "data": {- "method": "post",- "content_type": "application/json",- "params": [{"name": "version", "required": True}],- "body": [{"name": "message", "type": "string", "required": True}],- }- }-- with pytest.raises(ValueError, match="Required parameter missing: version"):- WebhookService.extract_and_validate_webhook_data(webhook_trigger, node_config)-- def test_extract_and_validate_webhook_request_missing_required_body_param(self):- """Test webhook validation with missing required body parameter."""- app = Flask(__name__)-- with app.test_request_context(- "/webhook",- method="POST",- headers={"Content-Type": "application/json"},- json={},- ):- webhook_trigger = MagicMock()- node_config = {- "data": {- "method": "post",- "content_type": "application/json",- "body": [{"name": "message", "type": "string", "required": True}],- }- }-- with pytest.raises(ValueError, match="Required body parameter missing: message"):- WebhookService.extract_and_validate_webhook_data(webhook_trigger, node_config)-- def test_extract_and_validate_webhook_request_missing_required_file(self):- """Test webhook validation when required file is missing from multipart request."""- app = Flask(__name__)-- with app.test_request_context(- "/webhook",- method="POST",- data={"note": "test"},- content_type="multipart/form-data",- ):- webhook_trigger = MagicMock()- webhook_trigger.tenant_id = "tenant"- webhook_trigger.created_by = "user"- node_config = {- "data": {- "method": "post",- "content_type": "multipart/form-data",- "body": [{"name": "file", "type": "file", "required": True}],- }+ "params": [+ {"name": "version", "required": True},+ {"name": "format", "required": False},+ ],+ "body": [+ {"name": "message", "type": "string", "required": True},+ {"name": "count", "type": "number", "required": False},+ {"name": "upload", "type": "file", "required": False},+ ],+ "status_code": 200,+ "response_body": '{"status": "success"}',+ "timeout": 30,+ },}-- result = WebhookService.extract_and_validate_webhook_data(webhook_trigger, node_config)-- assert result["files"] == {}-- def test_trigger_workflow_execution_success(- self, test_data, mock_external_dependencies, flask_app_with_containers: Flask- ):- """Test successful workflow execution trigger."""- webhook_data = {- "method": "POST",- "headers": {"Authorization": "Bearer token"},- "query_params": {"version": "1"},- "body": {"message": "hello"},- "files": {},- }-+ ],+ "edges": [],+ }+ workflow = Workflow(+ tenant_id=tenant.id,+ app_id=app.id,+ type="workflow",+ graph=json.dumps(workflow_data),+ features=json.dumps({}),+ created_by=account.id,+ environment_variables=[],+ conversation_variables=[],+ version="1.0",+ )+ db_session_with_containers.add(workflow)+ db_session_with_containers.flush()+ app.workflow_id = workflow.id+ webhook_id = fake.uuid4()[:16]+ webhook_trigger = WorkflowWebhookTrigger(+ app_id=app.id,+ node_id="webhook_node",+ tenant_id=tenant.id,+ webhook_id=webhook_id,+ created_by=account.id,+ )+ db_session_with_containers.add(webhook_trigger)+ db_session_with_containers.flush()+ app_trigger = AppTrigger(+ tenant_id=tenant.id,+ app_id=app.id,+ node_id="webhook_node",+ trigger_type=AppTriggerType.TRIGGER_WEBHOOK,+ provider_name="webhook",+ title="Test Webhook",+ status=AppTriggerStatus.ENABLED,+ )+ db_session_with_containers.add(app_trigger)+ db_session_with_containers.commit()+ return {+ "tenant": tenant,+ "account": account,+ "app": app,+ "workflow": workflow,+ "webhook_trigger": webhook_trigger,+ "webhook_id": webhook_id,+ "app_trigger": app_trigger,+ }+++class TestWebhookServiceDatabaseLookup:+ def test_get_webhook_trigger_and_workflow_success(+ self,+ test_data: WebhookIntegrationData,+ flask_app_with_containers: Flask,+ ) -> None:with flask_app_with_containers.app_context():- # Mock tenant owner lookup to return the test account- with patch("services.trigger.webhook_service.select", autospec=True) as mock_select:- mock_query = MagicMock()- mock_select.return_value.join.return_value.where.return_value = mock_query-- # Mock the session to return our test account- with patch("services.trigger.webhook_service.Session", autospec=True) as mock_session:- mock_session_instance = MagicMock()- mock_session.return_value.__enter__.return_value = mock_session_instance- mock_session_instance.scalar.return_value = test_data["account"]+ webhook_trigger, workflow, node_config = WebhookService.get_webhook_trigger_and_workflow(+ test_data["webhook_id"]+ )- # Should not raise any exceptions- WebhookService.trigger_workflow_execution(- test_data["webhook_trigger"], webhook_data, test_data["workflow"]- )-- # Verify AsyncWorkflowService was called- mock_external_dependencies["async_service"].trigger_workflow_async.assert_called_once()-- def test_trigger_workflow_execution_end_user_service_failure(- self, test_data, mock_external_dependencies, flask_app_with_containers: Flask- ):- """Test workflow execution trigger when EndUserService fails."""- webhook_data = {"method": "POST", "headers": {}, "query_params": {}, "body": {}, "files": {}}+ assert webhook_trigger.webhook_id == test_data["webhook_id"]+ assert workflow.app_id == test_data["app"].id+ assert node_config["id"] == "webhook_node"+ assert node_config["data"].title == "Test Webhook"+ def test_get_webhook_trigger_and_workflow_not_found(self, flask_app_with_containers: Flask) -> None:with flask_app_with_containers.app_context():- # Mock EndUserService to raise an exception- with patch(- "services.trigger.webhook_service.EndUserService.get_or_create_end_user_by_type", autospec=True- ) as mock_end_user:- mock_end_user.side_effect = ValueError("Failed to create end user")-- with pytest.raises(ValueError, match="Failed to create end user"):- WebhookService.trigger_workflow_execution(- test_data["webhook_trigger"], webhook_data, test_data["workflow"]- )-- def test_generate_webhook_response_default(self):- """Test webhook response generation with default values."""- node_config = {"data": {}}-- response_data, status_code = WebhookService.generate_webhook_response(node_config)-- assert status_code == 200- assert response_data["status"] == "success"- assert "Webhook processed successfully" in response_data["message"]-- def test_generate_webhook_response_custom_json(self):- """Test webhook response generation with custom JSON response."""- node_config = {"data": {"status_code": 201, "response_body": '{"result": "created", "id": 123}'}}-- response_data, status_code = WebhookService.generate_webhook_response(node_config)-- assert status_code == 201- assert response_data["result"] == "created"- assert response_data["id"] == 123-- def test_generate_webhook_response_custom_text(self):- """Test webhook response generation with custom text response."""- node_config = {"data": {"status_code": 202, "response_body": "Request accepted for processing"}}-- response_data, status_code = WebhookService.generate_webhook_response(node_config)-- assert status_code == 202- assert response_data["message"] == "Request accepted for processing"-- def test_generate_webhook_response_invalid_json(self):- """Test webhook response generation with invalid JSON response."""- node_config = {"data": {"status_code": 400, "response_body": '{"invalid": json}'}}-- response_data, status_code = WebhookService.generate_webhook_response(node_config)-- assert status_code == 400- assert response_data["message"] == '{"invalid": json}'-- def test_process_file_uploads_success(self, mock_external_dependencies):- """Test successful file upload processing."""- # Create mock files- files = {- "file1": MagicMock(filename="test1.txt", content_type="text/plain"),- "file2": MagicMock(filename="test2.jpg", content_type="image/jpeg"),- }-- # Mock file reads- files["file1"].read.return_value = b"content1"- files["file2"].read.return_value = b"content2"-- webhook_trigger = MagicMock()- webhook_trigger.tenant_id = "test_tenant"-- result = WebhookService._process_file_uploads(files, webhook_trigger)-- assert len(result) == 2- assert "file1" in result- assert "file2" in result-- # Verify file processing was called for each file- assert mock_external_dependencies["tool_file_manager"].call_count == 2- assert mock_external_dependencies["file_factory"].build_from_mapping.call_count == 2-- def test_process_file_uploads_with_errors(self, mock_external_dependencies):- """Test file upload processing with errors."""- # Create mock files, one will fail- files = {- "good_file": MagicMock(filename="test.txt", content_type="text/plain"),- "bad_file": MagicMock(filename="test.bad", content_type="text/plain"),- }-- files["good_file"].stream.read.return_value = b"content"- files["bad_file"].stream.read.side_effect = Exception("Read error")-- webhook_trigger = MagicMock()- webhook_trigger.tenant_id = "test_tenant"-- result = WebhookService._process_file_uploads(files, webhook_trigger)-- # Should process the good file and skip the bad one- assert len(result) == 1- assert "good_file" in result- assert "bad_file" not in result-- def test_process_file_uploads_empty_filename(self, mock_external_dependencies):- """Test file upload processing with empty filename."""- files = {- "no_filename": MagicMock(filename="", content_type="text/plain"),- "none_filename": MagicMock(filename=None, content_type="text/plain"),- }-- webhook_trigger = MagicMock()- webhook_trigger.tenant_id = "test_tenant"-- result = WebhookService._process_file_uploads(files, webhook_trigger)-- # Should skip files without filenames- assert len(result) == 0- mock_external_dependencies["tool_file_manager"].assert_not_called()+ with pytest.raises(ValueError, match="Webhook not found"):+ WebhookService.get_webhook_trigger_and_workflow("nonexistent_webhook")diff --git a/api/tests/unit_tests/services/test_webhook_service.py b/api/tests/unit_tests/services/test_webhook_service.pyindex 338771c5a28..c4505f0b77a 100644--- a/api/tests/unit_tests/services/test_webhook_service.py+++ b/api/tests/unit_tests/services/test_webhook_service.py@@ -15,7 +15,7 @@ from services.trigger.webhook_service import WebhookServiceclass TestWebhookServiceUnit:- """Webhook business-logic tests with real sessions where the service owns their lifecycle."""+ """Webhook business-logic tests with isolated sessions where the service owns their lifecycle."""def test_trigger_workflow_execution_propagates_quota_error_without_error_log(self,@@ -65,6 +65,66 @@ class TestWebhookServiceUnit:"Tenant tenant-123 quota exceeded for feature workflow, skipping webhook trigger webhook-123")+ def test_trigger_workflow_execution_success(+ self,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_engine: Engine,+ ) -> None:+ monkeypatch.setattr(webhook_service_module, "db", SimpleNamespace(engine=sqlite_engine))+ webhook_trigger = MagicMock(+ webhook_id="webhook-123",+ tenant_id="tenant-123",+ app_id="app-123",+ node_id="node-123",+ )+ workflow = MagicMock(id="workflow-123")+ end_user = MagicMock(id="end-user-123")+ quota_charge = MagicMock()+ webhook_data = {+ "method": "POST",+ "headers": {"Authorization": "Bearer token"},+ "query_params": {"version": "1"},+ "body": {"message": "hello"},+ "files": {},+ }++ with (+ patch.object(+ webhook_service_module.EndUserService,+ "get_or_create_end_user_by_type",+ return_value=end_user,+ ),+ patch.object(webhook_service_module.QuotaService, "reserve", return_value=quota_charge),+ patch.object(+ webhook_service_module.AsyncWorkflowService,+ "trigger_workflow_async",+ ) as mock_trigger,+ ):+ WebhookService.trigger_workflow_execution(webhook_trigger, webhook_data, workflow)++ call_session = mock_trigger.call_args.kwargs["session"]+ assert call_session.get_bind() is sqlite_engine+ quota_charge.commit.assert_called_once_with()+ quota_charge.refund.assert_not_called()++ def test_trigger_workflow_execution_end_user_service_failure(self) -> None:+ webhook_trigger = MagicMock(+ webhook_id="webhook-123",+ tenant_id="tenant-123",+ app_id="app-123",+ node_id="node-123",+ )+ workflow = MagicMock(id="workflow-123")+ webhook_data = {"method": "POST", "headers": {}, "query_params": {}, "body": {}, "files": {}}++ with patch.object(+ webhook_service_module.EndUserService,+ "get_or_create_end_user_by_type",+ side_effect=ValueError("Failed to create end user"),+ ):+ with pytest.raises(ValueError, match="Failed to create end user"):+ WebhookService.trigger_workflow_execution(webhook_trigger, webhook_data, workflow)+def test_extract_webhook_data_json(self):"""Test webhook data extraction from JSON request."""app = Flask(__name__)@@ -590,6 +650,104 @@ class TestWebhookServiceUnit:with pytest.raises(ValueError, match="HTTP method mismatch"):WebhookService.extract_and_validate_webhook_data(webhook_trigger, node_config)+ def test_extract_and_validate_webhook_request_missing_required_header(self) -> None:+ app = Flask(__name__)+ with app.test_request_context(+ "/webhook",+ method="POST",+ headers={"Content-Type": "application/json"},+ ):+ node_config = {+ "data": {+ "method": "post",+ "content_type": "application/json",+ "headers": [{"name": "Authorization", "required": True}],+ }+ }++ with pytest.raises(ValueError, match="Required header missing: Authorization"):+ WebhookService.extract_and_validate_webhook_data(MagicMock(), node_config)++ def test_extract_and_validate_webhook_request_case_insensitive_headers(self) -> None:+ app = Flask(__name__)+ with app.test_request_context(+ "/webhook",+ method="POST",+ headers={"Content-Type": "application/json", "authorization": "Bearer token"},+ json={"message": "hello"},+ ):+ node_config = {+ "data": {+ "method": "post",+ "content_type": "application/json",+ "headers": [{"name": "Authorization", "required": True}],+ "body": [{"name": "message", "type": "string", "required": True}],+ }+ }++ result = WebhookService.extract_and_validate_webhook_data(MagicMock(), node_config)++ assert result["headers"].get("Authorization") == "Bearer token"++ def test_extract_and_validate_webhook_request_missing_required_param(self) -> None:+ app = Flask(__name__)+ with app.test_request_context(+ "/webhook",+ method="POST",+ headers={"Content-Type": "application/json"},+ json={"message": "hello"},+ ):+ node_config = {+ "data": {+ "method": "post",+ "content_type": "application/json",+ "params": [{"name": "version", "required": True}],+ "body": [{"name": "message", "type": "string", "required": True}],+ }+ }++ with pytest.raises(ValueError, match="Required parameter missing: version"):+ WebhookService.extract_and_validate_webhook_data(MagicMock(), node_config)++ def test_extract_and_validate_webhook_request_missing_required_body_param(self) -> None:+ app = Flask(__name__)+ with app.test_request_context(+ "/webhook",+ method="POST",+ headers={"Content-Type": "application/json"},+ json={},+ ):+ node_config = {+ "data": {+ "method": "post",+ "content_type": "application/json",+ "body": [{"name": "message", "type": "string", "required": True}],+ }+ }++ with pytest.raises(ValueError, match="Required body parameter missing: message"):+ WebhookService.extract_and_validate_webhook_data(MagicMock(), node_config)++ def test_extract_and_validate_webhook_request_missing_required_file(self) -> None:+ app = Flask(__name__)+ with app.test_request_context(+ "/webhook",+ method="POST",+ data={"note": "test"},+ content_type="multipart/form-data",+ ):+ node_config = {+ "data": {+ "method": "post",+ "content_type": "multipart/form-data",+ "body": [{"name": "file", "type": "file", "required": True}],+ }+ }++ result = WebhookService.extract_and_validate_webhook_data(MagicMock(), node_config)++ assert result["files"] == {}+def test_debug_mode_parameter_handling(self):"""Test that the debug mode parameter is properly handled in _prepare_webhook_execution."""from controllers.trigger.webhook import _prepare_webhook_execution