🙌 OpenHands: AI-Driven Development
feat: allow manual reinstallation for gitlab resolver (#12184)
Hiep Le6f86e589c81c
diff --git a/enterprise/integrations/gitlab/gitlab_service.py b/enterprise/integrations/gitlab/gitlab_service.pyindex 6bf3db9835..0f7f9560b2 100644--- a/enterprise/integrations/gitlab/gitlab_service.py+++ b/enterprise/integrations/gitlab/gitlab_service.py@@ -80,22 +80,52 @@ class SaaSGitLabService(GitLabService):logger.warning('external_auth_token and user_id not set!')return gitlab_token- async def get_owned_groups(self) -> list[dict]:+ async def get_owned_groups(self, min_access_level: int = 40) -> list[dict]:"""- Get all groups for which the current user is the owner.+ Get all top-level groups where the current user has admin access.++ This method supports pagination and fetches all groups where the user has+ at least the specified access level.++ Args:+ min_access_level: Minimum access level required (default: 40 for Maintainer or Owner)+ - 40: Maintainer or Owner+ - 50: Owner onlyReturns:- list[dict]: A list of groups owned by the current user.+ list[dict]: A list of groups where user has the specified access level or higher."""- url = f'{self.BASE_URL}/groups'- params = {'owned': 'true', 'per_page': 100, 'top_level_only': 'true'}+ groups_with_admin_access = []+ page = 1+ per_page = 100- try:- response, headers = await self._make_request(url, params)- return response- except Exception:- logger.warning('Error fetching owned groups', exc_info=True)- return []+ while True:+ try:+ url = f'{self.BASE_URL}/groups'+ params = {+ 'page': str(page),+ 'per_page': str(per_page),+ 'min_access_level': min_access_level,+ 'top_level_only': 'true',+ }+ response, headers = await self._make_request(url, params)++ if not response:+ break++ groups_with_admin_access.extend(response)+ page += 1++ # Check if we've reached the last page+ link_header = headers.get('Link', '')+ if 'rel="next"' not in link_header:+ break++ except Exception:+ logger.warning(f'Error fetching groups on page {page}', exc_info=True)+ break++ return groups_with_admin_accessasync def add_owned_projects_and_groups_to_db(self, owned_personal_projects):"""@@ -527,3 +557,55 @@ class SaaSGitLabService(GitLabService):await self._make_request(url=url, params=params, method=RequestMethod.POST)except Exception as e:logger.exception(f'[GitLab]: Reply to MR failed {e}')++ async def get_user_resources_with_admin_access(+ self,+ ) -> tuple[list[dict], list[dict]]:+ """+ Get all projects and groups where the current user has admin access (maintainer or owner).++ Returns:+ tuple[list[dict], list[dict]]: A tuple containing:+ - list of projects where user has admin access+ - list of groups where user has admin access+ """+ projects_with_admin_access = []+ groups_with_admin_access = []++ # Fetch all projects the user is a member of+ page = 1+ per_page = 100+ while True:+ try:+ url = f'{self.BASE_URL}/projects'+ params = {+ 'page': str(page),+ 'per_page': str(per_page),+ 'membership': 1,+ 'min_access_level': 40, # Maintainer or Owner+ }+ response, headers = await self._make_request(url, params)++ if not response:+ break++ projects_with_admin_access.extend(response)+ page += 1++ # Check if we've reached the last page+ link_header = headers.get('Link', '')+ if 'rel="next"' not in link_header:+ break++ except Exception:+ logger.warning(f'Error fetching projects on page {page}', exc_info=True)+ break++ # Fetch all groups where user is owner or maintainer+ groups_with_admin_access = await self.get_owned_groups(min_access_level=40)++ logger.info(+ f'Found {len(projects_with_admin_access)} projects and {len(groups_with_admin_access)} groups with admin access'+ )++ return projects_with_admin_access, groups_with_admin_accessdiff --git a/enterprise/integrations/gitlab/webhook_installation.py b/enterprise/integrations/gitlab/webhook_installation.pynew file mode 100644index 0000000000..c3ab74b205--- /dev/null+++ b/enterprise/integrations/gitlab/webhook_installation.py@@ -0,0 +1,199 @@+"""Shared utilities for GitLab webhook installation.++This module contains reusable functions and classes for installing GitLab webhooks+that can be used by both the cron job and API routes.+"""++from typing import cast+from uuid import uuid4++from integrations.types import GitLabResourceType+from integrations.utils import GITLAB_WEBHOOK_URL+from storage.gitlab_webhook import GitlabWebhook, WebhookStatus+from storage.gitlab_webhook_store import GitlabWebhookStore++from openhands.core.logger import openhands_logger as logger+from openhands.integrations.service_types import GitService++# Webhook configuration constants+WEBHOOK_NAME = 'OpenHands Resolver'+SCOPES: list[str] = [+ 'note_events',+ 'merge_requests_events',+ 'confidential_issues_events',+ 'issues_events',+ 'confidential_note_events',+ 'job_events',+ 'pipeline_events',+]+++class BreakLoopException(Exception):+ """Exception raised when webhook installation conditions are not met or rate limited."""++ pass+++async def verify_webhook_conditions(+ gitlab_service: type[GitService],+ resource_type: GitLabResourceType,+ resource_id: str,+ webhook_store: GitlabWebhookStore,+ webhook: GitlabWebhook,+) -> None:+ """+ Verify all conditions are met for webhook installation.+ Raises BreakLoopException if any condition fails or rate limited.++ Args:+ gitlab_service: GitLab service instance+ resource_type: Type of resource (PROJECT or GROUP)+ resource_id: ID of the resource+ webhook_store: Webhook store instance+ webhook: Webhook object to verify+ """+ from integrations.gitlab.gitlab_service import SaaSGitLabService++ gitlab_service = cast(type[SaaSGitLabService], gitlab_service)++ # Check if resource exists+ does_resource_exist, status = await gitlab_service.check_resource_exists(+ resource_type, resource_id+ )++ logger.info(+ 'Does resource exists',+ extra={+ 'does_resource_exist': does_resource_exist,+ 'status': status,+ 'resource_id': resource_id,+ 'resource_type': resource_type,+ },+ )++ if status == WebhookStatus.RATE_LIMITED:+ raise BreakLoopException()+ if not does_resource_exist and status != WebhookStatus.RATE_LIMITED:+ await webhook_store.delete_webhook(webhook)+ raise BreakLoopException()++ # Check if user has admin access+ (+ is_user_admin_of_resource,+ status,+ ) = await gitlab_service.check_user_has_admin_access_to_resource(+ resource_type, resource_id+ )++ logger.info(+ 'Is user admin',+ extra={+ 'is_user_admin': is_user_admin_of_resource,+ 'status': status,+ 'resource_id': resource_id,+ 'resource_type': resource_type,+ },+ )++ if status == WebhookStatus.RATE_LIMITED:+ raise BreakLoopException()+ if not is_user_admin_of_resource:+ await webhook_store.delete_webhook(webhook)+ raise BreakLoopException()++ # Check if webhook already exists+ (+ does_webhook_exist_on_resource,+ status,+ ) = await gitlab_service.check_webhook_exists_on_resource(+ resource_type, resource_id, GITLAB_WEBHOOK_URL+ )++ logger.info(+ 'Does webhook already exist',+ extra={+ 'does_webhook_exist_on_resource': does_webhook_exist_on_resource,+ 'status': status,+ 'resource_id': resource_id,+ 'resource_type': resource_type,+ },+ )++ if status == WebhookStatus.RATE_LIMITED:+ raise BreakLoopException()+ if does_webhook_exist_on_resource != webhook.webhook_exists:+ await webhook_store.update_webhook(+ webhook, {'webhook_exists': does_webhook_exist_on_resource}+ )++ if does_webhook_exist_on_resource:+ raise BreakLoopException()+++async def install_webhook_on_resource(+ gitlab_service: type[GitService],+ resource_type: GitLabResourceType,+ resource_id: str,+ webhook_store: GitlabWebhookStore,+ webhook: GitlabWebhook,+) -> tuple[str | None, WebhookStatus | None]:+ """+ Install webhook on a GitLab resource.++ Args:+ gitlab_service: GitLab service instance+ resource_type: Type of resource (PROJECT or GROUP)+ resource_id: ID of the resource+ webhook_store: Webhook store instance+ webhook: Webhook object to install++ Returns:+ Tuple of (webhook_id, status)+ """+ from integrations.gitlab.gitlab_service import SaaSGitLabService++ gitlab_service = cast(type[SaaSGitLabService], gitlab_service)++ webhook_secret = f'{webhook.user_id}-{str(uuid4())}'+ webhook_uuid = f'{str(uuid4())}'++ webhook_id, status = await gitlab_service.install_webhook(+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_name=WEBHOOK_NAME,+ webhook_url=GITLAB_WEBHOOK_URL,+ webhook_secret=webhook_secret,+ webhook_uuid=webhook_uuid,+ scopes=SCOPES,+ )++ logger.info(+ 'Creating new webhook',+ extra={+ 'webhook_id': webhook_id,+ 'status': status,+ 'resource_id': resource_id,+ 'resource_type': resource_type,+ },+ )++ if status == WebhookStatus.RATE_LIMITED:+ raise BreakLoopException()++ if webhook_id:+ await webhook_store.update_webhook(+ webhook=webhook,+ update_fields={+ 'webhook_secret': webhook_secret,+ 'webhook_exists': True, # webhook was created+ 'webhook_url': GITLAB_WEBHOOK_URL,+ 'scopes': SCOPES,+ 'webhook_uuid': webhook_uuid, # required to identify which webhook installation is sending payload+ },+ )++ logger.info(+ f'Installed webhook for {webhook.user_id} on {resource_type}:{resource_id}'+ )++ return webhook_id, statusdiff --git a/enterprise/server/routes/integration/gitlab.py b/enterprise/server/routes/integration/gitlab.pyindex e7cad2cb22..a67c0c9742 100644--- a/enterprise/server/routes/integration/gitlab.py+++ b/enterprise/server/routes/integration/gitlab.py@@ -1,15 +1,28 @@+import asyncioimport hashlibimport json-from fastapi import APIRouter, Header, HTTPException, Request+from fastapi import APIRouter, Depends, Header, HTTPException, Request, statusfrom fastapi.responses import JSONResponsefrom integrations.gitlab.gitlab_manager import GitlabManager+from integrations.gitlab.gitlab_service import SaaSGitLabService+from integrations.gitlab.webhook_installation import (+ BreakLoopException,+ install_webhook_on_resource,+ verify_webhook_conditions,+)from integrations.models import Message, SourceType+from integrations.types import GitLabResourceType+from integrations.utils import GITLAB_WEBHOOK_URL+from pydantic import BaseModelfrom server.auth.token_manager import TokenManager+from storage.gitlab_webhook import GitlabWebhookfrom storage.gitlab_webhook_store import GitlabWebhookStorefrom openhands.core.logger import openhands_logger as logger+from openhands.integrations.gitlab.gitlab_service import GitLabServiceImplfrom openhands.server.shared import sio+from openhands.server.user_auth import get_user_idgitlab_integration_router = APIRouter(prefix='/integration')webhook_store = GitlabWebhookStore()@@ -18,6 +31,37 @@ token_manager = TokenManager()gitlab_manager = GitlabManager(token_manager)+# Request/Response models+class ResourceIdentifier(BaseModel):+ type: GitLabResourceType+ id: str+++class ReinstallWebhookRequest(BaseModel):+ resource: ResourceIdentifier+++class ResourceWithWebhookStatus(BaseModel):+ id: str+ name: str+ full_path: str+ type: str+ webhook_installed: bool+ webhook_uuid: str | None+ last_synced: str | None+++class GitLabResourcesResponse(BaseModel):+ resources: list[ResourceWithWebhookStatus]+++class ResourceInstallationResult(BaseModel):+ resource_id: str+ resource_type: str+ success: bool+ error: str | None++async def verify_gitlab_signature(header_webhook_secret: str, webhook_uuid: str, user_id: str):@@ -83,3 +127,260 @@ async def gitlab_events(except Exception as e:logger.exception(f'Error processing GitLab event: {e}')return JSONResponse(status_code=400, content={'error': 'Invalid payload.'})+++@gitlab_integration_router.get('/gitlab/resources')+async def get_gitlab_resources(+ user_id: str = Depends(get_user_id),+) -> GitLabResourcesResponse:+ """Get all GitLab projects and groups where the user has admin access.++ Returns a list of resources with their webhook installation status.+ """+ try:+ # Get GitLab service for the user+ gitlab_service = GitLabServiceImpl(external_auth_id=user_id)++ if not isinstance(gitlab_service, SaaSGitLabService):+ raise HTTPException(+ status_code=status.HTTP_400_BAD_REQUEST,+ detail='Only SaaS GitLab service is supported',+ )++ # Fetch projects and groups with admin access+ projects, groups = await gitlab_service.get_user_resources_with_admin_access()++ # Filter out projects that belong to a group (nested projects)+ # We only want top-level personal projects since group webhooks cover nested projects+ filtered_projects = [+ project+ for project in projects+ if project.get('namespace', {}).get('kind') != 'group'+ ]++ # Extract IDs for bulk fetching+ project_ids = [str(project['id']) for project in filtered_projects]+ group_ids = [str(group['id']) for group in groups]++ # Bulk fetch webhook records from database (organization-wide)+ (+ project_webhook_map,+ group_webhook_map,+ ) = await webhook_store.get_webhooks_by_resources(project_ids, group_ids)++ # Parallelize GitLab API calls to check webhook status for all resources+ async def check_project_webhook(project):+ project_id = str(project['id'])+ webhook_exists, _ = await gitlab_service.check_webhook_exists_on_resource(+ GitLabResourceType.PROJECT, project_id, GITLAB_WEBHOOK_URL+ )+ return project_id, webhook_exists++ async def check_group_webhook(group):+ group_id = str(group['id'])+ webhook_exists, _ = await gitlab_service.check_webhook_exists_on_resource(+ GitLabResourceType.GROUP, group_id, GITLAB_WEBHOOK_URL+ )+ return group_id, webhook_exists++ # Gather all API calls in parallel+ project_checks = [+ check_project_webhook(project) for project in filtered_projects+ ]+ group_checks = [check_group_webhook(group) for group in groups]++ # Execute all checks concurrently+ all_results = await asyncio.gather(*(project_checks + group_checks))++ # Split results back into projects and groups+ num_projects = len(filtered_projects)+ project_results = all_results[:num_projects]+ group_results = all_results[num_projects:]++ # Build response+ resources = []++ # Add projects with their webhook status+ for project, (project_id, webhook_exists) in zip(+ filtered_projects, project_results+ ):+ webhook = project_webhook_map.get(project_id)++ resources.append(+ ResourceWithWebhookStatus(+ id=project_id,+ name=project.get('name', ''),+ full_path=project.get('path_with_namespace', ''),+ type='project',+ webhook_installed=webhook_exists,+ webhook_uuid=webhook.webhook_uuid if webhook else None,+ last_synced=(+ webhook.last_synced.isoformat()+ if webhook and webhook.last_synced+ else None+ ),+ )+ )++ # Add groups with their webhook status+ for group, (group_id, webhook_exists) in zip(groups, group_results):+ webhook = group_webhook_map.get(group_id)++ resources.append(+ ResourceWithWebhookStatus(+ id=group_id,+ name=group.get('name', ''),+ full_path=group.get('full_path', ''),+ type='group',+ webhook_installed=webhook_exists,+ webhook_uuid=webhook.webhook_uuid if webhook else None,+ last_synced=(+ webhook.last_synced.isoformat()+ if webhook and webhook.last_synced+ else None+ ),+ )+ )++ logger.info(+ 'Retrieved GitLab resources',+ extra={+ 'user_id': user_id,+ 'project_count': len(projects),+ 'group_count': len(groups),+ },+ )++ return GitLabResourcesResponse(resources=resources)++ except HTTPException:+ raise+ except Exception as e:+ logger.exception(f'Error retrieving GitLab resources: {e}')+ raise HTTPException(+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,+ detail='Failed to retrieve GitLab resources',+ )+++@gitlab_integration_router.post('/gitlab/reinstall-webhook')+async def reinstall_gitlab_webhook(+ body: ReinstallWebhookRequest,+ user_id: str = Depends(get_user_id),+) -> ResourceInstallationResult:+ """Reinstall GitLab webhook for a specific resource immediately.++ This endpoint validates permissions, resets webhook status in the database,+ and immediately installs the webhook on the specified resource.+ """+ try:+ # Get GitLab service for the user+ gitlab_service = GitLabServiceImpl(external_auth_id=user_id)++ if not isinstance(gitlab_service, SaaSGitLabService):+ raise HTTPException(+ status_code=status.HTTP_400_BAD_REQUEST,+ detail='Only SaaS GitLab service is supported',+ )++ resource_id = body.resource.id+ resource_type = body.resource.type++ # Check if user has admin access to this resource+ (+ has_admin_access,+ check_status,+ ) = await gitlab_service.check_user_has_admin_access_to_resource(+ resource_type, resource_id+ )++ if not has_admin_access:+ raise HTTPException(+ status_code=status.HTTP_403_FORBIDDEN,+ detail='User does not have admin access to this resource',+ )++ # Reset webhook in database (organization-wide, not user-specific)+ # This allows any admin user to reinstall webhooks+ await webhook_store.reset_webhook_for_reinstallation_by_resource(+ resource_type, resource_id, user_id+ )++ # Get or create webhook record (without user_id filter)+ webhook = await webhook_store.get_webhook_by_resource_only(+ resource_type, resource_id+ )++ if not webhook:+ # Create new webhook record+ webhook = GitlabWebhook(+ user_id=user_id, # Track who created it+ project_id=resource_id+ if resource_type == GitLabResourceType.PROJECT+ else None,+ group_id=resource_id+ if resource_type == GitLabResourceType.GROUP+ else None,+ webhook_exists=False,+ )+ await webhook_store.store_webhooks([webhook])+ # Fetch it again to get the ID (without user_id filter)+ webhook = await webhook_store.get_webhook_by_resource_only(+ resource_type, resource_id+ )++ # Verify conditions and install webhook+ try:+ await verify_webhook_conditions(+ gitlab_service=gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=webhook_store,+ webhook=webhook,+ )++ # Install the webhook+ webhook_id, install_status = await install_webhook_on_resource(+ gitlab_service=gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=webhook_store,+ webhook=webhook,+ )++ if webhook_id:+ logger.info(+ 'GitLab webhook reinstalled successfully',+ extra={+ 'user_id': user_id,+ 'resource_type': resource_type.value,+ 'resource_id': resource_id,+ },+ )+ return ResourceInstallationResult(+ resource_id=resource_id,+ resource_type=resource_type.value,+ success=True,+ error=None,+ )+ else:+ raise HTTPException(+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,+ detail='Failed to install webhook',+ )++ except BreakLoopException:+ # Conditions not met or webhook already exists+ raise HTTPException(+ status_code=status.HTTP_400_BAD_REQUEST,+ detail='Webhook installation conditions not met or webhook already exists',+ )++ except HTTPException:+ raise+ except Exception as e:+ logger.exception(f'Error reinstalling GitLab webhook: {e}')+ raise HTTPException(+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,+ detail='Failed to reinstall webhook',+ )diff --git a/enterprise/storage/gitlab_webhook_store.py b/enterprise/storage/gitlab_webhook_store.pyindex 22d660fc0f..058e35c21b 100644--- a/enterprise/storage/gitlab_webhook_store.py+++ b/enterprise/storage/gitlab_webhook_store.py@@ -220,6 +220,127 @@ class GitlabWebhookStore:return webhooks[0].webhook_secretreturn None+ async def get_webhook_by_resource_only(+ self, resource_type: GitLabResourceType, resource_id: str+ ) -> GitlabWebhook | None:+ """Get a webhook by resource without filtering by user_id.++ This allows any admin user in the organization to manage webhooks,+ not just the original installer.++ Args:+ resource_type: The type of resource (PROJECT or GROUP)+ resource_id: The ID of the resource++ Returns:+ GitlabWebhook object if found, None otherwise+ """+ async with self.a_session_maker() as session:+ if resource_type == GitLabResourceType.PROJECT:+ query = select(GitlabWebhook).where(+ GitlabWebhook.project_id == resource_id+ )+ else: # GROUP+ query = select(GitlabWebhook).where(+ GitlabWebhook.group_id == resource_id+ )++ result = await session.execute(query)+ webhook = result.scalars().first()+ return webhook++ async def get_webhooks_by_resources(+ self, project_ids: list[str], group_ids: list[str]+ ) -> tuple[dict[str, GitlabWebhook], dict[str, GitlabWebhook]]:+ """Bulk fetch webhooks for multiple resources.++ This is more efficient than fetching one at a time in a loop.++ Args:+ project_ids: List of project IDs to fetch+ group_ids: List of group IDs to fetch++ Returns:+ Tuple of (project_webhook_map, group_webhook_map)+ """+ async with self.a_session_maker() as session:+ project_webhook_map = {}+ group_webhook_map = {}++ # Fetch all project webhooks in one query+ if project_ids:+ project_query = select(GitlabWebhook).where(+ GitlabWebhook.project_id.in_(project_ids)+ )+ result = await session.execute(project_query)+ project_webhooks = result.scalars().all()+ project_webhook_map = {wh.project_id: wh for wh in project_webhooks}++ # Fetch all group webhooks in one query+ if group_ids:+ group_query = select(GitlabWebhook).where(+ GitlabWebhook.group_id.in_(group_ids)+ )+ result = await session.execute(group_query)+ group_webhooks = result.scalars().all()+ group_webhook_map = {wh.group_id: wh for wh in group_webhooks}++ return project_webhook_map, group_webhook_map++ async def reset_webhook_for_reinstallation_by_resource(+ self, resource_type: GitLabResourceType, resource_id: str, updating_user_id: str+ ) -> bool:+ """Reset webhook for reinstallation without filtering by user_id.++ This allows any admin user to reset webhooks, and updates the user_id+ to track who last modified it.++ Args:+ resource_type: The type of resource (PROJECT or GROUP)+ resource_id: The ID of the resource+ updating_user_id: The user ID performing the update (for audit purposes)++ Returns:+ True if webhook was reset, False if not found+ """+ async with self.a_session_maker() as session:+ async with session.begin():+ if resource_type == GitLabResourceType.PROJECT:+ update_statement = (+ update(GitlabWebhook)+ .where(GitlabWebhook.project_id == resource_id)+ .values(+ webhook_exists=False,+ webhook_uuid=None,+ user_id=updating_user_id, # Update to track who modified it+ )+ )+ else: # GROUP+ update_statement = (+ update(GitlabWebhook)+ .where(GitlabWebhook.group_id == resource_id)+ .values(+ webhook_exists=False,+ webhook_uuid=None,+ user_id=updating_user_id, # Update to track who modified it+ )+ )++ result = await session.execute(update_statement)+ rows_updated = result.rowcount++ logger.info(+ 'Reset webhook for reinstallation (organization-wide)',+ extra={+ 'updating_user_id': updating_user_id,+ 'resource_type': resource_type.value,+ 'resource_id': resource_id,+ 'rows_updated': rows_updated,+ },+ )++ return rows_updated > 0+@classmethodasync def get_instance(cls) -> GitlabWebhookStore:"""Get an instance of the GitlabWebhookStore.diff --git a/enterprise/sync/install_gitlab_webhooks.py b/enterprise/sync/install_gitlab_webhooks.pyindex 8f274bf81c..e11085e300 100644--- a/enterprise/sync/install_gitlab_webhooks.py+++ b/enterprise/sync/install_gitlab_webhooks.py@@ -1,7 +1,11 @@import asynciofrom typing import cast-from uuid import uuid4+from integrations.gitlab.webhook_installation import (+ BreakLoopException,+ install_webhook_on_resource,+ verify_webhook_conditions,+)from integrations.types import GitLabResourceTypefrom integrations.utils import GITLAB_WEBHOOK_URLfrom sqlalchemy import text@@ -14,20 +18,6 @@ from openhands.integrations.gitlab.gitlab_service import GitLabServiceImplfrom openhands.integrations.service_types import GitServiceCHUNK_SIZE = 100-WEBHOOK_NAME = 'OpenHands Resolver'-SCOPES: list[str] = [- 'note_events',- 'merge_requests_events',- 'confidential_issues_events',- 'issues_events',- 'confidential_note_events',- 'job_events',- 'pipeline_events',-]---class BreakLoopException(Exception):- passclass VerifyWebhookStatus:@@ -43,77 +33,6 @@ class VerifyWebhookStatus:if status == WebhookStatus.RATE_LIMITED:raise BreakLoopException()- async def check_if_resource_exists(- self,- gitlab_service: type[GitService],- resource_type: GitLabResourceType,- resource_id: str,- webhook_store: GitlabWebhookStore,- webhook: GitlabWebhook,- ):- """- Check if the GitLab resource still exists- """- from integrations.gitlab.gitlab_service import SaaSGitLabService-- gitlab_service = cast(type[SaaSGitLabService], gitlab_service)-- does_resource_exist, status = await gitlab_service.check_resource_exists(- resource_type, resource_id- )-- logger.info(- 'Does resource exists',- extra={- 'does_resource_exist': does_resource_exist,- 'status': status,- 'resource_id': resource_id,- 'resource_type': resource_type,- },- )-- self.determine_if_rate_limited(status)- if not does_resource_exist and status != WebhookStatus.RATE_LIMITED:- await webhook_store.delete_webhook(webhook)- raise BreakLoopException()-- async def check_if_user_has_admin_acccess_to_resource(- self,- gitlab_service: type[GitService],- resource_type: GitLabResourceType,- resource_id: str,- webhook_store: GitlabWebhookStore,- webhook: GitlabWebhook,- ):- """- Check is user still has permission to resource- """- from integrations.gitlab.gitlab_service import SaaSGitLabService-- gitlab_service = cast(type[SaaSGitLabService], gitlab_service)-- (- is_user_admin_of_resource,- status,- ) = await gitlab_service.check_user_has_admin_access_to_resource(- resource_type, resource_id- )-- logger.info(- 'Is user admin',- extra={- 'is_user_admin': is_user_admin_of_resource,- 'status': status,- 'resource_id': resource_id,- 'resource_type': resource_type,- },- )-- self.determine_if_rate_limited(status)- if not is_user_admin_of_resource:- await webhook_store.delete_webhook(webhook)- raise BreakLoopException()-async def check_if_webhook_already_exists_on_resource(self,gitlab_service: type[GitService],@@ -162,23 +81,8 @@ class VerifyWebhookStatus:webhook_store: GitlabWebhookStore,webhook: GitlabWebhook,):- await self.check_if_resource_exists(- gitlab_service=gitlab_service,- resource_type=resource_type,- resource_id=resource_id,- webhook_store=webhook_store,- webhook=webhook,- )-- await self.check_if_user_has_admin_acccess_to_resource(- gitlab_service=gitlab_service,- resource_type=resource_type,- resource_id=resource_id,- webhook_store=webhook_store,- webhook=webhook,- )-- await self.check_if_webhook_already_exists_on_resource(+ # Use the standalone function+ await verify_webhook_conditions(gitlab_service=gitlab_service,resource_type=resource_type,resource_id=resource_id,@@ -197,51 +101,15 @@ class VerifyWebhookStatus:"""Install webhook on resource"""- from integrations.gitlab.gitlab_service import SaaSGitLabService-- gitlab_service = cast(type[SaaSGitLabService], gitlab_service)-- webhook_secret = f'{webhook.user_id}-{str(uuid4())}'- webhook_uuid = f'{str(uuid4())}'-- webhook_id, status = await gitlab_service.install_webhook(+ # Use the standalone function+ await install_webhook_on_resource(+ gitlab_service=gitlab_service,resource_type=resource_type,resource_id=resource_id,- webhook_name=WEBHOOK_NAME,- webhook_url=GITLAB_WEBHOOK_URL,- webhook_secret=webhook_secret,- webhook_uuid=webhook_uuid,- scopes=SCOPES,- )-- logger.info(- 'Creating new webhook',- extra={- 'webhook_id': webhook_id,- 'status': status,- 'resource_id': resource_id,- 'resource_type': resource_type,- },+ webhook_store=webhook_store,+ webhook=webhook,)- self.determine_if_rate_limited(status)-- if webhook_id:- await webhook_store.update_webhook(- webhook=webhook,- update_fields={- 'webhook_secret': webhook_secret,- 'webhook_exists': True, # webhook was created- 'webhook_url': GITLAB_WEBHOOK_URL,- 'scopes': SCOPES,- 'webhook_uuid': webhook_uuid, # required to identify which webhook installation is sending payload- },- )-- logger.info(- f'Installed webhook for {webhook.user_id} on {resource_type}:{resource_id}'- )-async def install_webhooks(self):"""Periodically check the conditions for installing a webhook on resource as validdiff --git a/enterprise/tests/unit/integrations/gitlab/test_gitlab_service.py b/enterprise/tests/unit/integrations/gitlab/test_gitlab_service.pynew file mode 100644index 0000000000..1f479f9312--- /dev/null+++ b/enterprise/tests/unit/integrations/gitlab/test_gitlab_service.py@@ -0,0 +1,204 @@+"""Unit tests for SaaSGitLabService."""++from unittest.mock import patch++import pytest+from integrations.gitlab.gitlab_service import SaaSGitLabService+++def gitlab_service():+ """Create a SaaSGitLabService instance for testing."""+ return SaaSGitLabService(external_auth_id='test_user_id')+++class TestGetUserResourcesWithAdminAccess:+ """Test cases for get_user_resources_with_admin_access method."""++ @pytest.mark.asyncio+ async def test_get_resources_single_page_projects_and_groups(self, gitlab_service):+ """Test fetching resources when all data fits in a single page."""+ # Arrange+ mock_projects = [+ {'id': 1, 'name': 'Project 1'},+ {'id': 2, 'name': 'Project 2'},+ ]+ mock_groups = [+ {'id': 10, 'name': 'Group 1'},+ ]++ with patch.object(gitlab_service, '_make_request') as mock_request:+ # First call for projects, second for groups+ mock_request.side_effect = [+ (mock_projects, {'Link': ''}), # No next page+ (mock_groups, {'Link': ''}), # No next page+ ]++ # Act+ (+ projects,+ groups,+ ) = await gitlab_service.get_user_resources_with_admin_access()++ # Assert+ assert len(projects) == 2+ assert len(groups) == 1+ assert projects[0]['id'] == 1+ assert projects[1]['id'] == 2+ assert groups[0]['id'] == 10+ assert mock_request.call_count == 2++ @pytest.mark.asyncio+ async def test_get_resources_multiple_pages_projects(self, gitlab_service):+ """Test fetching projects across multiple pages."""+ # Arrange+ page1_projects = [{'id': i, 'name': f'Project {i}'} for i in range(1, 101)]+ page2_projects = [{'id': i, 'name': f'Project {i}'} for i in range(101, 151)]++ with patch.object(gitlab_service, '_make_request') as mock_request:+ mock_request.side_effect = [+ (page1_projects, {'Link': '<url>; rel="next"'}), # Has next page+ (page2_projects, {'Link': ''}), # Last page+ ([], {'Link': ''}), # Groups (empty)+ ]++ # Act+ (+ projects,+ groups,+ ) = await gitlab_service.get_user_resources_with_admin_access()++ # Assert+ assert len(projects) == 150+ assert len(groups) == 0+ assert mock_request.call_count == 3++ @pytest.mark.asyncio+ async def test_get_resources_multiple_pages_groups(self, gitlab_service):+ """Test fetching groups across multiple pages."""+ # Arrange+ page1_groups = [{'id': i, 'name': f'Group {i}'} for i in range(1, 101)]+ page2_groups = [{'id': i, 'name': f'Group {i}'} for i in range(101, 151)]++ with patch.object(gitlab_service, '_make_request') as mock_request:+ mock_request.side_effect = [+ ([], {'Link': ''}), # Projects (empty)+ (page1_groups, {'Link': '<url>; rel="next"'}), # Has next page+ (page2_groups, {'Link': ''}), # Last page+ ]++ # Act+ (+ projects,+ groups,+ ) = await gitlab_service.get_user_resources_with_admin_access()++ # Assert+ assert len(projects) == 0+ assert len(groups) == 150+ assert mock_request.call_count == 3++ @pytest.mark.asyncio+ async def test_get_resources_empty_response(self, gitlab_service):+ """Test when user has no projects or groups with admin access."""+ # Arrange+ with patch.object(gitlab_service, '_make_request') as mock_request:+ mock_request.side_effect = [+ ([], {'Link': ''}), # No projects+ ([], {'Link': ''}), # No groups+ ]++ # Act+ (+ projects,+ groups,+ ) = await gitlab_service.get_user_resources_with_admin_access()++ # Assert+ assert len(projects) == 0+ assert len(groups) == 0+ assert mock_request.call_count == 2++ @pytest.mark.asyncio+ async def test_get_resources_uses_correct_params_for_projects(self, gitlab_service):+ """Test that projects API is called with correct parameters."""+ # Arrange+ with patch.object(gitlab_service, '_make_request') as mock_request:+ mock_request.side_effect = [+ ([], {'Link': ''}), # Projects+ ([], {'Link': ''}), # Groups+ ]++ # Act+ await gitlab_service.get_user_resources_with_admin_access()++ # Assert+ # Check first call (projects)+ first_call = mock_request.call_args_list[0]+ assert 'projects' in first_call[0][0]+ assert first_call[0][1]['membership'] == 1+ assert first_call[0][1]['min_access_level'] == 40+ assert first_call[0][1]['per_page'] == '100'++ @pytest.mark.asyncio+ async def test_get_resources_uses_correct_params_for_groups(self, gitlab_service):+ """Test that groups API is called with correct parameters."""+ # Arrange+ with patch.object(gitlab_service, '_make_request') as mock_request:+ mock_request.side_effect = [+ ([], {'Link': ''}), # Projects+ ([], {'Link': ''}), # Groups+ ]++ # Act+ await gitlab_service.get_user_resources_with_admin_access()++ # Assert+ # Check second call (groups)+ second_call = mock_request.call_args_list[1]+ assert 'groups' in second_call[0][0]+ assert second_call[0][1]['min_access_level'] == 40+ assert second_call[0][1]['top_level_only'] == 'true'+ assert second_call[0][1]['per_page'] == '100'++ @pytest.mark.asyncio+ async def test_get_resources_handles_api_error_gracefully(self, gitlab_service):+ """Test that API errors are handled gracefully and don't crash."""+ # Arrange+ with patch.object(gitlab_service, '_make_request') as mock_request:+ # First call succeeds, second call fails+ mock_request.side_effect = [+ ([{'id': 1, 'name': 'Project 1'}], {'Link': ''}),+ Exception('API Error'),+ ]++ # Act+ (+ projects,+ groups,+ ) = await gitlab_service.get_user_resources_with_admin_access()++ # Assert+ # Should return what was fetched before the error+ assert len(projects) == 1+ assert len(groups) == 0++ @pytest.mark.asyncio+ async def test_get_resources_stops_on_empty_response(self, gitlab_service):+ """Test that pagination stops when API returns empty response."""+ # Arrange+ with patch.object(gitlab_service, '_make_request') as mock_request:+ mock_request.side_effect = [+ (None, {'Link': ''}), # Empty response stops pagination+ ([], {'Link': ''}), # Groups+ ]++ # Act+ (+ projects,+ groups,+ ) = await gitlab_service.get_user_resources_with_admin_access()++ # Assert+ assert len(projects) == 0+ assert mock_request.call_count == 2 # Should not continue paginationdiff --git a/enterprise/tests/unit/server/routes/test_gitlab_integration_routes.py b/enterprise/tests/unit/server/routes/test_gitlab_integration_routes.pynew file mode 100644index 0000000000..43a0ebd013--- /dev/null+++ b/enterprise/tests/unit/server/routes/test_gitlab_integration_routes.py@@ -0,0 +1,502 @@+"""Unit tests for GitLab integration routes."""++from unittest.mock import AsyncMock, MagicMock, patch++import pytest+from fastapi import HTTPException, status+from integrations.gitlab.gitlab_service import SaaSGitLabService+from integrations.gitlab.webhook_installation import BreakLoopException+from integrations.types import GitLabResourceType+from server.routes.integration.gitlab import (+ ReinstallWebhookRequest,+ ResourceIdentifier,+ get_gitlab_resources,+ reinstall_gitlab_webhook,+)+from storage.gitlab_webhook import GitlabWebhook+++def mock_gitlab_service():+ """Create a mock SaaSGitLabService instance."""+ service = MagicMock(spec=SaaSGitLabService)+ service.get_user_resources_with_admin_access = AsyncMock(+ return_value=(+ [+ {+ 'id': 1,+ 'name': 'Test Project',+ 'path_with_namespace': 'user/test-project',+ 'namespace': {'kind': 'user'},+ },+ {+ 'id': 2,+ 'name': 'Group Project',+ 'path_with_namespace': 'group/group-project',+ 'namespace': {'kind': 'group'},+ },+ ],+ [+ {+ 'id': 10,+ 'name': 'Test Group',+ 'full_path': 'test-group',+ },+ ],+ )+ )+ service.check_webhook_exists_on_resource = AsyncMock(return_value=(True, None))+ service.check_user_has_admin_access_to_resource = AsyncMock(+ return_value=(True, None)+ )+ return service+++def mock_webhook():+ """Create a mock webhook object."""+ webhook = MagicMock(spec=GitlabWebhook)+ webhook.webhook_uuid = 'test-uuid'+ webhook.last_synced = None+ return webhook+++class TestGetGitLabResources:+ """Test cases for get_gitlab_resources endpoint."""++ @pytest.mark.asyncio+ @patch('server.routes.integration.gitlab.GitLabServiceImpl')+ @patch('server.routes.integration.gitlab.webhook_store')+ @patch('server.routes.integration.gitlab.isinstance')+ async def test_get_resources_success(+ self,+ mock_isinstance,+ mock_webhook_store,+ mock_gitlab_service_impl,+ mock_gitlab_service,+ ):+ """Test successfully retrieving GitLab resources with webhook status."""+ # Arrange+ user_id = 'test_user_id'+ mock_gitlab_service_impl.return_value = mock_gitlab_service+ mock_isinstance.return_value = True+ mock_webhook_store.get_webhooks_by_resources = AsyncMock(+ return_value=({}, {}) # Empty maps for simplicity+ )++ # Act+ response = await get_gitlab_resources(user_id=user_id)++ # Assert+ assert len(response.resources) == 2 # 1 project (filtered) + 1 group+ assert response.resources[0].type == 'project'+ assert response.resources[0].id == '1'+ assert response.resources[0].name == 'Test Project'+ assert response.resources[1].type == 'group'+ assert response.resources[1].id == '10'+ mock_gitlab_service.get_user_resources_with_admin_access.assert_called_once()+ mock_webhook_store.get_webhooks_by_resources.assert_called_once()++ @pytest.mark.asyncio+ @patch('server.routes.integration.gitlab.GitLabServiceImpl')+ @patch('server.routes.integration.gitlab.webhook_store')+ @patch('server.routes.integration.gitlab.isinstance')+ async def test_get_resources_filters_nested_projects(+ self,+ mock_isinstance,+ mock_webhook_store,+ mock_gitlab_service_impl,+ mock_gitlab_service,+ ):+ """Test that projects nested under groups are filtered out."""+ # Arrange+ user_id = 'test_user_id'+ mock_gitlab_service_impl.return_value = mock_gitlab_service+ mock_isinstance.return_value = True+ mock_webhook_store.get_webhooks_by_resources = AsyncMock(return_value=({}, {}))++ # Act+ response = await get_gitlab_resources(user_id=user_id)++ # Assert+ # Should only include the user project, not the group project+ project_resources = [r for r in response.resources if r.type == 'project']+ assert len(project_resources) == 1+ assert project_resources[0].id == '1'+ assert project_resources[0].name == 'Test Project'++ @pytest.mark.asyncio+ @patch('server.routes.integration.gitlab.GitLabServiceImpl')+ @patch('server.routes.integration.gitlab.webhook_store')+ @patch('server.routes.integration.gitlab.isinstance')+ async def test_get_resources_includes_webhook_metadata(+ self,+ mock_isinstance,+ mock_webhook_store,+ mock_gitlab_service_impl,+ mock_gitlab_service,+ mock_webhook,+ ):+ """Test that webhook metadata is included in the response."""+ # Arrange+ user_id = 'test_user_id'+ mock_gitlab_service_impl.return_value = mock_gitlab_service+ mock_isinstance.return_value = True+ mock_webhook_store.get_webhooks_by_resources = AsyncMock(+ return_value=({'1': mock_webhook}, {'10': mock_webhook})+ )++ # Act+ response = await get_gitlab_resources(user_id=user_id)++ # Assert+ assert response.resources[0].webhook_uuid == 'test-uuid'+ assert response.resources[1].webhook_uuid == 'test-uuid'++ @pytest.mark.asyncio+ @patch('server.routes.integration.gitlab.GitLabServiceImpl')+ async def test_get_resources_non_saas_service(+ self, mock_gitlab_service_impl, mock_gitlab_service+ ):+ """Test that non-SaaS GitLab service raises an error."""+ # Arrange+ user_id = 'test_user_id'+ non_saas_service = AsyncMock()+ mock_gitlab_service_impl.return_value = non_saas_service++ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await get_gitlab_resources(user_id=user_id)++ assert exc_info.value.status_code == status.HTTP_400_BAD_REQUEST+ assert 'Only SaaS GitLab service is supported' in exc_info.value.detail++ @pytest.mark.asyncio+ @patch('server.routes.integration.gitlab.GitLabServiceImpl')+ @patch('server.routes.integration.gitlab.webhook_store')+ @patch('server.routes.integration.gitlab.isinstance')+ async def test_get_resources_parallel_api_calls(+ self,+ mock_isinstance,+ mock_webhook_store,+ mock_gitlab_service_impl,+ mock_gitlab_service,+ ):+ """Test that webhook status checks are made in parallel."""+ # Arrange+ user_id = 'test_user_id'+ mock_gitlab_service_impl.return_value = mock_gitlab_service+ mock_isinstance.return_value = True+ mock_webhook_store.get_webhooks_by_resources = AsyncMock(return_value=({}, {}))+ call_count = 0++ async def track_calls(*args, **kwargs):+ nonlocal call_count+ call_count += 1+ return (True, None)++ mock_gitlab_service.check_webhook_exists_on_resource = AsyncMock(+ side_effect=track_calls+ )++ # Act+ await get_gitlab_resources(user_id=user_id)++ # Assert+ # Should be called for each resource (1 project + 1 group)+ assert call_count == 2+++class TestReinstallGitLabWebhook:+ """Test cases for reinstall_gitlab_webhook endpoint."""++ @pytest.mark.asyncio+ @patch('server.routes.integration.gitlab.install_webhook_on_resource')+ @patch('server.routes.integration.gitlab.verify_webhook_conditions')+ @patch('server.routes.integration.gitlab.GitLabServiceImpl')+ @patch('server.routes.integration.gitlab.webhook_store')+ @patch('server.routes.integration.gitlab.isinstance')+ async def test_reinstall_webhook_success_existing_webhook(+ self,+ mock_isinstance,+ mock_webhook_store,+ mock_gitlab_service_impl,+ mock_verify_conditions,+ mock_install_webhook,+ mock_gitlab_service,+ mock_webhook,+ ):+ """Test successful webhook reinstallation when webhook record exists."""+ # Arrange+ user_id = 'test_user_id'+ resource_id = 'project-123'+ resource_type = GitLabResourceType.PROJECT++ mock_gitlab_service_impl.return_value = mock_gitlab_service+ mock_isinstance.return_value = True+ mock_webhook_store.reset_webhook_for_reinstallation_by_resource = AsyncMock(+ return_value=True+ )+ mock_webhook_store.get_webhook_by_resource_only = AsyncMock(+ return_value=mock_webhook+ )+ mock_verify_conditions.return_value = None+ mock_install_webhook.return_value = ('webhook-id-123', None)++ body = ReinstallWebhookRequest(+ resource=ResourceIdentifier(type=resource_type, id=resource_id)+ )++ # Act+ result = await reinstall_gitlab_webhook(body=body, user_id=user_id)++ # Assert+ assert result.success is True+ assert result.resource_id == resource_id+ assert result.resource_type == resource_type.value+ assert result.error is None+ mock_gitlab_service.check_user_has_admin_access_to_resource.assert_called_once_with(+ resource_type, resource_id+ )+ mock_webhook_store.reset_webhook_for_reinstallation_by_resource.assert_called_once_with(+ resource_type, resource_id, user_id+ )+ mock_verify_conditions.assert_called_once()+ mock_install_webhook.assert_called_once()++ @pytest.mark.asyncio+ @patch('server.routes.integration.gitlab.install_webhook_on_resource')+ @patch('server.routes.integration.gitlab.verify_webhook_conditions')+ @patch('server.routes.integration.gitlab.GitLabServiceImpl')+ @patch('server.routes.integration.gitlab.webhook_store')+ @patch('server.routes.integration.gitlab.isinstance')+ async def test_reinstall_webhook_success_new_webhook_record(+ self,+ mock_isinstance,+ mock_webhook_store,+ mock_gitlab_service_impl,+ mock_verify_conditions,+ mock_install_webhook,+ mock_gitlab_service,+ ):+ """Test successful webhook reinstallation when webhook record doesn't exist."""+ # Arrange+ user_id = 'test_user_id'+ resource_id = 'project-456'+ resource_type = GitLabResourceType.PROJECT++ mock_gitlab_service_impl.return_value = mock_gitlab_service+ mock_isinstance.return_value = True+ mock_webhook_store.reset_webhook_for_reinstallation_by_resource = (+ AsyncMock(return_value=False) # No existing webhook to reset+ )+ mock_webhook_store.get_webhook_by_resource_only = AsyncMock(+ side_effect=[+ None,+ MagicMock(),+ ] # First call returns None, second returns new webhook+ )+ mock_webhook_store.store_webhooks = AsyncMock()+ mock_verify_conditions.return_value = None+ mock_install_webhook.return_value = ('webhook-id-456', None)++ body = ReinstallWebhookRequest(+ resource=ResourceIdentifier(type=resource_type, id=resource_id)+ )++ # Act+ result = await reinstall_gitlab_webhook(body=body, user_id=user_id)++ # Assert+ assert result.success is True+ mock_webhook_store.store_webhooks.assert_called_once()+ # Should fetch webhook twice: once to check, once after creating+ assert mock_webhook_store.get_webhook_by_resource_only.call_count == 2++ @pytest.mark.asyncio+ @patch('server.routes.integration.gitlab.GitLabServiceImpl')+ @patch('server.routes.integration.gitlab.isinstance')+ async def test_reinstall_webhook_no_admin_access(+ self, mock_isinstance, mock_gitlab_service_impl, mock_gitlab_service+ ):+ """Test reinstallation when user doesn't have admin access."""+ # Arrange+ user_id = 'test_user_id'+ resource_id = 'project-789'+ resource_type = GitLabResourceType.PROJECT++ mock_gitlab_service_impl.return_value = mock_gitlab_service+ mock_isinstance.return_value = True+ mock_gitlab_service.check_user_has_admin_access_to_resource = AsyncMock(+ return_value=(False, None)+ )++ body = ReinstallWebhookRequest(+ resource=ResourceIdentifier(type=resource_type, id=resource_id)+ )++ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await reinstall_gitlab_webhook(body=body, user_id=user_id)++ assert exc_info.value.status_code == status.HTTP_403_FORBIDDEN+ assert 'does not have admin access' in exc_info.value.detail++ @pytest.mark.asyncio+ @patch('server.routes.integration.gitlab.GitLabServiceImpl')+ async def test_reinstall_webhook_non_saas_service(self, mock_gitlab_service_impl):+ """Test reinstallation with non-SaaS GitLab service."""+ # Arrange+ user_id = 'test_user_id'+ resource_id = 'project-999'+ resource_type = GitLabResourceType.PROJECT++ non_saas_service = AsyncMock()+ mock_gitlab_service_impl.return_value = non_saas_service++ body = ReinstallWebhookRequest(+ resource=ResourceIdentifier(type=resource_type, id=resource_id)+ )++ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await reinstall_gitlab_webhook(body=body, user_id=user_id)++ assert exc_info.value.status_code == status.HTTP_400_BAD_REQUEST+ assert 'Only SaaS GitLab service is supported' in exc_info.value.detail++ @pytest.mark.asyncio+ @patch('server.routes.integration.gitlab.install_webhook_on_resource')+ @patch('server.routes.integration.gitlab.verify_webhook_conditions')+ @patch('server.routes.integration.gitlab.GitLabServiceImpl')+ @patch('server.routes.integration.gitlab.webhook_store')+ @patch('server.routes.integration.gitlab.isinstance')+ async def test_reinstall_webhook_conditions_not_met(+ self,+ mock_isinstance,+ mock_webhook_store,+ mock_gitlab_service_impl,+ mock_verify_conditions,+ mock_install_webhook,+ mock_gitlab_service,+ mock_webhook,+ ):+ """Test reinstallation when webhook conditions are not met."""+ # Arrange+ user_id = 'test_user_id'+ resource_id = 'project-111'+ resource_type = GitLabResourceType.PROJECT++ mock_gitlab_service_impl.return_value = mock_gitlab_service+ mock_isinstance.return_value = True+ mock_webhook_store.reset_webhook_for_reinstallation_by_resource = AsyncMock(+ return_value=True+ )+ mock_webhook_store.get_webhook_by_resource_only = AsyncMock(+ return_value=mock_webhook+ )+ mock_verify_conditions.side_effect = BreakLoopException()++ body = ReinstallWebhookRequest(+ resource=ResourceIdentifier(type=resource_type, id=resource_id)+ )++ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await reinstall_gitlab_webhook(body=body, user_id=user_id)++ assert exc_info.value.status_code == status.HTTP_400_BAD_REQUEST+ assert 'conditions not met' in exc_info.value.detail.lower()+ mock_install_webhook.assert_not_called()++ @pytest.mark.asyncio+ @patch('server.routes.integration.gitlab.install_webhook_on_resource')+ @patch('server.routes.integration.gitlab.verify_webhook_conditions')+ @patch('server.routes.integration.gitlab.GitLabServiceImpl')+ @patch('server.routes.integration.gitlab.webhook_store')+ @patch('server.routes.integration.gitlab.isinstance')+ async def test_reinstall_webhook_installation_fails(+ self,+ mock_isinstance,+ mock_webhook_store,+ mock_gitlab_service_impl,+ mock_verify_conditions,+ mock_install_webhook,+ mock_gitlab_service,+ mock_webhook,+ ):+ """Test reinstallation when webhook installation fails."""+ # Arrange+ user_id = 'test_user_id'+ resource_id = 'project-222'+ resource_type = GitLabResourceType.PROJECT++ mock_gitlab_service_impl.return_value = mock_gitlab_service+ mock_isinstance.return_value = True+ mock_webhook_store.reset_webhook_for_reinstallation_by_resource = AsyncMock(+ return_value=True+ )+ mock_webhook_store.get_webhook_by_resource_only = AsyncMock(+ return_value=mock_webhook+ )+ mock_verify_conditions.return_value = None+ mock_install_webhook.return_value = (None, None) # Installation failed++ body = ReinstallWebhookRequest(+ resource=ResourceIdentifier(type=resource_type, id=resource_id)+ )++ # Act & Assert+ with pytest.raises(HTTPException) as exc_info:+ await reinstall_gitlab_webhook(body=body, user_id=user_id)++ assert exc_info.value.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR+ assert 'Failed to install webhook' in exc_info.value.detail++ @pytest.mark.asyncio+ @patch('server.routes.integration.gitlab.install_webhook_on_resource')+ @patch('server.routes.integration.gitlab.verify_webhook_conditions')+ @patch('server.routes.integration.gitlab.GitLabServiceImpl')+ @patch('server.routes.integration.gitlab.webhook_store')+ @patch('server.routes.integration.gitlab.isinstance')+ async def test_reinstall_webhook_group_resource(+ self,+ mock_isinstance,+ mock_webhook_store,+ mock_gitlab_service_impl,+ mock_verify_conditions,+ mock_install_webhook,+ mock_gitlab_service,+ mock_webhook,+ ):+ """Test reinstallation for a group resource."""+ # Arrange+ user_id = 'test_user_id'+ resource_id = 'group-333'+ resource_type = GitLabResourceType.GROUP++ mock_gitlab_service_impl.return_value = mock_gitlab_service+ mock_isinstance.return_value = True+ mock_webhook_store.reset_webhook_for_reinstallation_by_resource = AsyncMock(+ return_value=True+ )+ mock_webhook_store.get_webhook_by_resource_only = AsyncMock(+ return_value=mock_webhook+ )+ mock_verify_conditions.return_value = None+ mock_install_webhook.return_value = ('webhook-id-group', None)++ body = ReinstallWebhookRequest(+ resource=ResourceIdentifier(type=resource_type, id=resource_id)+ )++ # Act+ result = await reinstall_gitlab_webhook(body=body, user_id=user_id)++ # Assert+ assert result.success is True+ assert result.resource_id == resource_id+ assert result.resource_type == resource_type.value+ mock_webhook_store.reset_webhook_for_reinstallation_by_resource.assert_called_once_with(+ resource_type, resource_id, user_id+ )diff --git a/enterprise/tests/unit/storage/test_gitlab_webhook_store.py b/enterprise/tests/unit/storage/test_gitlab_webhook_store.pynew file mode 100644index 0000000000..56f55203a2--- /dev/null+++ b/enterprise/tests/unit/storage/test_gitlab_webhook_store.py@@ -0,0 +1,388 @@+"""Unit tests for GitlabWebhookStore."""++import pytest+from integrations.types import GitLabResourceType+from sqlalchemy import select+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine+from sqlalchemy.pool import StaticPool+from storage.base import Base+from storage.gitlab_webhook import GitlabWebhook+from storage.gitlab_webhook_store import GitlabWebhookStore+++async def async_engine():+ """Create an async SQLite engine for testing."""+ engine = create_async_engine(+ 'sqlite+aiosqlite:///:memory:',+ poolclass=StaticPool,+ connect_args={'check_same_thread': False},+ echo=False,+ )++ # Create all tables+ async with engine.begin() as conn:+ await conn.run_sync(Base.metadata.create_all)++ yield engine++ await engine.dispose()+++async def async_session_maker(async_engine):+ """Create an async session maker for testing."""+ return async_sessionmaker(async_engine, class_=AsyncSession, expire_on_commit=False)+++async def webhook_store(async_session_maker):+ """Create a GitlabWebhookStore instance for testing."""+ return GitlabWebhookStore(a_session_maker=async_session_maker)+++async def sample_webhooks(async_session_maker):+ """Create sample webhook records for testing."""+ async with async_session_maker() as session:+ # Create webhooks for user_1+ webhook1 = GitlabWebhook(+ project_id='project-1',+ group_id=None,+ user_id='user_1',+ webhook_exists=True,+ webhook_url='https://example.com/webhook',+ webhook_secret='secret-1',+ webhook_uuid='uuid-1',+ )+ webhook2 = GitlabWebhook(+ project_id='project-2',+ group_id=None,+ user_id='user_1',+ webhook_exists=True,+ webhook_url='https://example.com/webhook',+ webhook_secret='secret-2',+ webhook_uuid='uuid-2',+ )+ webhook3 = GitlabWebhook(+ project_id=None,+ group_id='group-1',+ user_id='user_1',+ webhook_exists=False, # Already marked for reinstallation+ webhook_url='https://example.com/webhook',+ webhook_secret='secret-3',+ webhook_uuid='uuid-3',+ )++ # Create webhook for user_2+ webhook4 = GitlabWebhook(+ project_id='project-3',+ group_id=None,+ user_id='user_2',+ webhook_exists=True,+ webhook_url='https://example.com/webhook',+ webhook_secret='secret-4',+ webhook_uuid='uuid-4',+ )++ session.add_all([webhook1, webhook2, webhook3, webhook4])+ await session.commit()++ # Refresh to get IDs (outside of begin() context)+ await session.refresh(webhook1)+ await session.refresh(webhook2)+ await session.refresh(webhook3)+ await session.refresh(webhook4)++ return [webhook1, webhook2, webhook3, webhook4]+++class TestGetWebhookByResourceOnly:+ """Test cases for get_webhook_by_resource_only method."""++ @pytest.mark.asyncio+ async def test_get_project_webhook_by_resource_only(+ self, webhook_store, async_session_maker, sample_webhooks+ ):+ """Test getting a project webhook by resource ID without user_id filter."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-1'++ # Act+ webhook = await webhook_store.get_webhook_by_resource_only(+ resource_type, resource_id+ )++ # Assert+ assert webhook is not None+ assert webhook.project_id == resource_id+ assert webhook.user_id == 'user_1'++ @pytest.mark.asyncio+ async def test_get_group_webhook_by_resource_only(+ self, webhook_store, async_session_maker, sample_webhooks+ ):+ """Test getting a group webhook by resource ID without user_id filter."""+ # Arrange+ resource_type = GitLabResourceType.GROUP+ resource_id = 'group-1'++ # Act+ webhook = await webhook_store.get_webhook_by_resource_only(+ resource_type, resource_id+ )++ # Assert+ assert webhook is not None+ assert webhook.group_id == resource_id+ assert webhook.user_id == 'user_1'++ @pytest.mark.asyncio+ async def test_get_webhook_by_resource_only_not_found(+ self, webhook_store, async_session_maker+ ):+ """Test getting a webhook that doesn't exist."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'non-existent-project'++ # Act+ webhook = await webhook_store.get_webhook_by_resource_only(+ resource_type, resource_id+ )++ # Assert+ assert webhook is None++ @pytest.mark.asyncio+ async def test_get_webhook_by_resource_only_organization_wide(+ self, webhook_store, async_session_maker, sample_webhooks+ ):+ """Test that webhook lookup works regardless of which user originally created it."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-3' # Created by user_2++ # Act+ webhook = await webhook_store.get_webhook_by_resource_only(+ resource_type, resource_id+ )++ # Assert+ assert webhook is not None+ assert webhook.project_id == resource_id+ # Should find webhook even though it was created by a different user+ assert webhook.user_id == 'user_2'+++class TestResetWebhookForReinstallationByResource:+ """Test cases for reset_webhook_for_reinstallation_by_resource method."""++ @pytest.mark.asyncio+ async def test_reset_project_webhook_by_resource(+ self, webhook_store, async_session_maker, sample_webhooks+ ):+ """Test resetting a project webhook by resource without user_id filter."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-1'+ updating_user_id = 'user_2' # Different user can reset it++ # Act+ result = await webhook_store.reset_webhook_for_reinstallation_by_resource(+ resource_type, resource_id, updating_user_id+ )++ # Assert+ assert result is True++ # Verify webhook was reset+ async with async_session_maker() as session:+ result_query = await session.execute(+ select(GitlabWebhook).where(GitlabWebhook.project_id == resource_id)+ )+ webhook = result_query.scalars().first()+ assert webhook.webhook_exists is False+ assert webhook.webhook_uuid is None+ assert (+ webhook.user_id == updating_user_id+ ) # Updated to track who modified it++ @pytest.mark.asyncio+ async def test_reset_group_webhook_by_resource(+ self, webhook_store, async_session_maker, sample_webhooks+ ):+ """Test resetting a group webhook by resource without user_id filter."""+ # Arrange+ resource_type = GitLabResourceType.GROUP+ resource_id = 'group-1'+ updating_user_id = 'user_2'++ # Act+ result = await webhook_store.reset_webhook_for_reinstallation_by_resource(+ resource_type, resource_id, updating_user_id+ )++ # Assert+ assert result is True++ # Verify webhook was reset+ async with async_session_maker() as session:+ result_query = await session.execute(+ select(GitlabWebhook).where(GitlabWebhook.group_id == resource_id)+ )+ webhook = result_query.scalars().first()+ assert webhook.webhook_exists is False+ assert webhook.webhook_uuid is None+ assert webhook.user_id == updating_user_id++ @pytest.mark.asyncio+ async def test_reset_webhook_by_resource_not_found(+ self, webhook_store, async_session_maker+ ):+ """Test resetting a webhook that doesn't exist."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'non-existent-project'+ updating_user_id = 'user_1'++ # Act+ result = await webhook_store.reset_webhook_for_reinstallation_by_resource(+ resource_type, resource_id, updating_user_id+ )++ # Assert+ assert result is False++ @pytest.mark.asyncio+ async def test_reset_webhook_by_resource_organization_wide(+ self, webhook_store, async_session_maker, sample_webhooks+ ):+ """Test that any user can reset a webhook regardless of original creator."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-3' # Created by user_2+ updating_user_id = 'user_1' # Different user resetting it++ # Act+ result = await webhook_store.reset_webhook_for_reinstallation_by_resource(+ resource_type, resource_id, updating_user_id+ )++ # Assert+ assert result is True++ # Verify webhook was reset and user_id updated+ async with async_session_maker() as session:+ result_query = await session.execute(+ select(GitlabWebhook).where(GitlabWebhook.project_id == resource_id)+ )+ webhook = result_query.scalars().first()+ assert webhook.webhook_exists is False+ assert webhook.user_id == updating_user_id+++class TestGetWebhooksByResources:+ """Test cases for get_webhooks_by_resources method."""++ @pytest.mark.asyncio+ async def test_get_webhooks_by_resources_projects_only(+ self, webhook_store, async_session_maker, sample_webhooks+ ):+ """Test bulk fetching webhooks for multiple projects."""+ # Arrange+ project_ids = ['project-1', 'project-2', 'project-3']+ group_ids: list[str] = []++ # Act+ project_map, group_map = await webhook_store.get_webhooks_by_resources(+ project_ids, group_ids+ )++ # Assert+ assert len(project_map) == 3+ assert 'project-1' in project_map+ assert 'project-2' in project_map+ assert 'project-3' in project_map+ assert len(group_map) == 0++ @pytest.mark.asyncio+ async def test_get_webhooks_by_resources_groups_only(+ self, webhook_store, async_session_maker, sample_webhooks+ ):+ """Test bulk fetching webhooks for multiple groups."""+ # Arrange+ project_ids: list[str] = []+ group_ids = ['group-1']++ # Act+ project_map, group_map = await webhook_store.get_webhooks_by_resources(+ project_ids, group_ids+ )++ # Assert+ assert len(project_map) == 0+ assert len(group_map) == 1+ assert 'group-1' in group_map++ @pytest.mark.asyncio+ async def test_get_webhooks_by_resources_mixed(+ self, webhook_store, async_session_maker, sample_webhooks+ ):+ """Test bulk fetching webhooks for both projects and groups."""+ # Arrange+ project_ids = ['project-1', 'project-2']+ group_ids = ['group-1']++ # Act+ project_map, group_map = await webhook_store.get_webhooks_by_resources(+ project_ids, group_ids+ )++ # Assert+ assert len(project_map) == 2+ assert len(group_map) == 1+ assert 'project-1' in project_map+ assert 'project-2' in project_map+ assert 'group-1' in group_map++ @pytest.mark.asyncio+ async def test_get_webhooks_by_resources_empty_lists(+ self, webhook_store, async_session_maker+ ):+ """Test bulk fetching with empty ID lists."""+ # Arrange+ project_ids: list[str] = []+ group_ids: list[str] = []++ # Act+ project_map, group_map = await webhook_store.get_webhooks_by_resources(+ project_ids, group_ids+ )++ # Assert+ assert len(project_map) == 0+ assert len(group_map) == 0++ @pytest.mark.asyncio+ async def test_get_webhooks_by_resources_partial_matches(+ self, webhook_store, async_session_maker, sample_webhooks+ ):+ """Test bulk fetching when some IDs don't exist."""+ # Arrange+ project_ids = ['project-1', 'non-existent-project']+ group_ids = ['group-1', 'non-existent-group']++ # Act+ project_map, group_map = await webhook_store.get_webhooks_by_resources(+ project_ids, group_ids+ )++ # Assert+ assert len(project_map) == 1+ assert 'project-1' in project_map+ assert 'non-existent-project' not in project_map+ assert len(group_map) == 1+ assert 'group-1' in group_map+ assert 'non-existent-group' not in group_mapdiff --git a/enterprise/tests/unit/sync/test_install_gitlab_webhooks.py b/enterprise/tests/unit/sync/test_install_gitlab_webhooks.pynew file mode 100644index 0000000000..3d8d91a965--- /dev/null+++ b/enterprise/tests/unit/sync/test_install_gitlab_webhooks.py@@ -0,0 +1,438 @@+"""Unit tests for install_gitlab_webhooks module."""++from unittest.mock import AsyncMock, MagicMock++import pytest+from integrations.gitlab.webhook_installation import (+ BreakLoopException,+ install_webhook_on_resource,+ verify_webhook_conditions,+)+from integrations.types import GitLabResourceType+from integrations.utils import GITLAB_WEBHOOK_URL+from storage.gitlab_webhook import GitlabWebhook, WebhookStatus+++def mock_gitlab_service():+ """Create a mock GitLab service."""+ service = MagicMock()+ service.check_resource_exists = AsyncMock(return_value=(True, None))+ service.check_user_has_admin_access_to_resource = AsyncMock(+ return_value=(True, None)+ )+ service.check_webhook_exists_on_resource = AsyncMock(return_value=(False, None))+ service.install_webhook = AsyncMock(return_value=('webhook-id-123', None))+ return service+++def mock_webhook_store():+ """Create a mock webhook store."""+ store = MagicMock()+ store.delete_webhook = AsyncMock()+ store.update_webhook = AsyncMock()+ return store+++def sample_webhook():+ """Create a sample webhook object."""+ webhook = MagicMock(spec=GitlabWebhook)+ webhook.user_id = 'test_user_id'+ webhook.webhook_exists = False+ webhook.webhook_uuid = None+ return webhook+++class TestVerifyWebhookConditions:+ """Test cases for verify_webhook_conditions function."""++ @pytest.mark.asyncio+ async def test_verify_conditions_all_pass(+ self, mock_gitlab_service, mock_webhook_store, sample_webhook+ ):+ """Test when all conditions are met for webhook installation."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-123'++ # Act+ # Should not raise any exception+ await verify_webhook_conditions(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ # Assert+ mock_gitlab_service.check_resource_exists.assert_called_once_with(+ resource_type, resource_id+ )+ mock_gitlab_service.check_user_has_admin_access_to_resource.assert_called_once_with(+ resource_type, resource_id+ )+ mock_gitlab_service.check_webhook_exists_on_resource.assert_called_once_with(+ resource_type, resource_id, GITLAB_WEBHOOK_URL+ )+ mock_webhook_store.delete_webhook.assert_not_called()++ @pytest.mark.asyncio+ async def test_verify_conditions_resource_does_not_exist(+ self, mock_gitlab_service, mock_webhook_store, sample_webhook+ ):+ """Test when resource does not exist."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-999'+ mock_gitlab_service.check_resource_exists = AsyncMock(+ return_value=(False, None)+ )++ # Act & Assert+ with pytest.raises(BreakLoopException):+ await verify_webhook_conditions(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ # Assert webhook is deleted+ mock_webhook_store.delete_webhook.assert_called_once_with(sample_webhook)++ @pytest.mark.asyncio+ async def test_verify_conditions_rate_limited_on_resource_check(+ self, mock_gitlab_service, mock_webhook_store, sample_webhook+ ):+ """Test when rate limited during resource existence check."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-123'+ mock_gitlab_service.check_resource_exists = AsyncMock(+ return_value=(False, WebhookStatus.RATE_LIMITED)+ )++ # Act & Assert+ with pytest.raises(BreakLoopException):+ await verify_webhook_conditions(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ # Should not delete webhook on rate limit+ mock_webhook_store.delete_webhook.assert_not_called()++ @pytest.mark.asyncio+ async def test_verify_conditions_user_no_admin_access(+ self, mock_gitlab_service, mock_webhook_store, sample_webhook+ ):+ """Test when user does not have admin access."""+ # Arrange+ resource_type = GitLabResourceType.GROUP+ resource_id = 'group-456'+ mock_gitlab_service.check_user_has_admin_access_to_resource = AsyncMock(+ return_value=(False, None)+ )++ # Act & Assert+ with pytest.raises(BreakLoopException):+ await verify_webhook_conditions(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ # Assert webhook is deleted+ mock_webhook_store.delete_webhook.assert_called_once_with(sample_webhook)++ @pytest.mark.asyncio+ async def test_verify_conditions_rate_limited_on_admin_check(+ self, mock_gitlab_service, mock_webhook_store, sample_webhook+ ):+ """Test when rate limited during admin access check."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-123'+ mock_gitlab_service.check_user_has_admin_access_to_resource = AsyncMock(+ return_value=(False, WebhookStatus.RATE_LIMITED)+ )++ # Act & Assert+ with pytest.raises(BreakLoopException):+ await verify_webhook_conditions(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ # Should not delete webhook on rate limit+ mock_webhook_store.delete_webhook.assert_not_called()++ @pytest.mark.asyncio+ async def test_verify_conditions_webhook_already_exists(+ self, mock_gitlab_service, mock_webhook_store, sample_webhook+ ):+ """Test when webhook already exists on resource."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-123'+ mock_gitlab_service.check_webhook_exists_on_resource = AsyncMock(+ return_value=(True, None)+ )++ # Act & Assert+ with pytest.raises(BreakLoopException):+ await verify_webhook_conditions(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ @pytest.mark.asyncio+ async def test_verify_conditions_rate_limited_on_webhook_check(+ self, mock_gitlab_service, mock_webhook_store, sample_webhook+ ):+ """Test when rate limited during webhook existence check."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-123'+ mock_gitlab_service.check_webhook_exists_on_resource = AsyncMock(+ return_value=(False, WebhookStatus.RATE_LIMITED)+ )++ # Act & Assert+ with pytest.raises(BreakLoopException):+ await verify_webhook_conditions(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ @pytest.mark.asyncio+ async def test_verify_conditions_updates_webhook_status_mismatch(+ self, mock_gitlab_service, mock_webhook_store, sample_webhook+ ):+ """Test that webhook status is updated when database and API don't match."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-123'+ sample_webhook.webhook_exists = True # DB says exists+ mock_gitlab_service.check_webhook_exists_on_resource = AsyncMock(+ return_value=(False, None) # API says doesn't exist+ )++ # Act+ # Should not raise BreakLoopException when webhook doesn't exist (allows installation)+ await verify_webhook_conditions(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ # Assert webhook status was updated to match API+ mock_webhook_store.update_webhook.assert_called_once_with(+ sample_webhook, {'webhook_exists': False}+ )+++class TestInstallWebhookOnResource:+ """Test cases for install_webhook_on_resource function."""++ @pytest.mark.asyncio+ async def test_install_webhook_success(+ self, mock_gitlab_service, mock_webhook_store, sample_webhook+ ):+ """Test successful webhook installation."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-123'++ # Act+ webhook_id, status = await install_webhook_on_resource(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ # Assert+ assert webhook_id == 'webhook-id-123'+ assert status is None+ mock_gitlab_service.install_webhook.assert_called_once()+ mock_webhook_store.update_webhook.assert_called_once()+ # Verify update_webhook was called with correct fields (using keyword arguments)+ call_args = mock_webhook_store.update_webhook.call_args+ assert call_args[1]['webhook'] == sample_webhook+ update_fields = call_args[1]['update_fields']+ assert update_fields['webhook_exists'] is True+ assert update_fields['webhook_url'] == GITLAB_WEBHOOK_URL+ assert 'webhook_secret' in update_fields+ assert 'webhook_uuid' in update_fields+ assert 'scopes' in update_fields++ @pytest.mark.asyncio+ async def test_install_webhook_group_resource(+ self, mock_gitlab_service, mock_webhook_store, sample_webhook+ ):+ """Test webhook installation for a group resource."""+ # Arrange+ resource_type = GitLabResourceType.GROUP+ resource_id = 'group-456'++ # Act+ webhook_id, status = await install_webhook_on_resource(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ # Assert+ assert webhook_id == 'webhook-id-123'+ # Verify install_webhook was called with GROUP type+ call_args = mock_gitlab_service.install_webhook.call_args+ assert call_args[1]['resource_type'] == resource_type+ assert call_args[1]['resource_id'] == resource_id++ @pytest.mark.asyncio+ async def test_install_webhook_rate_limited(+ self, mock_gitlab_service, mock_webhook_store, sample_webhook+ ):+ """Test when installation is rate limited."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-123'+ mock_gitlab_service.install_webhook = AsyncMock(+ return_value=(None, WebhookStatus.RATE_LIMITED)+ )++ # Act & Assert+ with pytest.raises(BreakLoopException):+ await install_webhook_on_resource(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ # Should not update webhook on rate limit+ mock_webhook_store.update_webhook.assert_not_called()++ @pytest.mark.asyncio+ async def test_install_webhook_installation_fails(+ self, mock_gitlab_service, mock_webhook_store, sample_webhook+ ):+ """Test when webhook installation fails."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-123'+ mock_gitlab_service.install_webhook = AsyncMock(return_value=(None, None))++ # Act+ webhook_id, status = await install_webhook_on_resource(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ # Assert+ assert webhook_id is None+ assert status is None+ # Should not update webhook when installation fails+ mock_webhook_store.update_webhook.assert_not_called()++ @pytest.mark.asyncio+ async def test_install_webhook_generates_unique_secrets(+ self, mock_gitlab_service, mock_webhook_store, sample_webhook+ ):+ """Test that unique webhook secrets and UUIDs are generated."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-123'++ # Act - First call+ webhook_id1, _ = await install_webhook_on_resource(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ # Capture first call's values before resetting+ call1_secret = mock_webhook_store.update_webhook.call_args_list[0][1][+ 'update_fields'+ ]['webhook_secret']+ call1_uuid = mock_webhook_store.update_webhook.call_args_list[0][1][+ 'update_fields'+ ]['webhook_uuid']++ # Reset mocks and call again+ mock_gitlab_service.install_webhook.reset_mock()+ mock_webhook_store.update_webhook.reset_mock()++ # Act - Second call+ webhook_id2, _ = await install_webhook_on_resource(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ # Capture second call's values+ call2_secret = mock_webhook_store.update_webhook.call_args_list[0][1][+ 'update_fields'+ ]['webhook_secret']+ call2_uuid = mock_webhook_store.update_webhook.call_args_list[0][1][+ 'update_fields'+ ]['webhook_uuid']++ # Assert - Secrets and UUIDs should be different+ assert call1_secret != call2_secret+ assert call1_uuid != call2_uuid++ @pytest.mark.asyncio+ async def test_install_webhook_uses_correct_webhook_name_and_url(+ self, mock_gitlab_service, mock_webhook_store, sample_webhook+ ):+ """Test that correct webhook name and URL are used."""+ # Arrange+ resource_type = GitLabResourceType.PROJECT+ resource_id = 'project-123'++ # Act+ await install_webhook_on_resource(+ gitlab_service=mock_gitlab_service,+ resource_type=resource_type,+ resource_id=resource_id,+ webhook_store=mock_webhook_store,+ webhook=sample_webhook,+ )++ # Assert+ call_args = mock_gitlab_service.install_webhook.call_args+ assert call_args[1]['webhook_name'] == 'OpenHands Resolver'+ assert call_args[1]['webhook_url'] == GITLAB_WEBHOOK_URLdiff --git a/frontend/__tests__/components/features/settings/gitlab-webhook-manager-state.test.tsx b/frontend/__tests__/components/features/settings/gitlab-webhook-manager-state.test.tsxnew file mode 100644index 0000000000..b854b0cd7a--- /dev/null+++ b/frontend/__tests__/components/features/settings/gitlab-webhook-manager-state.test.tsx@@ -0,0 +1,49 @@+import { render, screen } from "@testing-library/react";+import { describe, expect, it, vi } from "vitest";+import { GitLabWebhookManagerState } from "#/components/features/settings/git-settings/gitlab-webhook-manager-state";+import { I18nKey } from "#/i18n/declaration";++// Mock react-i18next+vi.mock("react-i18next", () => ({+ useTranslation: () => ({+ t: (key: string) => key,+ }),+}));++describe("GitLabWebhookManagerState", () => {+ it("should render title and message with translated keys", () => {+ // Arrange+ const props = {+ titleKey: I18nKey.GITLAB$WEBHOOK_MANAGER_TITLE,+ messageKey: I18nKey.GITLAB$WEBHOOK_MANAGER_LOADING,+ };++ // Act+ render(<GitLabWebhookManagerState {...props} />);++ // Assert+ expect(+ screen.getByText(I18nKey.GITLAB$WEBHOOK_MANAGER_TITLE),+ ).toBeInTheDocument();+ expect(+ screen.getByText(I18nKey.GITLAB$WEBHOOK_MANAGER_LOADING),+ ).toBeInTheDocument();+ });++ it("should apply custom className to container", () => {+ // Arrange+ const customClassName = "custom-container-class";+ const props = {+ titleKey: I18nKey.GITLAB$WEBHOOK_MANAGER_TITLE,+ messageKey: I18nKey.GITLAB$WEBHOOK_MANAGER_LOADING,+ className: customClassName,+ };++ // Act+ const { container } = render(<GitLabWebhookManagerState {...props} />);++ // Assert+ const containerElement = container.firstChild as HTMLElement;+ expect(containerElement).toHaveClass(customClassName);+ });+});diff --git a/frontend/__tests__/components/features/settings/gitlab-webhook-manager.test.tsx b/frontend/__tests__/components/features/settings/gitlab-webhook-manager.test.tsxnew file mode 100644index 0000000000..12e5e72970--- /dev/null+++ b/frontend/__tests__/components/features/settings/gitlab-webhook-manager.test.tsx@@ -0,0 +1,416 @@+import { render, screen, waitFor } from "@testing-library/react";+import userEvent from "@testing-library/user-event";+import { describe, expect, it, vi, beforeEach } from "vitest";+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";+import { GitLabWebhookManager } from "#/components/features/settings/git-settings/gitlab-webhook-manager";+import { integrationService } from "#/api/integration-service/integration-service.api";+import type {+ GitLabResource,+ ResourceInstallationResult,+} from "#/api/integration-service/integration-service.types";+import * as ToastHandlers from "#/utils/custom-toast-handlers";++// Mock react-i18next+vi.mock("react-i18next", () => ({+ useTranslation: () => ({+ t: (key: string) => key,+ }),+}));++// Mock toast handlers+vi.mock("#/utils/custom-toast-handlers", () => ({+ displaySuccessToast: vi.fn(),+ displayErrorToast: vi.fn(),+}));++const mockResources: GitLabResource[] = [+ {+ id: "1",+ name: "Test Project",+ full_path: "user/test-project",+ type: "project",+ webhook_installed: false,+ webhook_uuid: null,+ last_synced: null,+ },+ {+ id: "10",+ name: "Test Group",+ full_path: "test-group",+ type: "group",+ webhook_installed: true,+ webhook_uuid: "uuid-123",+ last_synced: "2024-01-01T00:00:00Z",+ },+];++describe("GitLabWebhookManager", () => {+ const queryClient = new QueryClient({+ defaultOptions: {+ queries: { retry: false },+ mutations: { retry: false },+ },+ });++ beforeEach(() => {+ queryClient.clear();+ vi.clearAllMocks();+ });++ const renderComponent = () => {+ return render(+ <QueryClientProvider client={queryClient}>+ <GitLabWebhookManager />+ </QueryClientProvider>,+ );+ };++ it("should display loading state when fetching resources", async () => {+ // Arrange+ vi.spyOn(integrationService, "getGitLabResources").mockImplementation(+ () => new Promise(() => {}), // Never resolves+ );++ // Act+ renderComponent();++ // Assert+ expect(+ screen.getByText("GITLAB$WEBHOOK_MANAGER_LOADING"),+ ).toBeInTheDocument();+ });++ it("should display error state when fetching fails", async () => {+ // Arrange+ vi.spyOn(integrationService, "getGitLabResources").mockRejectedValue(+ new Error("Failed to fetch"),+ );++ // Act+ renderComponent();++ // Assert+ await waitFor(() => {+ expect(+ screen.getByText("GITLAB$WEBHOOK_MANAGER_ERROR"),+ ).toBeInTheDocument();+ });+ });++ it("should display no resources message when list is empty", async () => {+ // Arrange+ vi.spyOn(integrationService, "getGitLabResources").mockResolvedValue({+ resources: [],+ });++ // Act+ renderComponent();++ // Assert+ await waitFor(() => {+ expect(+ screen.getByText("GITLAB$WEBHOOK_MANAGER_NO_RESOURCES"),+ ).toBeInTheDocument();+ });+ });++ it("should display resources table when resources are available", async () => {+ // Arrange+ vi.spyOn(integrationService, "getGitLabResources").mockResolvedValue({+ resources: mockResources,+ });++ // Act+ renderComponent();++ // Assert+ await waitFor(() => {+ expect(screen.getByText("Test Project")).toBeInTheDocument();+ expect(screen.getByText("Test Group")).toBeInTheDocument();+ });++ expect(screen.getByText("user/test-project")).toBeInTheDocument();+ expect(screen.getByText("test-group")).toBeInTheDocument();+ });++ it("should display correct resource types in table", async () => {+ // Arrange+ vi.spyOn(integrationService, "getGitLabResources").mockResolvedValue({+ resources: mockResources,+ });++ // Act+ renderComponent();++ // Assert+ await waitFor(() => {+ const projectType = screen.getByText("project");+ const groupType = screen.getByText("group");+ expect(projectType).toBeInTheDocument();+ expect(groupType).toBeInTheDocument();+ });+ });++ it("should disable reinstall button when webhook is already installed", async () => {+ // Arrange+ vi.spyOn(integrationService, "getGitLabResources").mockResolvedValue({+ resources: [+ {+ id: "10",+ name: "Test Group",+ full_path: "test-group",+ type: "group",+ webhook_installed: true,+ webhook_uuid: "uuid-123",+ last_synced: null,+ },+ ],+ });++ // Act+ renderComponent();++ // Assert+ await waitFor(() => {+ const reinstallButton = screen.getByTestId(+ "reinstall-webhook-button-group:10",+ );+ expect(reinstallButton).toBeDisabled();+ });+ });++ it("should enable reinstall button when webhook is not installed", async () => {+ // Arrange+ vi.spyOn(integrationService, "getGitLabResources").mockResolvedValue({+ resources: [+ {+ id: "1",+ name: "Test Project",+ full_path: "user/test-project",+ type: "project",+ webhook_installed: false,+ webhook_uuid: null,+ last_synced: null,+ },+ ],+ });++ // Act+ renderComponent();++ // Assert+ await waitFor(() => {+ const reinstallButton = screen.getByTestId(+ "reinstall-webhook-button-project:1",+ );+ expect(reinstallButton).not.toBeDisabled();+ });+ });++ it("should call reinstall service when reinstall button is clicked", async () => {+ // Arrange+ const user = userEvent.setup();+ const reinstallSpy = vi.spyOn(integrationService, "reinstallGitLabWebhook");++ vi.spyOn(integrationService, "getGitLabResources").mockResolvedValue({+ resources: [+ {+ id: "1",+ name: "Test Project",+ full_path: "user/test-project",+ type: "project",+ webhook_installed: false,+ webhook_uuid: null,+ last_synced: null,+ },+ ],+ });++ // Act+ renderComponent();+ const reinstallButton = await screen.findByTestId(+ "reinstall-webhook-button-project:1",+ );+ await user.click(reinstallButton);++ // Assert+ await waitFor(() => {+ expect(reinstallSpy).toHaveBeenCalledWith({+ resource: {+ type: "project",+ id: "1",+ },+ });+ });+ });++ it("should show loading state on button during reinstallation", async () => {+ // Arrange+ const user = userEvent.setup();+ let resolveReinstall: (value: ResourceInstallationResult) => void;+ const reinstallPromise = new Promise<ResourceInstallationResult>(+ (resolve) => {+ resolveReinstall = resolve;+ },+ );++ vi.spyOn(integrationService, "reinstallGitLabWebhook").mockReturnValue(+ reinstallPromise,+ );++ vi.spyOn(integrationService, "getGitLabResources").mockResolvedValue({+ resources: [+ {+ id: "1",+ name: "Test Project",+ full_path: "user/test-project",+ type: "project",+ webhook_installed: false,+ webhook_uuid: null,+ last_synced: null,+ },+ ],+ });++ // Act+ renderComponent();+ const reinstallButton = await screen.findByTestId(+ "reinstall-webhook-button-project:1",+ );+ await user.click(reinstallButton);++ // Assert+ await waitFor(() => {+ expect(+ screen.getByText("GITLAB$WEBHOOK_REINSTALLING"),+ ).toBeInTheDocument();+ });++ // Cleanup+ resolveReinstall!({+ resource_id: "1",+ resource_type: "project",+ success: true,+ error: null,+ });+ });++ it("should display error message when reinstallation fails", async () => {+ // Arrange+ const user = userEvent.setup();+ const errorMessage = "Permission denied";+ vi.spyOn(integrationService, "reinstallGitLabWebhook").mockResolvedValue({+ resource_id: "1",+ resource_type: "project",+ success: false,+ error: errorMessage,+ });++ vi.spyOn(integrationService, "getGitLabResources").mockResolvedValue({+ resources: [+ {+ id: "1",+ name: "Test Project",+ full_path: "user/test-project",+ type: "project",+ webhook_installed: false,+ webhook_uuid: null,+ last_synced: null,+ },+ ],+ });++ // Act+ renderComponent();+ const reinstallButton = await screen.findByTestId(+ "reinstall-webhook-button-project:1",+ );+ await user.click(reinstallButton);++ // Assert+ await waitFor(() => {+ expect(screen.getByText(errorMessage)).toBeInTheDocument();+ });+ });++ it("should display success toast when reinstallation succeeds", async () => {+ // Arrange+ const user = userEvent.setup();+ const displaySuccessToastSpy = vi.spyOn(+ ToastHandlers,+ "displaySuccessToast",+ );++ vi.spyOn(integrationService, "reinstallGitLabWebhook").mockResolvedValue({+ resource_id: "1",+ resource_type: "project",+ success: true,+ error: null,+ });++ vi.spyOn(integrationService, "getGitLabResources").mockResolvedValue({+ resources: [+ {+ id: "1",+ name: "Test Project",+ full_path: "user/test-project",+ type: "project",+ webhook_installed: false,+ webhook_uuid: null,+ last_synced: null,+ },+ ],+ });++ // Act+ renderComponent();+ const reinstallButton = await screen.findByTestId(+ "reinstall-webhook-button-project:1",+ );+ await user.click(reinstallButton);++ // Assert+ await waitFor(() => {+ expect(displaySuccessToastSpy).toHaveBeenCalledWith(+ "GITLAB$WEBHOOK_REINSTALL_SUCCESS",+ );+ });+ });++ it("should display error toast when reinstallation throws error", async () => {+ // Arrange+ const user = userEvent.setup();+ const displayErrorToastSpy = vi.spyOn(ToastHandlers, "displayErrorToast");+ const errorMessage = "Network error";++ vi.spyOn(integrationService, "reinstallGitLabWebhook").mockRejectedValue(+ new Error(errorMessage),+ );++ vi.spyOn(integrationService, "getGitLabResources").mockResolvedValue({+ resources: [+ {+ id: "1",+ name: "Test Project",+ full_path: "user/test-project",+ type: "project",+ webhook_installed: false,+ webhook_uuid: null,+ last_synced: null,+ },+ ],+ });++ // Act+ renderComponent();+ const reinstallButton = await screen.findByTestId(+ "reinstall-webhook-button-project:1",+ );+ await user.click(reinstallButton);++ // Assert+ await waitFor(() => {+ expect(displayErrorToastSpy).toHaveBeenCalledWith(errorMessage);+ });+ });+});diff --git a/frontend/__tests__/components/features/settings/webhook-status-badge.test.tsx b/frontend/__tests__/components/features/settings/webhook-status-badge.test.tsxnew file mode 100644index 0000000000..361c0d2590--- /dev/null+++ b/frontend/__tests__/components/features/settings/webhook-status-badge.test.tsx@@ -0,0 +1,97 @@+import { render, screen } from "@testing-library/react";+import { describe, expect, it, vi } from "vitest";+import { WebhookStatusBadge } from "#/components/features/settings/git-settings/webhook-status-badge";++// Mock react-i18next+vi.mock("react-i18next", () => ({+ useTranslation: () => ({+ t: (key: string) => key,+ }),+}));++describe("WebhookStatusBadge", () => {+ it("should display installed status when webhook is installed", () => {+ // Arrange+ const props = {+ webhookInstalled: true,+ };++ // Act+ render(<WebhookStatusBadge {...props} />);++ // Assert+ const badge = screen.getByText("GITLAB$WEBHOOK_STATUS_INSTALLED");+ expect(badge).toBeInTheDocument();+ });++ it("should display not installed status when webhook is not installed", () => {+ // Arrange+ const props = {+ webhookInstalled: false,+ };++ // Act+ render(<WebhookStatusBadge {...props} />);++ // Assert+ const badge = screen.getByText("GITLAB$WEBHOOK_STATUS_NOT_INSTALLED");+ expect(badge).toBeInTheDocument();+ });++ it("should display installed status when installation result is successful", () => {+ // Arrange+ const props = {+ webhookInstalled: false,+ installationResult: {+ success: true,+ error: null,+ },+ };++ // Act+ render(<WebhookStatusBadge {...props} />);++ // Assert+ const badge = screen.getByText("GITLAB$WEBHOOK_STATUS_INSTALLED");+ expect(badge).toBeInTheDocument();+ });++ it("should display failed status when installation result has error", () => {+ // Arrange+ const props = {+ webhookInstalled: false,+ installationResult: {+ success: false,+ error: "Installation failed",+ },+ };++ // Act+ render(<WebhookStatusBadge {...props} />);++ // Assert+ const badge = screen.getByText("GITLAB$WEBHOOK_STATUS_FAILED");+ expect(badge).toBeInTheDocument();+ });++ it("should show error message when installation fails", () => {+ // Arrange+ const errorMessage = "Permission denied";+ const props = {+ webhookInstalled: false,+ installationResult: {+ success: false,+ error: errorMessage,+ },+ };++ // Act+ render(<WebhookStatusBadge {...props} />);++ // Assert+ const badgeContainer = screen.getByText(+ "GITLAB$WEBHOOK_STATUS_FAILED",+ ).parentElement;+ expect(badgeContainer).toHaveAttribute("title", errorMessage);+ });+});diff --git a/frontend/__tests__/routes/git-settings.test.tsx b/frontend/__tests__/routes/git-settings.test.tsxindex 6c0875f5a9..200e08bcb1 100644--- a/frontend/__tests__/routes/git-settings.test.tsx+++ b/frontend/__tests__/routes/git-settings.test.tsx@@ -13,6 +13,7 @@ import { MOCK_DEFAULT_USER_SETTINGS } from "#/mocks/handlers";import { GetConfigResponse } from "#/api/option-service/option.types";import * as ToastHandlers from "#/utils/custom-toast-handlers";import { SecretsService } from "#/api/secrets-service";+import { integrationService } from "#/api/integration-service/integration-service.api";const VALID_OSS_CONFIG: GetConfigResponse = {APP_MODE: "oss",@@ -63,6 +64,15 @@ const renderGitSettingsScreen = () => {GITLAB$HOST_LABEL: "GitLab Host",BITBUCKET$TOKEN_LABEL: "Bitbucket Token",BITBUCKET$HOST_LABEL: "Bitbucket Host",+ SETTINGS$GITLAB: "GitLab",+ COMMON$STATUS: "Status",+ STATUS$CONNECTED: "Connected",+ SETTINGS$GITLAB_NOT_CONNECTED: "Not Connected",+ SETTINGS$GITLAB_REINSTALL_WEBHOOK: "Reinstall Webhook",+ SETTINGS$GITLAB_INSTALLING_WEBHOOK:+ "Installing GitLab webhook, please wait a few minutes.",+ SETTINGS$SAVING: "Saving...",+ ERROR$GENERIC: "An error occurred",},},},@@ -356,7 +366,9 @@ describe("Form submission", () => {renderGitSettingsScreen();- const azureDevOpsInput = await screen.findByTestId("azure-devops-token-input");+ const azureDevOpsInput = await screen.findByTestId(+ "azure-devops-token-input",+ );const submit = await screen.findByTestId("submit-button");await userEvent.type(azureDevOpsInput, "test-token");@@ -560,3 +572,101 @@ describe("Status toasts", () => {expect(displayErrorToastSpy).toHaveBeenCalled();});});++describe("GitLab Webhook Manager Integration", () => {+ it("should not render GitLab webhook manager in OSS mode", async () => {+ // Arrange+ const getConfigSpy = vi.spyOn(OptionService, "getConfig");+ getConfigSpy.mockResolvedValue(VALID_OSS_CONFIG);++ // Act+ renderGitSettingsScreen();+ await screen.findByTestId("git-settings-screen");++ // Assert+ await waitFor(() => {+ expect(+ screen.queryByText("GITLAB$WEBHOOK_MANAGER_TITLE"),+ ).not.toBeInTheDocument();+ });+ });++ it("should not render GitLab webhook manager in SaaS mode without APP_SLUG", async () => {+ // Arrange+ const getConfigSpy = vi.spyOn(OptionService, "getConfig");+ getConfigSpy.mockResolvedValue(VALID_SAAS_CONFIG);++ // Act+ renderGitSettingsScreen();+ await screen.findByTestId("git-settings-screen");++ // Assert+ await waitFor(() => {+ expect(+ screen.queryByText("GITLAB$WEBHOOK_MANAGER_TITLE"),+ ).not.toBeInTheDocument();+ });+ });++ it("should not render GitLab webhook manager when token is not set", async () => {+ // Arrange+ const getConfigSpy = vi.spyOn(OptionService, "getConfig");+ const getSettingsSpy = vi.spyOn(SettingsService, "getSettings");++ getConfigSpy.mockResolvedValue({+ ...VALID_SAAS_CONFIG,+ APP_SLUG: "test-slug",+ });+ getSettingsSpy.mockResolvedValue({+ ...MOCK_DEFAULT_USER_SETTINGS,+ provider_tokens_set: {},+ });++ // Act+ renderGitSettingsScreen();+ await screen.findByTestId("git-settings-screen");++ // Assert+ await waitFor(() => {+ expect(+ screen.queryByText("GITLAB$WEBHOOK_MANAGER_TITLE"),+ ).not.toBeInTheDocument();+ });+ });++ it("should render GitLab webhook manager when token is set", async () => {+ // Arrange+ const getConfigSpy = vi.spyOn(OptionService, "getConfig");+ const getSettingsSpy = vi.spyOn(SettingsService, "getSettings");+ const getResourcesSpy = vi.spyOn(+ integrationService,+ "getGitLabResources",+ );++ getConfigSpy.mockResolvedValue({+ ...VALID_SAAS_CONFIG,+ APP_SLUG: "test-slug",+ });+ getSettingsSpy.mockResolvedValue({+ ...MOCK_DEFAULT_USER_SETTINGS,+ provider_tokens_set: {+ gitlab: null,+ },+ });+ getResourcesSpy.mockResolvedValue({+ resources: [],+ });++ // Act+ renderGitSettingsScreen();+ await screen.findByTestId("git-settings-screen");++ // Assert+ await waitFor(() => {+ expect(+ screen.getByText("GITLAB$WEBHOOK_MANAGER_TITLE"),+ ).toBeInTheDocument();+ expect(getResourcesSpy).toHaveBeenCalled();+ });+ });+});diff --git a/frontend/src/api/integration-service/integration-service.api.ts b/frontend/src/api/integration-service/integration-service.api.tsnew file mode 100644index 0000000000..38e97ffaf8--- /dev/null+++ b/frontend/src/api/integration-service/integration-service.api.ts@@ -0,0 +1,38 @@+import { openHands } from "../open-hands-axios";+import {+ GitLabResourcesResponse,+ ReinstallWebhookRequest,+ ResourceIdentifier,+ ResourceInstallationResult,+} from "./integration-service.types";++export const integrationService = {+ /**+ * Get all GitLab projects and groups where the user has admin access+ * @returns Promise with list of resources and their webhook status+ */+ getGitLabResources: async (): Promise<GitLabResourcesResponse> => {+ const { data } = await openHands.get<GitLabResourcesResponse>(+ "/integration/gitlab/resources",+ );+ return data;+ },++ /**+ * Reinstall webhook on a specific GitLab resource+ * @param resource - Resource to reinstall webhook on+ * @returns Promise with installation result+ */+ reinstallGitLabWebhook: async ({+ resource,+ }: {+ resource: ResourceIdentifier;+ }): Promise<ResourceInstallationResult> => {+ const requestBody: ReinstallWebhookRequest = { resource };+ const { data } = await openHands.post<ResourceInstallationResult>(+ "/integration/gitlab/reinstall-webhook",+ requestBody,+ );+ return data;+ },+};diff --git a/frontend/src/api/integration-service/integration-service.types.ts b/frontend/src/api/integration-service/integration-service.types.tsnew file mode 100644index 0000000000..7d8c6ffde0--- /dev/null+++ b/frontend/src/api/integration-service/integration-service.types.ts@@ -0,0 +1,29 @@+export interface GitLabResource {+ id: string;+ name: string;+ full_path: string;+ type: "project" | "group";+ webhook_installed: boolean;+ webhook_uuid: string | null;+ last_synced: string | null;+}++export interface GitLabResourcesResponse {+ resources: GitLabResource[];+}++export interface ResourceIdentifier {+ type: "project" | "group";+ id: string;+}++export interface ReinstallWebhookRequest {+ resource: ResourceIdentifier;+}++export interface ResourceInstallationResult {+ resource_id: string;+ resource_type: string;+ success: boolean;+ error: string | null;+}diff --git a/frontend/src/components/features/settings/git-settings/gitlab-webhook-manager-state.tsx b/frontend/src/components/features/settings/git-settings/gitlab-webhook-manager-state.tsxnew file mode 100644index 0000000000..1ea105769e--- /dev/null+++ b/frontend/src/components/features/settings/git-settings/gitlab-webhook-manager-state.tsx@@ -0,0 +1,31 @@+import { useTranslation } from "react-i18next";+import { I18nKey } from "#/i18n/declaration";+import { cn } from "#/utils/utils";+import { Typography } from "#/ui/typography";++interface GitLabWebhookManagerStateProps {+ className?: string;+ titleKey: I18nKey;+ messageKey: I18nKey;+ messageColor?: string;+}++export function GitLabWebhookManagerState({+ className,+ titleKey,+ messageKey,+ messageColor = "text-gray-400",+}: GitLabWebhookManagerStateProps) {+ const { t } = useTranslation();++ return (+ <div className={cn("flex flex-col gap-4", className)}>+ <Typography.H3 className="text-lg font-medium text-white">+ {t(titleKey)}+ </Typography.H3>+ <Typography.Text className={cn("text-sm", messageColor)}>+ {t(messageKey)}+ </Typography.Text>+ </div>+ );+}diff --git a/frontend/src/components/features/settings/git-settings/gitlab-webhook-manager.tsx b/frontend/src/components/features/settings/git-settings/gitlab-webhook-manager.tsxnew file mode 100644index 0000000000..38749645a8--- /dev/null+++ b/frontend/src/components/features/settings/git-settings/gitlab-webhook-manager.tsx@@ -0,0 +1,199 @@+import React, { useState } from "react";+import { useTranslation } from "react-i18next";+import { I18nKey } from "#/i18n/declaration";+import { useGitLabResources } from "#/hooks/query/use-gitlab-resources-list";+import { useReinstallGitLabWebhook } from "#/hooks/mutation/use-reinstall-gitlab-webhook";+import { BrandButton } from "#/components/features/settings/brand-button";+import type { GitLabResource } from "#/api/integration-service/integration-service.types";+import { cn } from "#/utils/utils";+import { Typography } from "#/ui/typography";+import { WebhookStatusBadge } from "./webhook-status-badge";+import { GitLabWebhookManagerState } from "./gitlab-webhook-manager-state";++interface GitLabWebhookManagerProps {+ className?: string;+}++export function GitLabWebhookManager({ className }: GitLabWebhookManagerProps) {+ const { t } = useTranslation();+ const [installingResource, setInstallingResource] = useState<string | null>(+ null,+ );+ const [installationResults, setInstallationResults] = useState<+ Map<string, { success: boolean; error: string | null }>+ >(new Map());++ const { data, isLoading, isError } = useGitLabResources(true);+ const reinstallMutation = useReinstallGitLabWebhook();++ const resources = data?.resources || [];++ const handleReinstall = async (resource: GitLabResource) => {+ const key = `${resource.type}:${resource.id}`;+ setInstallingResource(key);++ // Clear previous result for this resource+ const newResults = new Map(installationResults);+ newResults.delete(key);+ setInstallationResults(newResults);++ try {+ const result = await reinstallMutation.mutateAsync({+ type: resource.type,+ id: resource.id,+ });++ // Store result for display+ const resultsMap = new Map(installationResults);+ resultsMap.set(key, {+ success: result.success,+ error: result.error,+ });+ setInstallationResults(resultsMap);+ } catch (error: unknown) {+ // Store error result+ const resultsMap = new Map(installationResults);+ const errorMessage =+ error instanceof Error+ ? error.message+ : t(I18nKey.GITLAB$WEBHOOK_REINSTALL_FAILED);+ resultsMap.set(key, {+ success: false,+ error: errorMessage,+ });+ setInstallationResults(resultsMap);+ } finally {+ setInstallingResource(null);+ }+ };++ const getResourceKey = (resource: GitLabResource) =>+ `${resource.type}:${resource.id}`;++ if (isLoading) {+ return (+ <GitLabWebhookManagerState+ className={className}+ titleKey={I18nKey.GITLAB$WEBHOOK_MANAGER_TITLE}+ messageKey={I18nKey.GITLAB$WEBHOOK_MANAGER_LOADING}+ />+ );+ }++ if (isError) {+ return (+ <GitLabWebhookManagerState+ className={className}+ titleKey={I18nKey.GITLAB$WEBHOOK_MANAGER_TITLE}+ messageKey={I18nKey.GITLAB$WEBHOOK_MANAGER_ERROR}+ messageColor="text-red-400"+ />+ );+ }++ if (resources.length === 0) {+ return (+ <GitLabWebhookManagerState+ className={className}+ titleKey={I18nKey.GITLAB$WEBHOOK_MANAGER_TITLE}+ messageKey={I18nKey.GITLAB$WEBHOOK_MANAGER_NO_RESOURCES}+ />+ );+ }++ return (+ <div className={cn("flex flex-col gap-4", className)}>+ <div className="flex items-center justify-between">+ <Typography.H3 className="text-lg font-medium text-white">+ {t(I18nKey.GITLAB$WEBHOOK_MANAGER_TITLE)}+ </Typography.H3>+ </div>++ <Typography.Text className="text-sm text-gray-400">+ {t(I18nKey.GITLAB$WEBHOOK_MANAGER_DESCRIPTION)}+ </Typography.Text>++ <div className="border border-neutral-700 rounded-lg overflow-hidden">+ <table className="w-full">+ <thead className="bg-neutral-800">+ <tr>+ <th className="px-4 py-3 text-left text-xs font-medium text-gray-400 uppercase tracking-wider">+ {t(I18nKey.GITLAB$WEBHOOK_COLUMN_RESOURCE)}+ </th>+ <th className="px-4 py-3 text-left text-xs font-medium text-gray-400 uppercase tracking-wider">+ {t(I18nKey.GITLAB$WEBHOOK_COLUMN_TYPE)}+ </th>+ <th className="px-4 py-3 text-left text-xs font-medium text-gray-400 uppercase tracking-wider">+ {t(I18nKey.GITLAB$WEBHOOK_COLUMN_STATUS)}+ </th>+ <th className="px-4 py-3 text-left text-xs font-medium text-gray-400 uppercase tracking-wider">+ {t(I18nKey.GITLAB$WEBHOOK_COLUMN_ACTION)}+ </th>+ </tr>+ </thead>+ <tbody className="divide-y divide-neutral-700">+ {resources.map((resource) => {+ const key = getResourceKey(resource);+ const result = installationResults.get(key);+ const isInstalling = installingResource === key;++ return (+ <tr+ key={key}+ className="hover:bg-neutral-800/50 transition-colors"+ >+ <td className="px-4 py-3">+ <div className="flex flex-col">+ <Typography.Text className="text-sm font-medium text-white">+ {resource.name}+ </Typography.Text>+ <Typography.Text className="text-xs text-gray-400">+ {resource.full_path}+ </Typography.Text>+ </div>+ </td>+ <td className="px-4 py-3">+ <Typography.Text className="text-sm text-gray-300 capitalize">+ {resource.type}+ </Typography.Text>+ </td>+ <td className="px-4 py-3">+ <div className="flex flex-col gap-1">+ <WebhookStatusBadge+ webhookInstalled={resource.webhook_installed}+ installationResult={result}+ />+ {result?.error && (+ <Typography.Text className="text-xs text-red-400">+ {result.error}+ </Typography.Text>+ )}+ </div>+ </td>+ <td className="px-4 py-3">+ <BrandButton+ type="button"+ variant="primary"+ onClick={() => handleReinstall(resource)}+ isDisabled={+ installingResource !== null ||+ resource.webhook_installed ||+ result?.success === true+ }+ className="cursor-pointer"+ testId={`reinstall-webhook-button-${key}`}+ >+ {isInstalling+ ? t(I18nKey.GITLAB$WEBHOOK_REINSTALLING)+ : t(I18nKey.GITLAB$WEBHOOK_REINSTALL)}+ </BrandButton>+ </td>+ </tr>+ );+ })}+ </tbody>+ </table>+ </div>+ </div>+ );+}diff --git a/frontend/src/components/features/settings/git-settings/webhook-status-badge.tsx b/frontend/src/components/features/settings/git-settings/webhook-status-badge.tsxnew file mode 100644index 0000000000..7855408d71--- /dev/null+++ b/frontend/src/components/features/settings/git-settings/webhook-status-badge.tsx@@ -0,0 +1,46 @@+import { useTranslation } from "react-i18next";+import { I18nKey } from "#/i18n/declaration";+import { Typography } from "#/ui/typography";++export interface WebhookStatusBadgeProps {+ webhookInstalled: boolean;+ installationResult?: { success: boolean; error: string | null } | null;+}++export function WebhookStatusBadge({+ webhookInstalled,+ installationResult,+}: WebhookStatusBadgeProps) {+ const { t } = useTranslation();++ if (installationResult) {+ if (installationResult.success) {+ return (+ <Typography.Text className="px-2 py-1 text-xs rounded bg-green-500/20 text-green-400">+ {t(I18nKey.GITLAB$WEBHOOK_STATUS_INSTALLED)}+ </Typography.Text>+ );+ }+ return (+ <span title={installationResult.error || undefined}>+ <Typography.Text className="px-2 py-1 text-xs rounded bg-red-500/20 text-red-400">+ {t(I18nKey.GITLAB$WEBHOOK_STATUS_FAILED)}+ </Typography.Text>+ </span>+ );+ }++ if (webhookInstalled) {+ return (+ <Typography.Text className="px-2 py-1 text-xs rounded bg-green-500/20 text-green-400">+ {t(I18nKey.GITLAB$WEBHOOK_STATUS_INSTALLED)}+ </Typography.Text>+ );+ }++ return (+ <Typography.Text className="px-2 py-1 text-xs rounded bg-gray-500/20 text-gray-400">+ {t(I18nKey.GITLAB$WEBHOOK_STATUS_NOT_INSTALLED)}+ </Typography.Text>+ );+}diff --git a/frontend/src/hooks/mutation/use-reinstall-gitlab-webhook.ts b/frontend/src/hooks/mutation/use-reinstall-gitlab-webhook.tsnew file mode 100644index 0000000000..af0f2b9afd--- /dev/null+++ b/frontend/src/hooks/mutation/use-reinstall-gitlab-webhook.ts@@ -0,0 +1,47 @@+import { useMutation, useQueryClient } from "@tanstack/react-query";+import { useTranslation } from "react-i18next";+import { integrationService } from "#/api/integration-service/integration-service.api";+import type {+ ResourceIdentifier,+ ResourceInstallationResult,+} from "#/api/integration-service/integration-service.types";+import { I18nKey } from "#/i18n/declaration";+import {+ displayErrorToast,+ displaySuccessToast,+} from "#/utils/custom-toast-handlers";++/**+ * Hook to reinstall webhook on a specific resource+ */+export function useReinstallGitLabWebhook() {+ const queryClient = useQueryClient();+ const { t } = useTranslation();++ return useMutation<+ ResourceInstallationResult,+ Error,+ ResourceIdentifier,+ unknown+ >({+ mutationFn: (resource: ResourceIdentifier) =>+ integrationService.reinstallGitLabWebhook({ resource }),+ onSuccess: (data) => {+ // Invalidate and refetch the resources list+ queryClient.invalidateQueries({ queryKey: ["gitlab-resources"] });++ if (data.success) {+ displaySuccessToast(t(I18nKey.GITLAB$WEBHOOK_REINSTALL_SUCCESS));+ } else if (data.error) {+ displayErrorToast(data.error);+ } else {+ displayErrorToast(t(I18nKey.GITLAB$WEBHOOK_REINSTALL_FAILED));+ }+ },+ onError: (error) => {+ const errorMessage =+ error?.message || t(I18nKey.GITLAB$WEBHOOK_REINSTALL_FAILED);+ displayErrorToast(errorMessage);+ },+ });+}diff --git a/frontend/src/hooks/query/use-gitlab-resources-list.ts b/frontend/src/hooks/query/use-gitlab-resources-list.tsnew file mode 100644index 0000000000..7e529bdae7--- /dev/null+++ b/frontend/src/hooks/query/use-gitlab-resources-list.ts@@ -0,0 +1,16 @@+import { useQuery } from "@tanstack/react-query";+import { integrationService } from "#/api/integration-service/integration-service.api";+import type { GitLabResourcesResponse } from "#/api/integration-service/integration-service.types";++/**+ * Hook to fetch GitLab resources with webhook status+ */+export function useGitLabResources(enabled: boolean = true) {+ return useQuery<GitLabResourcesResponse>({+ queryKey: ["gitlab-resources"],+ queryFn: () => integrationService.getGitLabResources(),+ enabled,+ staleTime: 1000 * 60 * 2, // 2 minutes+ gcTime: 1000 * 60 * 10, // 10 minutes+ });+}diff --git a/frontend/src/i18n/declaration.ts b/frontend/src/i18n/declaration.tsindex a3c04ce323..30645cb4f7 100644--- a/frontend/src/i18n/declaration.ts+++ b/frontend/src/i18n/declaration.ts@@ -126,6 +126,11 @@ export enum I18nKey {SETTINGS$GITHUB = "SETTINGS$GITHUB",SETTINGS$AZURE_DEVOPS = "SETTINGS$AZURE_DEVOPS",SETTINGS$SLACK = "SETTINGS$SLACK",+ COMMON$STATUS = "COMMON$STATUS",+ SETTINGS$GITLAB_NOT_CONNECTED = "SETTINGS$GITLAB_NOT_CONNECTED",+ SETTINGS$GITLAB_REINSTALL_WEBHOOK = "SETTINGS$GITLAB_REINSTALL_WEBHOOK",+ SETTINGS$GITLAB_INSTALLING_WEBHOOK = "SETTINGS$GITLAB_INSTALLING_WEBHOOK",+ SETTINGS$GITLAB = "SETTINGS$GITLAB",SETTINGS$NAV_LLM = "SETTINGS$NAV_LLM",GIT$MERGE_REQUEST = "GIT$MERGE_REQUEST",GIT$GITLAB_API = "GIT$GITLAB_API",@@ -618,6 +623,22 @@ export enum I18nKey {GITLAB$TOKEN_HELP_TEXT = "GITLAB$TOKEN_HELP_TEXT",GITLAB$TOKEN_LINK_TEXT = "GITLAB$TOKEN_LINK_TEXT",GITLAB$INSTRUCTIONS_LINK_TEXT = "GITLAB$INSTRUCTIONS_LINK_TEXT",+ GITLAB$WEBHOOK_MANAGER_TITLE = "GITLAB$WEBHOOK_MANAGER_TITLE",+ GITLAB$WEBHOOK_MANAGER_DESCRIPTION = "GITLAB$WEBHOOK_MANAGER_DESCRIPTION",+ GITLAB$WEBHOOK_MANAGER_LOADING = "GITLAB$WEBHOOK_MANAGER_LOADING",+ GITLAB$WEBHOOK_MANAGER_ERROR = "GITLAB$WEBHOOK_MANAGER_ERROR",+ GITLAB$WEBHOOK_MANAGER_NO_RESOURCES = "GITLAB$WEBHOOK_MANAGER_NO_RESOURCES",+ GITLAB$WEBHOOK_REINSTALL = "GITLAB$WEBHOOK_REINSTALL",+ GITLAB$WEBHOOK_REINSTALLING = "GITLAB$WEBHOOK_REINSTALLING",+ GITLAB$WEBHOOK_REINSTALL_SUCCESS = "GITLAB$WEBHOOK_REINSTALL_SUCCESS",+ GITLAB$WEBHOOK_COLUMN_RESOURCE = "GITLAB$WEBHOOK_COLUMN_RESOURCE",+ GITLAB$WEBHOOK_COLUMN_TYPE = "GITLAB$WEBHOOK_COLUMN_TYPE",+ GITLAB$WEBHOOK_COLUMN_STATUS = "GITLAB$WEBHOOK_COLUMN_STATUS",+ GITLAB$WEBHOOK_COLUMN_ACTION = "GITLAB$WEBHOOK_COLUMN_ACTION",+ GITLAB$WEBHOOK_STATUS_INSTALLED = "GITLAB$WEBHOOK_STATUS_INSTALLED",+ GITLAB$WEBHOOK_STATUS_NOT_INSTALLED = "GITLAB$WEBHOOK_STATUS_NOT_INSTALLED",+ GITLAB$WEBHOOK_STATUS_FAILED = "GITLAB$WEBHOOK_STATUS_FAILED",+ GITLAB$WEBHOOK_REINSTALL_FAILED = "GITLAB$WEBHOOK_REINSTALL_FAILED",BITBUCKET$TOKEN_LABEL = "BITBUCKET$TOKEN_LABEL",BITBUCKET$HOST_LABEL = "BITBUCKET$HOST_LABEL",BITBUCKET$GET_TOKEN = "BITBUCKET$GET_TOKEN",diff --git a/frontend/src/i18n/translation.json b/frontend/src/i18n/translation.jsonindex b2aaeb1a1d..bfad5665e4 100644--- a/frontend/src/i18n/translation.json+++ b/frontend/src/i18n/translation.json@@ -2015,6 +2015,86 @@"de": "Slack","uk": "Slack"},+ "COMMON$STATUS": {+ "en": "Status",+ "ja": "ステータス",+ "zh-CN": "状态",+ "zh-TW": "狀態",+ "ko-KR": "상태",+ "no": "Status",+ "it": "Stato",+ "pt": "Status",+ "es": "Estado",+ "ar": "الحالة",+ "fr": "Statut",+ "tr": "Durum",+ "de": "Status",+ "uk": "Статус"+ },+ "SETTINGS$GITLAB_NOT_CONNECTED": {+ "en": "Not Connected",+ "ja": "未接続",+ "zh-CN": "未连接",+ "zh-TW": "未連接",+ "ko-KR": "연결되지 않음",+ "no": "Ikke tilkoblet",+ "it": "Non connesso",+ "pt": "Não conectado",+ "es": "No conectado",+ "ar": "غير متصل",+ "fr": "Non connecté",+ "tr": "Bağlı değil",+ "de": "Nicht verbunden",+ "uk": "Не підключено"+ },+ "SETTINGS$GITLAB_REINSTALL_WEBHOOK": {+ "en": "Reinstall Webhook",+ "ja": "Webhookを再インストール",+ "zh-CN": "重新安装 Webhook",+ "zh-TW": "重新安裝 Webhook",+ "ko-KR": "Webhook 재설치",+ "no": "Installer Webhook på nytt",+ "it": "Reinstalla Webhook",+ "pt": "Reinstalar Webhook",+ "es": "Reinstalar Webhook",+ "ar": "إعادة تثبيت Webhook",+ "fr": "Réinstaller le Webhook",+ "tr": "Webhook'u Yeniden Kur",+ "de": "Webhook neu installieren",+ "uk": "Перевстановити Webhook"+ },+ "SETTINGS$GITLAB_INSTALLING_WEBHOOK": {+ "en": "Installing GitLab webhook, please wait a few minutes.",+ "ja": "GitLabのWebhookをインストールしています。数分お待ちください。",+ "zh-CN": "正在安装 GitLab webhook,请稍等几分钟。",+ "zh-TW": "正在安裝 GitLab webhook,請稍候幾分鐘。",+ "ko-KR": "GitLab webhook을 설치 중입니다. 잠시만 기다려주세요.",+ "no": "Installerer GitLab-webhook, vennligst vent noen minutter.",+ "it": "Installazione del webhook GitLab in corso, attendi alcuni minuti.",+ "pt": "Instalando o webhook do GitLab, por favor aguarde alguns minutos.",+ "es": "Instalando el webhook de GitLab, por favor espera unos minutos.",+ "ar": "يتم تثبيت Webhook الخاص بـ GitLab، يرجى الانتظار لبضع دقائق.",+ "fr": "Installation du webhook GitLab, veuillez patienter quelques minutes.",+ "tr": "GitLab webhook'u yükleniyor, lütfen birkaç dakika bekleyin.",+ "de": "GitLab-Webhook wird installiert. Bitte warten Sie einige Minuten.",+ "uk": "Встановлення GitLab webhook, зачекайте кілька хвилин."+ },+ "SETTINGS$GITLAB": {+ "en": "GitLab",+ "ja": "GitLab",+ "zh-CN": "GitLab",+ "zh-TW": "GitLab",+ "ko-KR": "GitLab",+ "no": "GitLab",+ "it": "GitLab",+ "pt": "GitLab",+ "es": "GitLab",+ "ar": "GitLab",+ "fr": "GitLab",+ "tr": "GitLab",+ "de": "GitLab",+ "uk": "GitLab"+ },"SETTINGS$NAV_LLM": {"en": "LLM","ja": "LLM",@@ -9887,6 +9967,262 @@"de": "klicken Sie hier für Anweisungen","uk": "натисніть тут, щоб отримати інструкції"},+ "GITLAB$WEBHOOK_MANAGER_TITLE": {+ "en": "Webhook Management",+ "ja": "Webhook管理",+ "zh-CN": "Webhook管理",+ "zh-TW": "Webhook管理",+ "ko-KR": "웹훅 관리",+ "no": "Webhook-administrasjon",+ "it": "Gestione Webhook",+ "pt": "Gerenciamento de Webhook",+ "es": "Gestión de Webhook",+ "ar": "إدارة Webhook",+ "fr": "Gestion des Webhooks",+ "tr": "Webhook Yönetimi",+ "de": "Webhook-Verwaltung",+ "uk": "Керування Webhook"+ },+ "GITLAB$WEBHOOK_MANAGER_DESCRIPTION": {+ "en": "Manage webhooks for your GitLab projects and groups. Webhooks enable OpenHands to receive notifications from GitLab. Note: If a webhook is already installed, you must first delete it through the GitLab UI before reinstalling.",+ "ja": "GitLabプロジェクトとグループのWebhookを管理します。WebhookによりOpenHandsはGitLabから通知を受け取ることができます。注:Webhookが既にインストールされている場合は、再インストールする前にGitLab UIから削除する必要があります。",+ "zh-CN": "管理您的GitLab项目和组的Webhook。Webhook使OpenHands能够接收来自GitLab的通知。注意:如果Webhook已安装,您必须先通过GitLab UI删除它,然后才能重新安装。",+ "zh-TW": "管理您的GitLab專案和群組的Webhook。Webhook使OpenHands能夠接收來自GitLab的通知。注意:如果Webhook已安裝,您必須先透過GitLab UI刪除它,然後才能重新安裝。",+ "ko-KR": "GitLab 프로젝트 및 그룹의 웹훅을 관리합니다. 웹훅을 통해 OpenHands가 GitLab에서 알림을 받을 수 있습니다. 참고: 웹훅이 이미 설치되어 있는 경우 재설치하기 전에 GitLab UI를 통해 먼저 삭제해야 합니다.",+ "no": "Administrer webhooks for dine GitLab-prosjekter og grupper. Webhooks gjør det mulig for OpenHands å motta varsler fra GitLab. Merk: Hvis en webhook allerede er installert, må du først slette den via GitLab-grensesnittet før du installerer den på nytt.",+ "it": "Gestisci i webhook per i tuoi progetti e gruppi GitLab. I webhook consentono a OpenHands di ricevere notifiche da GitLab. Nota: se un webhook è già installato, devi prima eliminarlo tramite l'interfaccia utente di GitLab prima di reinstallarlo.",+ "pt": "Gerencie webhooks para seus projetos e grupos do GitLab. Os webhooks permitem que o OpenHands receba notificações do GitLab. Nota: Se um webhook já estiver instalado, você deve primeiro excluí-lo através da interface do GitLab antes de reinstalá-lo.",+ "es": "Administre webhooks para sus proyectos y grupos de GitLab. Los webhooks permiten que OpenHands reciba notificaciones de GitLab. Nota: Si un webhook ya está instalado, primero debe eliminarlo a través de la interfaz de GitLab antes de reinstalarlo.",+ "ar": "إدارة webhooks لمشاريعك ومجموعاتك في GitLab. تمكن Webhooks OpenHands من تلقي الإشعارات من GitLab. ملاحظة: إذا كان webhook مثبتًا بالفعل، يجب عليك أولاً حذفه من خلال واجهة GitLab قبل إعادة التثبيت.",+ "fr": "Gérez les webhooks pour vos projets et groupes GitLab. Les webhooks permettent à OpenHands de recevoir des notifications de GitLab. Remarque : Si un webhook est déjà installé, vous devez d'abord le supprimer via l'interface GitLab avant de le réinstaller.",+ "tr": "GitLab projeleriniz ve gruplarınız için webhook'ları yönetin. Webhook'lar OpenHands'in GitLab'dan bildirim almasını sağlar. Not: Bir webhook zaten yüklüyse, yeniden yüklemeden önce GitLab arayüzü üzerinden silmeniz gerekir.",+ "de": "Verwalten Sie Webhooks für Ihre GitLab-Projekte und -Gruppen. Webhooks ermöglichen es OpenHands, Benachrichtigungen von GitLab zu empfangen. Hinweis: Wenn ein Webhook bereits installiert ist, müssen Sie ihn zuerst über die GitLab-Benutzeroberfläche löschen, bevor Sie ihn neu installieren.",+ "uk": "Керуйте вебхуками для ваших проектів та груп GitLab. Вебхуки дозволяють OpenHands отримувати сповіщення від GitLab. Примітка: Якщо вебхук вже встановлено, ви повинні спочатку видалити його через інтерфейс GitLab перед повторним встановленням."+ },+ "GITLAB$WEBHOOK_MANAGER_LOADING": {+ "en": "Loading resources...",+ "ja": "リソースを読み込み中...",+ "zh-CN": "正在加载资源...",+ "zh-TW": "正在載入資源...",+ "ko-KR": "리소스 로드 중...",+ "no": "Laster ressurser...",+ "it": "Caricamento risorse...",+ "pt": "Carregando recursos...",+ "es": "Cargando recursos...",+ "ar": "جارٍ تحميل الموارد...",+ "fr": "Chargement des ressources...",+ "tr": "Kaynaklar yükleniyor...",+ "de": "Ressourcen werden geladen...",+ "uk": "Завантаження ресурсів..."+ },+ "GITLAB$WEBHOOK_MANAGER_ERROR": {+ "en": "Failed to load resources. Please try again.",+ "ja": "リソースの読み込みに失敗しました。もう一度お試しください。",+ "zh-CN": "加载资源失败。请重试。",+ "zh-TW": "載入資源失敗。請重試。",+ "ko-KR": "리소스 로드에 실패했습니다. 다시 시도해주세요.",+ "no": "Kunne ikke laste ressurser. Vennligst prøv igjen.",+ "it": "Impossibile caricare le risorse. Riprova.",+ "pt": "Falha ao carregar recursos. Por favor, tente novamente.",+ "es": "Error al cargar recursos. Por favor, inténtelo de nuevo.",+ "ar": "فشل تحميل الموارد. يرجى المحاولة مرة أخرى.",+ "fr": "Échec du chargement des ressources. Veuillez réessayer.",+ "tr": "Kaynaklar yüklenemedi. Lütfen tekrar deneyin.",+ "de": "Ressourcen konnten nicht geladen werden. Bitte versuchen Sie es erneut.",+ "uk": "Не вдалося завантажити ресурси. Будь ласка, спробуйте ще раз."+ },+ "GITLAB$WEBHOOK_MANAGER_NO_RESOURCES": {+ "en": "No projects or groups found where you have admin access.",+ "ja": "管理者アクセス権を持つプロジェクトまたはグループが見つかりませんでした。",+ "zh-CN": "未找到您具有管理员访问权限的项目或组。",+ "zh-TW": "未找到您具有管理員存取權限的專案或群組。",+ "ko-KR": "관리자 액세스 권한이 있는 프로젝트 또는 그룹을 찾을 수 없습니다.",+ "no": "Ingen prosjekter eller grupper funnet der du har administratortilgang.",+ "it": "Nessun progetto o gruppo trovato in cui hai accesso amministratore.",+ "pt": "Nenhum projeto ou grupo encontrado onde você tem acesso de administrador.",+ "es": "No se encontraron proyectos o grupos donde tenga acceso de administrador.",+ "ar": "لم يتم العثور على مشاريع أو مجموعات لديك فيها وصول المسؤول.",+ "fr": "Aucun projet ou groupe trouvé où vous avez un accès administrateur.",+ "tr": "Yönetici erişiminizin olduğu proje veya grup bulunamadı.",+ "de": "Keine Projekte oder Gruppen gefunden, auf die Sie Administratorzugriff haben.",+ "uk": "Не знайдено проектів або груп, де ви маєте адміністраторський доступ."+ },+ "GITLAB$WEBHOOK_REINSTALL": {+ "en": "Reinstall",+ "ja": "再インストール",+ "zh-CN": "重新安装",+ "zh-TW": "重新安裝",+ "ko-KR": "재설치",+ "no": "Installer på nytt",+ "it": "Reinstalla",+ "pt": "Reinstalar",+ "es": "Reinstalar",+ "ar": "إعادة التثبيت",+ "fr": "Réinstaller",+ "tr": "Yeniden Yükle",+ "de": "Neu installieren",+ "uk": "Перевстановити"+ },+ "GITLAB$WEBHOOK_REINSTALLING": {+ "en": "Reinstalling...",+ "ja": "再インストール中...",+ "zh-CN": "正在重新安装...",+ "zh-TW": "正在重新安裝...",+ "ko-KR": "재설치 중...",+ "no": "Installerer på nytt...",+ "it": "Reinstallazione...",+ "pt": "Reinstalando...",+ "es": "Reinstalando...",+ "ar": "جارٍ إعادة التثبيت...",+ "fr": "Réinstallation...",+ "tr": "Yeniden yükleniyor...",+ "de": "Wird neu installiert...",+ "uk": "Перевстановлення..."+ },+ "GITLAB$WEBHOOK_REINSTALL_SUCCESS": {+ "en": "Webhook reinstalled successfully",+ "ja": "ウェブフックの再インストールが完了しました",+ "zh-CN": "Webhook 重新安装成功",+ "zh-TW": "Webhook 重新安裝成功",+ "ko-KR": "웹훅 재설치 성공",+ "no": "Webhook ble installert på nytt",+ "it": "Webhook reinstallato con successo",+ "pt": "Webhook reinstalado com sucesso",+ "es": "Webhook reinstalado correctamente",+ "ar": "تم إعادة تثبيت الخطاف بنجاح",+ "fr": "Webhook réinstallé avec succès",+ "tr": "Webhook başarıyla yeniden yüklendi",+ "de": "Webhook erfolgreich neu installiert",+ "uk": "Вебхук успішно перевстановлено"+ },+ "GITLAB$WEBHOOK_COLUMN_RESOURCE": {+ "en": "Resource",+ "ja": "リソース",+ "zh-CN": "资源",+ "zh-TW": "資源",+ "ko-KR": "리소스",+ "no": "Ressurs",+ "it": "Risorsa",+ "pt": "Recurso",+ "es": "Recurso",+ "ar": "المورد",+ "fr": "Ressource",+ "tr": "Kaynak",+ "de": "Ressource",+ "uk": "Ресурс"+ },+ "GITLAB$WEBHOOK_COLUMN_TYPE": {+ "en": "Type",+ "ja": "タイプ",+ "zh-CN": "类型",+ "zh-TW": "類型",+ "ko-KR": "유형",+ "no": "Type",+ "it": "Tipo",+ "pt": "Tipo",+ "es": "Tipo",+ "ar": "النوع",+ "fr": "Type",+ "tr": "Tür",+ "de": "Typ",+ "uk": "Тип"+ },+ "GITLAB$WEBHOOK_COLUMN_STATUS": {+ "en": "Status",+ "ja": "ステータス",+ "zh-CN": "状态",+ "zh-TW": "狀態",+ "ko-KR": "상태",+ "no": "Status",+ "it": "Stato",+ "pt": "Status",+ "es": "Estado",+ "ar": "الحالة",+ "fr": "Statut",+ "tr": "Durum",+ "de": "Status",+ "uk": "Статус"+ },+ "GITLAB$WEBHOOK_COLUMN_ACTION": {+ "en": "Action",+ "ja": "アクション",+ "zh-CN": "操作",+ "zh-TW": "操作",+ "ko-KR": "작업",+ "no": "Handling",+ "it": "Azione",+ "pt": "Ação",+ "es": "Acción",+ "ar": "الإجراء",+ "fr": "Action",+ "tr": "Eylem",+ "de": "Aktion",+ "uk": "Дія"+ },+ "GITLAB$WEBHOOK_STATUS_INSTALLED": {+ "en": "Installed",+ "ja": "インストール済み",+ "zh-CN": "已安装",+ "zh-TW": "已安裝",+ "ko-KR": "설치됨",+ "no": "Installert",+ "it": "Installato",+ "pt": "Instalado",+ "es": "Instalado",+ "ar": "مثبت",+ "fr": "Installé",+ "tr": "Yüklü",+ "de": "Installiert",+ "uk": "Встановлено"+ },+ "GITLAB$WEBHOOK_STATUS_NOT_INSTALLED": {+ "en": "Not Installed",+ "ja": "未インストール",+ "zh-CN": "未安装",+ "zh-TW": "未安裝",+ "ko-KR": "설치되지 않음",+ "no": "Ikke installert",+ "it": "Non installato",+ "pt": "Não instalado",+ "es": "No instalado",+ "ar": "غير مثبت",+ "fr": "Non installé",+ "tr": "Yüklü değil",+ "de": "Nicht installiert",+ "uk": "Не встановлено"+ },+ "GITLAB$WEBHOOK_STATUS_FAILED": {+ "en": "Failed",+ "ja": "失敗",+ "zh-CN": "失败",+ "zh-TW": "失敗",+ "ko-KR": "실패",+ "no": "Mislyktes",+ "it": "Fallito",+ "pt": "Falhou",+ "es": "Fallido",+ "ar": "فشل",+ "fr": "Échoué",+ "tr": "Başarısız",+ "de": "Fehlgeschlagen",+ "uk": "Помилка"+ },+ "GITLAB$WEBHOOK_REINSTALL_FAILED": {+ "en": "Failed to reinstall webhook",+ "ja": "ウェブフックの再インストールに失敗しました",+ "zh-CN": "重新安装 Webhook 失败",+ "zh-TW": "重新安裝 Webhook 失敗",+ "ko-KR": "웹훅 재설치 실패",+ "no": "Kunne ikke installere webhook på nytt",+ "it": "Reinstallazione webhook non riuscita",+ "pt": "Falha ao reinstalar webhook",+ "es": "Error al reinstalar webhook",+ "ar": "فشل في إعادة تثبيت الخطاف",+ "fr": "Échec de la réinstallation du webhook",+ "tr": "Webhook yeniden yüklenemedi",+ "de": "Webhook konnte nicht neu installiert werden",+ "uk": "Не вдалося перевстановити вебхук"+ },"BITBUCKET$TOKEN_LABEL": {"en": "Bitbucket Token","ja": "Bitbucketトークン",diff --git a/frontend/src/routes/git-settings.tsx b/frontend/src/routes/git-settings.tsxindex ca43591117..00b274f1de 100644--- a/frontend/src/routes/git-settings.tsx+++ b/frontend/src/routes/git-settings.tsx@@ -6,11 +6,13 @@ import { BrandButton } from "#/components/features/settings/brand-button";import { useLogout } from "#/hooks/mutation/use-logout";import { GitHubTokenInput } from "#/components/features/settings/git-settings/github-token-input";import { GitLabTokenInput } from "#/components/features/settings/git-settings/gitlab-token-input";+import { GitLabWebhookManager } from "#/components/features/settings/git-settings/gitlab-webhook-manager";import { BitbucketTokenInput } from "#/components/features/settings/git-settings/bitbucket-token-input";import { AzureDevOpsTokenInput } from "#/components/features/settings/git-settings/azure-devops-token-input";import { ForgejoTokenInput } from "#/components/features/settings/git-settings/forgejo-token-input";import { ConfigureGitHubRepositoriesAnchor } from "#/components/features/settings/git-settings/configure-github-repositories-anchor";import { InstallSlackAppAnchor } from "#/components/features/settings/git-settings/install-slack-app-anchor";+import DebugStackframeDot from "#/icons/debug-stackframe-dot.svg?react";import { I18nKey } from "#/i18n/declaration";import {displayErrorToast,@@ -21,6 +23,7 @@ import { GitSettingInputsSkeleton } from "#/components/features/settings/git-setimport { useAddGitProviders } from "#/hooks/mutation/use-add-git-providers";import { useUserProviders } from "#/hooks/use-user-providers";import { ProjectManagementIntegration } from "#/components/features/settings/project-management/project-management-integration";+import { Typography } from "#/ui/typography";function GitSettingsScreen() {const { t } = useTranslation();@@ -182,6 +185,33 @@ function GitSettingsScreen() {</>)}+ {shouldRenderExternalConfigureButtons && !isLoading && (+ <>+ <div className="mt-6 flex flex-col gap-4 pb-8">+ <Typography.H3 className="text-xl">+ {t(I18nKey.SETTINGS$GITLAB)}+ </Typography.H3>+ <div className="flex items-center">+ <DebugStackframeDot+ className="w-6 h-6 shrink-0"+ color={isGitLabTokenSet ? "#BCFF8C" : "#FF684E"}+ />+ <Typography.Text+ className="text-sm text-gray-400"+ testId="gitlab-status-text"+ >+ {t(I18nKey.COMMON$STATUS)}:{" "}+ {isGitLabTokenSet+ ? t(I18nKey.STATUS$CONNECTED)+ : t(I18nKey.SETTINGS$GITLAB_NOT_CONNECTED)}+ </Typography.Text>+ </div>+ {isGitLabTokenSet && <GitLabWebhookManager />}+ </div>+ <div className="w-1/2 border-b border-gray-200" />+ </>+ )}+{shouldRenderExternalConfigureButtons && !isLoading && (<><div className="pb-1 mt-6 flex flex-col">