π OpenHands: AI-Driven Development
[Jira]: separate signature verification from conversation orchestration (#12478)
Rohit Malhotra3bc56740b94d
diff --git a/enterprise/integrations/jira/jira_manager.py b/enterprise/integrations/jira/jira_manager.pyindex c1795498ca..2bc5228862 100644--- a/enterprise/integrations/jira/jira_manager.py+++ b/enterprise/integrations/jira/jira_manager.py@@ -1,10 +1,7 @@-import hashlib-import hmac-from typing import Dict, Optional, Tuple+from typing import Tuplefrom urllib.parse import urlparseimport httpx-from fastapi import Requestfrom integrations.jira.jira_types import JiraViewInterfacefrom integrations.jira.jira_view import (JiraFactory,@@ -87,53 +84,20 @@ class JiraManager(Manager):)return repos- async def validate_request(- self, request: Request- ) -> Tuple[bool, Optional[str], Optional[Dict]]:- """Verify Jira webhook signature."""- signature_header = request.headers.get('x-hub-signature')- signature = signature_header.split('=')[1] if signature_header else None- body = await request.body()- payload = await request.json()- workspace_name = ''-+ def get_workspace_name_from_payload(self, payload: dict) -> str | None:+ """Extract workspace name from Jira webhook payload."""if payload.get('webhookEvent') == 'comment_created':selfUrl = payload.get('comment', {}).get('author', {}).get('self')elif payload.get('webhookEvent') == 'jira:issue_updated':selfUrl = payload.get('user', {}).get('self')else:- workspace_name = ''-- parsedUrl = urlparse(selfUrl)- if parsedUrl.hostname:- workspace_name = parsedUrl.hostname-- if not workspace_name:- logger.warning('[Jira] No workspace name found in webhook payload')- return False, None, None-- if not signature:- logger.warning('[Jira] No signature found in webhook headers')- return False, None, None-- workspace = await self.integration_store.get_workspace_by_name(workspace_name)-- if not workspace:- logger.warning('[Jira] Could not identify workspace for webhook')- return False, None, None-- if workspace.status != 'active':- logger.warning(f'[Jira] Workspace {workspace.id} is not active')- return False, None, None-- webhook_secret = self.token_manager.decrypt_text(workspace.webhook_secret)- digest = hmac.new(webhook_secret.encode(), body, hashlib.sha256).hexdigest()+ return None- if hmac.compare_digest(signature, digest):- logger.info('[Jira] Webhook signature verified successfully')- return True, signature, payload+ if not selfUrl:+ return None- return False, None, None+ parsedUrl = urlparse(selfUrl)+ return parsedUrl.hostname or Nonedef parse_webhook(self, message: Message) -> JobContext | None:payload = message.message.get('payload', {})diff --git a/enterprise/server/routes/integration/jira.py b/enterprise/server/routes/integration/jira.pyindex 2bc031e276..9ce281c100 100644--- a/enterprise/server/routes/integration/jira.py+++ b/enterprise/server/routes/integration/jira.py@@ -1,3 +1,5 @@+import hashlib+import hmacimport jsonimport osimport re@@ -5,7 +7,7 @@ import uuidfrom urllib.parse import urlparseimport requests-from fastapi import APIRouter, BackgroundTasks, HTTPException, Request, status+from fastapi import APIRouter, BackgroundTasks, Header, HTTPException, Request, statusfrom fastapi.responses import JSONResponse, RedirectResponsefrom integrations.jira.jira_manager import JiraManagerfrom integrations.models import Message, SourceType@@ -14,6 +16,7 @@ from pydantic import BaseModel, Field, field_validatorfrom server.auth.constants import JIRA_CLIENT_ID, JIRA_CLIENT_SECRETfrom server.auth.saas_user_auth import SaasUserAuthfrom server.auth.token_manager import TokenManager+from storage.jira_workspace import JiraWorkspacefrom storage.redis import create_redis_clientfrom openhands.core.logger import openhands_logger as logger@@ -122,6 +125,63 @@ jira_manager = JiraManager(token_manager)redis_client = create_redis_client()+async def verify_jira_signature(body: bytes, signature: str, payload: dict):+ """+ Verify Jira webhook signature.++ Args:+ body: Raw request body bytes+ signature: Signature from x-hub-signature header (format: "sha256=<hash>")+ payload: Parsed JSON payload from webhook++ Raises:+ HTTPException: 403 if signature verification fails or workspace is invalid++ Returns:+ None (raises exception on failure)+ """++ if not signature:+ raise HTTPException(+ status_code=403, detail='x-hub-signature header is missing!'+ )++ workspace_name = jira_manager.get_workspace_name_from_payload(payload)+ if workspace_name is None:+ logger.warning('[Jira] No workspace name found in webhook payload')+ raise HTTPException(+ status_code=403, detail='Workspace name not found in payload'+ )++ workspace: (+ JiraWorkspace | None+ ) = await jira_manager.integration_store.get_workspace_by_name(workspace_name)++ if workspace is None:+ logger.warning(f'[Jira] Could not identify workspace {workspace_name}')+ raise HTTPException(status_code=403, detail='Unidentified workspace')++ if workspace.status != 'active':+ logger.warning(+ '[Jira] Workspace is inactive',+ extra={+ 'jira_workspace_id': workspace.id,+ 'parsed_workspace_name': workspace.name,+ 'status': workspace.status,+ },+ )++ raise HTTPException(status_code=403, detail='Workspace is inactive')++ webhook_secret = token_manager.decrypt_text(workspace.webhook_secret)+ expected_signature = hmac.new(+ webhook_secret.encode(), body, hashlib.sha256+ ).hexdigest()++ if not hmac.compare_digest(expected_signature, signature):+ raise HTTPException(status_code=403, detail="Request signatures didn't match!")++async def _handle_workspace_link_creation(user_id: str, jira_user_id: str, target_workspace: str):@@ -216,6 +276,7 @@ async def _validate_workspace_update_permissions(user_id: str, target_workspace:async def jira_events(request: Request,background_tasks: BackgroundTasks,+ x_hub_signature: str = Header(None),):"""Handle Jira webhook events."""# Check if Jira webhooks are enabled@@ -227,13 +288,15 @@ async def jira_events()try:- signature_valid, signature, payload = await jira_manager.validate_request(- request- )+ parts = x_hub_signature.split('=', 1)+ if not (len(parts) == 2 and parts[1]):+ raise HTTPException(status_code=403, detail='Malformed x-hub-signature!')++ signature = parts[1]+ body = await request.body()+ payload = await request.json()- if not signature_valid:- logger.warning('[Jira] Invalid webhook signature')- raise HTTPException(status_code=403, detail='Invalid webhook signature!')+ await verify_jira_signature(body, signature, payload)# Check for duplicate requests using Rediskey = f'jira:{signature}'diff --git a/enterprise/storage/jira_integration_store.py b/enterprise/storage/jira_integration_store.pyindex 73d7da57f1..db353732bb 100644--- a/enterprise/storage/jira_integration_store.py+++ b/enterprise/storage/jira_integration_store.py@@ -118,9 +118,7 @@ class JiraIntegrationStore:.first())- async def get_workspace_by_name(- self, workspace_name: str- ) -> Optional[JiraWorkspace]:+ async def get_workspace_by_name(self, workspace_name: str) -> JiraWorkspace | None:"""Retrieve workspace by name."""with session_maker() as session:return (diff --git a/enterprise/tests/unit/integrations/jira/test_jira_manager.py b/enterprise/tests/unit/integrations/jira/test_jira_manager.pyindex 8787eadff1..5d2474452e 100644--- a/enterprise/tests/unit/integrations/jira/test_jira_manager.py+++ b/enterprise/tests/unit/integrations/jira/test_jira_manager.py@@ -2,13 +2,9 @@Unit tests for JiraManager."""-import hashlib-import hmac-import jsonfrom unittest.mock import AsyncMock, MagicMock, patchimport pytest-from fastapi import Requestfrom integrations.jira.jira_manager import JiraManagerfrom integrations.jira.jira_types import JiraViewInterfacefrom integrations.jira.jira_view import (@@ -124,124 +120,83 @@ class TestGetRepositories:mock_client.get_repositories.assert_called_once()-class TestValidateRequest:- """Test webhook request validation."""+class TestGetWorkspaceNameFromPayload:+ """Test workspace name extraction from webhook payload."""- @pytest.mark.asyncio- async def test_validate_request_success(+ def test_get_workspace_name_from_comment_created_payload(self,jira_manager,- mock_token_manager,- sample_jira_workspace,sample_comment_webhook_payload,):- """Test successful webhook validation."""- # Setup mocks- mock_token_manager.decrypt_text.return_value = 'test_secret'- jira_manager.integration_store.get_workspace_by_name.return_value = (- sample_jira_workspace+ """Test extracting workspace name from comment_created webhook."""+ workspace_name = jira_manager.get_workspace_name_from_payload(+ sample_comment_webhook_payload)- # Create mock request- body = json.dumps(sample_comment_webhook_payload).encode()- signature = hmac.new('test_secret'.encode(), body, hashlib.sha256).hexdigest()-- mock_request = MagicMock(spec=Request)- mock_request.headers = {'x-hub-signature': f'sha256={signature}'}- mock_request.body = AsyncMock(return_value=body)- mock_request.json = AsyncMock(return_value=sample_comment_webhook_payload)+ assert workspace_name == 'test.atlassian.net'- is_valid, returned_signature, payload = await jira_manager.validate_request(- mock_request- )-- assert is_valid is True- assert returned_signature == signature- assert payload == sample_comment_webhook_payload-- @pytest.mark.asyncio- async def test_validate_request_missing_signature(- self, jira_manager, sample_comment_webhook_payload+ def test_get_workspace_name_from_issue_updated_payload(+ self,+ jira_manager,+ sample_issue_update_webhook_payload,):- """Test webhook validation with missing signature."""- mock_request = MagicMock(spec=Request)- mock_request.headers = {}- mock_request.body = AsyncMock(return_value=b'{}')- mock_request.json = AsyncMock(return_value=sample_comment_webhook_payload)-- is_valid, signature, payload = await jira_manager.validate_request(mock_request)+ """Test extracting workspace name from jira:issue_updated webhook."""+ workspace_name = jira_manager.get_workspace_name_from_payload(+ sample_issue_update_webhook_payload+ )- assert is_valid is False- assert signature is None- assert payload is None+ assert workspace_name == 'jira.company.com'- @pytest.mark.asyncio- async def test_validate_request_workspace_not_found(- self, jira_manager, sample_comment_webhook_payload+ def test_get_workspace_name_from_unknown_event(+ self,+ jira_manager,):- """Test webhook validation when workspace is not found."""- jira_manager.integration_store.get_workspace_by_name.return_value = None-- mock_request = MagicMock(spec=Request)- mock_request.headers = {'x-hub-signature': 'sha256=test_signature'}- mock_request.body = AsyncMock(return_value=b'{}')- mock_request.json = AsyncMock(return_value=sample_comment_webhook_payload)+ """Test extracting workspace name from unknown webhook event."""+ payload = {+ 'webhookEvent': 'unknown_event',+ 'some_data': {'self': 'https://example.atlassian.net/rest/api/2/something'},+ }- is_valid, signature, payload = await jira_manager.validate_request(mock_request)+ workspace_name = jira_manager.get_workspace_name_from_payload(payload)- assert is_valid is False- assert signature is None- assert payload is None+ assert workspace_name is None- @pytest.mark.asyncio- async def test_validate_request_workspace_inactive(+ def test_get_workspace_name_with_missing_author_self(self,jira_manager,- mock_token_manager,- sample_jira_workspace,- sample_comment_webhook_payload,):- """Test webhook validation when workspace is inactive."""- sample_jira_workspace.status = 'inactive'- jira_manager.integration_store.get_workspace_by_name.return_value = (- sample_jira_workspace- )-- mock_request = MagicMock(spec=Request)- mock_request.headers = {'x-hub-signature': 'sha256=test_signature'}- mock_request.body = AsyncMock(return_value=b'{}')- mock_request.json = AsyncMock(return_value=sample_comment_webhook_payload)+ """Test extracting workspace name when author self URL is missing."""+ payload = {+ 'webhookEvent': 'comment_created',+ 'comment': {+ 'body': 'Test comment',+ 'author': {+ 'emailAddress': '[email protected]',+ 'displayName': 'Test User',+ },+ },+ }- is_valid, signature, payload = await jira_manager.validate_request(mock_request)+ workspace_name = jira_manager.get_workspace_name_from_payload(payload)- assert is_valid is False- assert signature is None- assert payload is None+ assert workspace_name is None- @pytest.mark.asyncio- async def test_validate_request_invalid_signature(+ def test_get_workspace_name_with_missing_user_self(self,jira_manager,- mock_token_manager,- sample_jira_workspace,- sample_comment_webhook_payload,):- """Test webhook validation with invalid signature."""- mock_token_manager.decrypt_text.return_value = 'test_secret'- jira_manager.integration_store.get_workspace_by_name.return_value = (- sample_jira_workspace- )-- mock_request = MagicMock(spec=Request)- mock_request.headers = {'x-hub-signature': 'sha256=invalid_signature'}- mock_request.body = AsyncMock(return_value=b'{}')- mock_request.json = AsyncMock(return_value=sample_comment_webhook_payload)+ """Test extracting workspace name when user self URL is missing."""+ payload = {+ 'webhookEvent': 'jira:issue_updated',+ 'user': {+ 'emailAddress': '[email protected]',+ 'displayName': 'Test User',+ },+ }- is_valid, signature, payload = await jira_manager.validate_request(mock_request)+ workspace_name = jira_manager.get_workspace_name_from_payload(payload)- assert is_valid is False- assert signature is None- assert payload is None+ assert workspace_name is Noneclass TestParseWebhook:diff --git a/enterprise/tests/unit/server/routes/test_jira_integration_routes.py b/enterprise/tests/unit/server/routes/test_jira_integration_routes.pyindex ab7f078efb..211957cc36 100644--- a/enterprise/tests/unit/server/routes/test_jira_integration_routes.py+++ b/enterprise/tests/unit/server/routes/test_jira_integration_routes.py@@ -1,3 +1,5 @@+import hashlib+import hmacimport jsonfrom datetime import datetimefrom unittest.mock import AsyncMock, MagicMock, patch@@ -19,6 +21,7 @@ from server.routes.integration.jira import (jira_events,unlink_workspace,validate_workspace_integration,+ verify_jira_signature,)@@ -61,25 +64,35 @@ def mock_user_auth():@pytest.mark.asyncio-@patch('server.routes.integration.jira.jira_manager', new_callable=AsyncMock)+@patch('server.routes.integration.jira.verify_jira_signature', new_callable=AsyncMock)@patch('server.routes.integration.jira.redis_client', new_callable=MagicMock)-async def test_jira_events_invalid_signature(mock_redis, mock_manager, mock_request):+async def test_jira_events_invalid_signature(mock_redis, mock_verify, mock_request):with patch('server.routes.integration.jira.JIRA_WEBHOOKS_ENABLED', True):- mock_manager.validate_request.return_value = (False, None, None)+ mock_request.body = AsyncMock(return_value=b'{}')+ mock_request.json = AsyncMock(return_value={})+ mock_verify.side_effect = HTTPException(+ status_code=403, detail="Request signatures didn't match!"+ )with pytest.raises(HTTPException) as exc_info:- await jira_events(mock_request, MagicMock())+ await jira_events(+ mock_request, MagicMock(), x_hub_signature='sha256=invalid'+ )assert exc_info.value.status_code == 403- assert exc_info.value.detail == 'Invalid webhook signature!'+ assert exc_info.value.detail == "Request signatures didn't match!"@pytest.mark.asyncio-@patch('server.routes.integration.jira.jira_manager', new_callable=AsyncMock)+@patch('server.routes.integration.jira.verify_jira_signature', new_callable=AsyncMock)@patch('server.routes.integration.jira.redis_client')-async def test_jira_events_duplicate_request(mock_redis, mock_manager, mock_request):+async def test_jira_events_duplicate_request(mock_redis, mock_verify, mock_request):with patch('server.routes.integration.jira.JIRA_WEBHOOKS_ENABLED', True):- mock_manager.validate_request.return_value = (True, 'sig123', 'payload')+ mock_request.body = AsyncMock(return_value=b'{}')+ mock_request.json = AsyncMock(return_value={})+ mock_verify.return_value = Nonemock_redis.exists.return_value = True- response = await jira_events(mock_request, MagicMock())+ response = await jira_events(+ mock_request, MagicMock(), x_hub_signature='sha256=sig123'+ )assert response.status_code == 200body = json.loads(response.body)assert body['success'] is True@@ -348,18 +361,21 @@ class TestJiraLinkCreateValidation:# Test jira_events error scenarios@pytest.mark.asyncio@patch('server.routes.integration.jira.jira_manager', new_callable=AsyncMock)+@patch('server.routes.integration.jira.verify_jira_signature', new_callable=AsyncMock)@patch('server.routes.integration.jira.redis_client', new_callable=MagicMock)-async def test_jira_events_processing_success(mock_redis, mock_manager, mock_request):+async def test_jira_events_processing_success(+ mock_redis, mock_verify, mock_manager, mock_request+):with patch('server.routes.integration.jira.JIRA_WEBHOOKS_ENABLED', True):- mock_manager.validate_request.return_value = (- True,- 'sig123',- {'test': 'payload'},- )+ mock_request.body = AsyncMock(return_value=b'{"test": "payload"}')+ mock_request.json = AsyncMock(return_value={'test': 'payload'})+ mock_verify.return_value = Nonemock_redis.exists.return_value = Falsebackground_tasks = MagicMock()- response = await jira_events(mock_request, background_tasks)+ response = await jira_events(+ mock_request, background_tasks, x_hub_signature='sha256=sig123'+ )assert response.status_code == 200body = json.loads(response.body)@@ -369,19 +385,241 @@ async def test_jira_events_processing_success(mock_redis, mock_manager, mock_req@pytest.mark.asyncio-@patch('server.routes.integration.jira.jira_manager', new_callable=AsyncMock)+@patch('server.routes.integration.jira.verify_jira_signature', new_callable=AsyncMock)@patch('server.routes.integration.jira.redis_client', new_callable=MagicMock)-async def test_jira_events_general_exception(mock_redis, mock_manager, mock_request):+async def test_jira_events_general_exception(mock_redis, mock_verify, mock_request):with patch('server.routes.integration.jira.JIRA_WEBHOOKS_ENABLED', True):- mock_manager.validate_request.side_effect = Exception('Unexpected error')+ mock_request.body = AsyncMock(side_effect=Exception('Unexpected error'))+ mock_request.json = AsyncMock(return_value={})- response = await jira_events(mock_request, MagicMock())+ response = await jira_events(+ mock_request, MagicMock(), x_hub_signature='sha256=sig123'+ )assert response.status_code == 500body = json.loads(response.body)assert 'Internal server error processing webhook' in body['error']+# Test verify_jira_signature+class TestVerifyJiraSignature:+ """Test Jira webhook signature verification."""++ @pytest.fixture+ def sample_payload(self):+ """Sample webhook payload with comment_created event."""+ return {+ 'webhookEvent': 'comment_created',+ 'comment': {+ 'body': 'Test comment @openhands',+ 'author': {+ 'emailAddress': '[email protected]',+ 'displayName': 'Test User',+ 'self': 'https://test.atlassian.net/rest/api/2/user?accountId=123',+ },+ },+ 'issue': {+ 'id': '12345',+ 'key': 'TEST-123',+ 'self': 'https://test.atlassian.net/rest/api/2/issue/12345',+ },+ }++ @pytest.fixture+ def mock_workspace(self):+ """Create a mock workspace."""+ workspace = MagicMock()+ workspace.id = 1+ workspace.name = 'test.atlassian.net'+ workspace.status = 'active'+ workspace.webhook_secret = 'encrypted_secret'+ return workspace++ @pytest.mark.asyncio+ @pytest.mark.parametrize(+ 'signature,expected_detail',+ [+ (None, 'x-hub-signature header is missing!'),+ ('', 'x-hub-signature header is missing!'),+ ],+ ids=['signature_none', 'signature_empty'],+ )+ async def test_missing_signature(self, signature, expected_detail, sample_payload):+ """Test that missing or empty signature raises HTTPException."""+ body = json.dumps(sample_payload).encode()++ with pytest.raises(HTTPException) as exc_info:+ await verify_jira_signature(body, signature, sample_payload)++ assert exc_info.value.status_code == 403+ assert exc_info.value.detail == expected_detail++ @pytest.mark.asyncio+ @pytest.mark.parametrize(+ 'payload',+ [+ {'webhookEvent': 'unknown_event'},+ {'webhookEvent': 'comment_created', 'comment': {}},+ {'webhookEvent': 'comment_created', 'comment': {'author': {}}},+ {'webhookEvent': 'jira:issue_updated', 'user': {}},+ {},+ ],+ ids=[+ 'unknown_event',+ 'missing_author',+ 'missing_self_url',+ 'issue_updated_missing_self',+ 'empty_payload',+ ],+ )+ @patch('server.routes.integration.jira.jira_manager')+ async def test_workspace_name_not_found(self, mock_manager, payload):+ """Test that missing workspace name in payload raises HTTPException."""+ mock_manager.get_workspace_name_from_payload.return_value = None+ body = json.dumps(payload).encode()++ with pytest.raises(HTTPException) as exc_info:+ await verify_jira_signature(body, 'valid_signature', payload)++ assert exc_info.value.status_code == 403+ assert exc_info.value.detail == 'Workspace name not found in payload'++ @pytest.mark.asyncio+ @patch('server.routes.integration.jira.jira_manager')+ async def test_workspace_not_found_in_database(self, mock_manager, sample_payload):+ """Test that workspace not found in database raises HTTPException."""+ mock_manager.get_workspace_name_from_payload.return_value = 'test.atlassian.net'+ mock_manager.integration_store.get_workspace_by_name = AsyncMock(+ return_value=None+ )+ body = json.dumps(sample_payload).encode()++ with pytest.raises(HTTPException) as exc_info:+ await verify_jira_signature(body, 'valid_signature', sample_payload)++ assert exc_info.value.status_code == 403+ assert exc_info.value.detail == 'Unidentified workspace'++ @pytest.mark.asyncio+ @pytest.mark.parametrize(+ 'workspace_status',+ ['inactive', 'disabled', 'pending'],+ ids=['inactive', 'disabled', 'pending'],+ )+ @patch('server.routes.integration.jira.jira_manager')+ async def test_workspace_not_active(+ self, mock_manager, workspace_status, sample_payload, mock_workspace+ ):+ """Test that inactive workspace raises HTTPException."""+ mock_workspace.status = workspace_status+ mock_manager.get_workspace_name_from_payload.return_value = 'test.atlassian.net'+ mock_manager.integration_store.get_workspace_by_name = AsyncMock(+ return_value=mock_workspace+ )+ body = json.dumps(sample_payload).encode()++ with pytest.raises(HTTPException) as exc_info:+ await verify_jira_signature(body, 'valid_signature', sample_payload)++ assert exc_info.value.status_code == 403+ assert exc_info.value.detail == 'Workspace is inactive'++ @pytest.mark.asyncio+ @patch('server.routes.integration.jira.token_manager')+ @patch('server.routes.integration.jira.jira_manager')+ async def test_signature_mismatch(+ self, mock_manager, mock_token_mgr, sample_payload, mock_workspace+ ):+ """Test that signature mismatch raises HTTPException."""+ mock_manager.get_workspace_name_from_payload.return_value = 'test.atlassian.net'+ mock_manager.integration_store.get_workspace_by_name = AsyncMock(+ return_value=mock_workspace+ )+ mock_token_mgr.decrypt_text.return_value = 'webhook_secret'+ body = json.dumps(sample_payload).encode()++ with pytest.raises(HTTPException) as exc_info:+ await verify_jira_signature(body, 'invalid_signature', sample_payload)++ assert exc_info.value.status_code == 403+ assert exc_info.value.detail == "Request signatures didn't match!"++ @pytest.mark.asyncio+ @patch('server.routes.integration.jira.token_manager')+ @patch('server.routes.integration.jira.jira_manager')+ async def test_valid_signature(+ self, mock_manager, mock_token_mgr, sample_payload, mock_workspace+ ):+ """Test that valid signature passes verification."""+ webhook_secret = 'webhook_secret'+ mock_manager.get_workspace_name_from_payload.return_value = 'test.atlassian.net'+ mock_manager.integration_store.get_workspace_by_name = AsyncMock(+ return_value=mock_workspace+ )+ mock_token_mgr.decrypt_text.return_value = webhook_secret++ body = json.dumps(sample_payload).encode()+ valid_signature = hmac.new(+ webhook_secret.encode(), body, hashlib.sha256+ ).hexdigest()++ # Should not raise any exception+ result = await verify_jira_signature(body, valid_signature, sample_payload)+ assert result is None++ @pytest.mark.asyncio+ @pytest.mark.parametrize(+ 'event_type,payload_key,author_key',+ [+ ('comment_created', 'comment', 'author'),+ ('jira:issue_updated', 'user', None),+ ],+ ids=['comment_created', 'issue_updated'],+ )+ @patch('server.routes.integration.jira.token_manager')+ @patch('server.routes.integration.jira.jira_manager')+ async def test_valid_signature_different_events(+ self,+ mock_manager,+ mock_token_mgr,+ event_type,+ payload_key,+ author_key,+ mock_workspace,+ ):+ """Test valid signature verification for different webhook events."""+ webhook_secret = 'webhook_secret'+ mock_manager.get_workspace_name_from_payload.return_value = 'test.atlassian.net'+ mock_manager.integration_store.get_workspace_by_name = AsyncMock(+ return_value=mock_workspace+ )+ mock_token_mgr.decrypt_text.return_value = webhook_secret++ if event_type == 'comment_created':+ payload = {+ 'webhookEvent': event_type,+ 'comment': {+ 'body': 'Test',+ 'author': {+ 'self': 'https://test.atlassian.net/rest/api/2/user?id=1'+ },+ },+ }+ else:+ payload = {+ 'webhookEvent': event_type,+ 'user': {'self': 'https://test.atlassian.net/rest/api/2/user?id=1'},+ }++ body = json.dumps(payload).encode()+ valid_signature = hmac.new(+ webhook_secret.encode(), body, hashlib.sha256+ ).hexdigest()++ result = await verify_jira_signature(body, valid_signature, payload)+ assert result is None++# Test create_jira_workspace error scenarios@pytest.mark.asyncio@patch('server.routes.integration.jira.get_user_auth')