π OpenHands: AI-Driven Development
Add V1 API endpoints for git search and branches (#13794)
Tim O'Farrelle46bcfa82ff8
diff --git a/openhands/app_server/git/git_models.py b/openhands/app_server/git/git_models.pyindex 6f35ae3bde..10dc9abdfd 100644--- a/openhands/app_server/git/git_models.py+++ b/openhands/app_server/git/git_models.py@@ -1,8 +1,34 @@"""Git-related models for V1 API pagination responses."""+from enum import StrEnum+from pydantic import BaseModel-from openhands.integrations.service_types import Repository+from openhands.integrations.service_types import (+ Branch,+ Repository,+ SuggestedTask,+)+++class SortOrder(StrEnum):+ """Sort order for search results combining sort field and direction.++ Values:+ STAR_DESC: Sort by stars, descending+ STAR_ASC: Sort by stars, ascending+ FORKS_DESC: Sort by forks, descending+ FORKS_ASC: Sort by forks, ascending+ UPDATED_DESC: Sort by last updated, descending+ UPDATED_ASC: Sort by last updated, ascending+ """++ STAR_DESC = 'stars-desc'+ STAR_ASC = 'stars-asc'+ FORKS_DESC = 'forks-desc'+ FORKS_ASC = 'forks-asc'+ UPDATED_DESC = 'updated-desc'+ UPDATED_ASC = 'updated-asc'class InstallationPage(BaseModel):@@ -27,3 +53,27 @@ class RepositoryPage(BaseModel):items: list[Repository]next_page_id: str | None = None+++class BranchPage(BaseModel):+ """Paginated response for branch search results.++ Attributes:+ items: List of branches in the current page.+ next_page_id: ID for the next page, or None if there are no more pages.+ """++ items: list[Branch]+ next_page_id: str | None = None+++class SuggestedTaskPage(BaseModel):+ """Paginated response for suggested tasks.++ Attributes:+ items: List of suggested tasks in the current page.+ next_page_id: ID for the next page, or None if there are no more pages.+ """++ items: list[SuggestedTask]+ next_page_id: str | None = Nonediff --git a/openhands/app_server/git/git_router.py b/openhands/app_server/git/git_router.pyindex f848b386a6..e1f1deec2c 100644--- a/openhands/app_server/git/git_router.py+++ b/openhands/app_server/git/git_router.py@@ -12,8 +12,11 @@ from fastapi import APIRouter, HTTPException, Query, statusfrom openhands.app_server.config import depends_user_context, get_global_configfrom openhands.app_server.git.git_models import (+ BranchPage,InstallationPage,RepositoryPage,+ SortOrder,+ SuggestedTaskPage,)from openhands.app_server.user.user_context import UserContextfrom openhands.app_server.utils.dependencies import get_dependencies@@ -23,7 +26,12 @@ from openhands.app_server.utils.paging_utils import (paginate_results,)from openhands.integrations.provider import ProviderHandler-from openhands.integrations.service_types import ProviderType+from openhands.integrations.service_types import (+ Branch,+ ProviderType,+ Repository,+ SuggestedTask,+)if TYPE_CHECKING:from openhands.integrations.provider import PROVIDER_TOKEN_TYPE@@ -38,8 +46,8 @@ router = APIRouter(user_context_dependency = depends_user_context()[email protected]('/installations')-async def get_user_installations([email protected]('/installations/search')+async def search_user_installations(provider: ProviderType,page_id: Annotated[str | None,@@ -89,11 +97,19 @@ async def get_user_installations(return InstallationPage(items=items, next_page_id=next_page_id)[email protected]('/repositories')-async def get_user_repositories([email protected]('/repositories/search')+async def search_repositories(provider: ProviderType,- sort: str = 'pushed',- installation_id: str | None = None,+ query: Annotated[+ str | None,+ Query(+ title='Search query for finding repositories. If not provided, returns user repositories.'+ ),+ ] = None,+ installation_id: Annotated[+ str | None,+ Query(title='Filter by installation/app ID'),+ ] = None,page_id: Annotated[str | None,Query(title='Optional next_page_id from the previously returned page'),@@ -102,11 +118,107 @@ async def get_user_repositories(int,Query(title='The max number of results in the page', gt=0, le=100),] = 100,+ sort_order: Annotated[+ SortOrder | None,+ Query(title='Sort order for search results (e.g., stars-desc, forks-asc)'),+ ] = None,user_context: UserContext = user_context_dependency,) -> RepositoryPage:- """Get user repositories.+ """Get or search repositories.++ If query is provided, searches repositories across the git provider.+ If query is not provided, returns a paginated list of the authenticated user's repositories.+ """+ # Get provider tokens from user context+ provider_tokens = await user_context.get_provider_tokens()+ if not provider_tokens:+ raise HTTPException(+ status_code=status.HTTP_401_UNAUTHORIZED,+ detail='Git provider token required (such as GitHub).',+ )++ user_id = await user_context.get_user_id()+ # Cast to the expected type since we validated provider_tokens exists+ typed_provider_tokens: PROVIDER_TOKEN_TYPE = provider_tokens # type: ignore[assignment]+ client = ProviderHandler(+ provider_tokens=MappingProxyType(typed_provider_tokens),+ external_auth_id=user_id,+ )++ page = 1+ decoded_page_id = decode_page_id(page_id)+ if decoded_page_id is not None:+ page = decoded_page_id++ # If query is provided, use search; otherwise get user's repositories+ if query:+ # Parse sort_order into sort and order components (if provided)+ if sort_order:+ search_sort, order = sort_order.value.rsplit('-', 1)+ else:+ search_sort = 'stars'+ order = 'desc'++ repos: list[Repository] = await client.search_repositories(+ selected_provider=provider,+ query=query,+ per_page=limit + 1,+ sort=search_sort,+ order=order,+ app_mode=get_global_config().app_mode,+ )+ else:+ if sort_order:+ # TODO: This is a temporary state until we refactor the underlying API.+ # The get_repositories method does not support sorting in the same way as+ # the search method - those should be merged into a single paginated+ # method+ raise HTTPException(+ status_code=status.HTTP_400_BAD_REQUEST,+ detail='sort_order is not supported when listing user repositories. It will be supported after API refactoring.',+ )+ # TODO: The underlying API needs refactoring.+ repos = await client.get_repositories(+ sort='pushed',+ app_mode=get_global_config().app_mode,+ selected_provider=provider,+ page=page,+ per_page=limit + 1,+ installation_id=installation_id,+ )++ next_page_id = None+ if len(repos) > limit:+ repos = repos[:-1]+ next_page_id = encode_page_id(page + 1)++ return RepositoryPage(items=repos, next_page_id=next_page_id)++[email protected]('/branches/search')+async def search_branches(+ provider: ProviderType,+ repository: Annotated[+ str,+ Query(title='Repository name in format owner/repo'),+ ],+ query: Annotated[+ str,+ Query(title='Branch name search query'),+ ],+ page_id: Annotated[+ str | None,+ Query(title='Optional next_page_id from the previously returned page'),+ ] = None,+ limit: Annotated[+ int,+ Query(title='The max number of results in the page', gt=0, le=100),+ ] = 30,+ user_context: UserContext = user_context_dependency,+) -> BranchPage:+ """Search branches in a repository.- Returns a paginated list of repositories for the authenticated user.+ Returns a paginated list of branches matching the search query."""# Get provider tokens from user contextprovider_tokens = await user_context.get_provider_tokens()@@ -129,19 +241,72 @@ async def get_user_repositories(if decoded_page_id is not None:page = decoded_page_id- # Get repositories - we'll handle pagination ourselves- items = await client.get_repositories(- sort=sort,- app_mode=get_global_config().app_mode,+ # Get search results - we'll handle pagination ourselves+ branches: list[Branch] = await client.search_branches(selected_provider=provider,- page=page,+ repository=repository,+ query=query,per_page=limit + 1, # We'll handle pagination ourselves- installation_id=installation_id,)next_page_id = None- if len(items) > limit:- items = items[:-1]+ if len(branches) > limit:+ branches = branches[:-1]+ next_page_id = encode_page_id(page + 1)++ return BranchPage(items=branches, next_page_id=next_page_id)++[email protected]('/suggested-tasks/search')+async def search_suggested_tasks(+ page_id: Annotated[+ str | None,+ Query(title='Optional next_page_id from the previously returned page'),+ ] = None,+ limit: Annotated[+ int,+ Query(title='The max number of results in the page', gt=0, le=100),+ ] = 30,+ user_context: UserContext = user_context_dependency,+) -> SuggestedTaskPage:+ """Get suggested tasks for the user.++ Returns a paginated list of suggested tasks including:+ - PRs owned by the user+ - Issues assigned to the user+ """+ # Get provider tokens from user context+ provider_tokens = await user_context.get_provider_tokens()+ if not provider_tokens:+ raise HTTPException(+ status_code=status.HTTP_401_UNAUTHORIZED,+ detail='Git provider token required (such as GitHub).',+ )++ user_id = await user_context.get_user_id()+ # Cast to the expected type since we validated provider_tokens exists+ typed_provider_tokens: PROVIDER_TOKEN_TYPE = provider_tokens # type: ignore[assignment]+ client = ProviderHandler(+ provider_tokens=MappingProxyType(typed_provider_tokens),+ external_auth_id=user_id,+ )++ page = 1+ decoded_page_id = decode_page_id(page_id)+ if decoded_page_id is not None:+ page = decoded_page_id++ # Get suggested tasks - we'll handle pagination ourselves+ # The underlying method doesn't have pagination, so we'll fetch all and paginate+ all_tasks: list[SuggestedTask] = await client.get_suggested_tasks()++ # Paginate results+ start_idx = (page - 1) * limit+ end_idx = start_idx + limit+ paginated_tasks = all_tasks[start_idx:end_idx]++ next_page_id = None+ if end_idx < len(all_tasks):next_page_id = encode_page_id(page + 1)- return RepositoryPage(items=items, next_page_id=next_page_id)+ return SuggestedTaskPage(items=paginated_tasks, next_page_id=next_page_id)diff --git a/openhands/server/routes/git.py b/openhands/server/routes/git.pyindex fa344b845d..9d40090428 100644--- a/openhands/server/routes/git.py+++ b/openhands/server/routes/git.py@@ -47,7 +47,7 @@ app = APIRouter(prefix='/api/user', dependencies=get_dependencies())'/installations',response_model=list[str],deprecated=True,- description='Deprecated: Use `/api/v1/git/installations` instead.',+ description='Deprecated: Use `/api/v1/git/installations/search` instead.',)async def get_user_installations(provider: ProviderType,@@ -83,7 +83,7 @@ async def get_user_installations('/repositories',response_model=list[Repository],deprecated=True,- description='Deprecated: Use `/api/v1/git/repositories` instead.',+ description='Deprecated: Use `/api/v1/git/repositories/search` instead.',)async def get_user_repositories(sort: str = 'pushed',@@ -151,7 +151,12 @@ async def get_user(raise AuthenticationError('Git provider token required. (such as GitHub).')[email protected]('/search/repositories', response_model=list[Repository])+ '/search/repositories',+ response_model=list[Repository],+ deprecated=True,+ description='Deprecated: Use `/api/v1/git/repositories/search` instead.',+)async def search_repositories(query: str,per_page: int = 5,@@ -186,7 +191,12 @@ async def search_repositories(raise AuthenticationError('Git provider token required.')[email protected]('/search/branches', response_model=list[Branch])+ '/search/branches',+ response_model=list[Branch],+ deprecated=True,+ description='Deprecated: Use `/api/v1/git/branches/search` instead.',+)async def search_branches(repository: str,query: str,@@ -229,7 +239,12 @@ async def search_branches()[email protected]('/suggested-tasks', response_model=list[SuggestedTask])+ '/suggested-tasks',+ response_model=list[SuggestedTask],+ deprecated=True,+ description='Deprecated: Use `/api/v1/git/suggested-tasks/search` instead.',+)async def get_suggested_tasks(provider_tokens: PROVIDER_TOKEN_TYPE | None = Depends(get_provider_tokens),access_token: SecretStr | None = Depends(get_access_token),@@ -258,7 +273,12 @@ async def get_suggested_tasks(raise AuthenticationError('No providers set.')[email protected]('/repository/branches', response_model=PaginatedBranchesResponse)+ '/repository/branches',+ response_model=PaginatedBranchesResponse,+ deprecated=True,+ description='Deprecated: Use `/api/v1/git/branches/search` instead.',+)async def get_repository_branches(repository: str,page: int = 1,@@ -304,18 +324,6 @@ async def get_repository_branches(raise AuthenticationError('Git provider token required. (such as GitHub).')-def _extract_repo_name(repository_name: str) -> str:- """Extract the actual repository name from the full repository path.-- Args:- repository_name: Repository name in format 'owner/repo' or 'domain/owner/repo'-- Returns:- The actual repository name (last part after the last '/')- """- return repository_name.split('/')[-1]--@app.get('/repository/{repository_name:path}/microagents',response_model=list[MicroagentResponse],diff --git a/tests/unit/app_server/test_git_router.py b/tests/unit/app_server/test_git_router.pyindex b62dbcae40..cf46e4e23b 100644--- a/tests/unit/app_server/test_git_router.py+++ b/tests/unit/app_server/test_git_router.py@@ -10,16 +10,25 @@ import pytestfrom fastapi import FastAPI, statusfrom fastapi.testclient import TestClient+from openhands.app_server.git.git_models import SortOrderfrom openhands.app_server.git.git_router import (- get_user_installations,- get_user_repositories,router,+ search_branches,+ search_repositories,+ search_suggested_tasks,+ search_user_installations,)from openhands.app_server.user.user_context import UserContextfrom openhands.app_server.utils.dependencies import check_session_api_keyfrom openhands.app_server.utils.paging_utils import encode_page_id, paginate_resultsfrom openhands.integrations.provider import ProviderToken-from openhands.integrations.service_types import ProviderType, Repository+from openhands.integrations.service_types import (+ Branch,+ ProviderType,+ Repository,+ SuggestedTask,+ TaskType,+)class TestPagination:@@ -123,51 +132,32 @@ def test_client():class TestInstallationsEndpoint:"""Test suite for /installations endpoint."""- def test_returns_401_when_no_provider_tokens(self, test_client, monkeypatch):+ def test_returns_401_when_no_provider_tokens(self, test_client):"""Test that 401 is returned when no provider tokens."""- mock_context = _make_mock_user_context(provider_tokens=None)- monkeypatch.setattr(- 'openhands.app_server.git.git_router.depends_user_context',- lambda: mock_context,- )-- response = test_client.get('/git/installations', params={'provider': 'github'})-- assert response.status_code == status.HTTP_401_UNAUTHORIZED-- def test_returns_422_for_unsupported_provider(self, test_client, monkeypatch):+ with patch(+ 'openhands.app_server.user.auth_user_context.AuthUserContext.get_provider_tokens',+ AsyncMock(return_value=None),+ ):+ response = test_client.get(+ '/git/installations/search', params={'provider': 'github'}+ )+ assert response.status_code == status.HTTP_401_UNAUTHORIZED++ def test_returns_422_for_unsupported_provider(self, test_client):"""Test that 422 is returned for unsupported provider."""- mock_context = _make_mock_user_context(provider_tokens={'github': 'token'})-- # Patch the ProviderHandler- monkeypatch.setattr(- 'openhands.app_server.git.git_router.depends_user_context',- lambda: mock_context,- )-- response = test_client.get('/git/installations', params={'provider': 'invalid'})- assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY---class TestRepositoriesEndpoint:- """Test suite for /repositories endpoint."""-- def test_returns_401_when_no_provider_tokens(self, test_client, monkeypatch):- """Test that 401 is returned when no provider tokens."""- mock_context = _make_mock_user_context(provider_tokens=None)- monkeypatch.setattr(- 'openhands.app_server.git.git_router.depends_user_context',- lambda: mock_context,- )-- response = test_client.get('/git/repositories', params={'provider': 'github'})-- assert response.status_code == status.HTTP_401_UNAUTHORIZED+ with patch(+ 'openhands.app_server.user.auth_user_context.AuthUserContext.get_provider_tokens',+ AsyncMock(return_value={'github': 'token'}),+ ):+ response = test_client.get(+ '/git/installations/search', params={'provider': 'invalid'}+ )+ assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY@pytest.mark.asyncio-class TestGetUserInstallations:- """Test suite for get_user_installations function."""+class TestSearchUserInstallations:+ """Test suite for search_user_installations function."""@pytest.mark.asyncio@patch('openhands.app_server.git.git_router.ProviderHandler')@@ -185,7 +175,7 @@ class TestGetUserInstallations:)# Act- result = await get_user_installations(+ result = await search_user_installations(provider=ProviderType.GITHUB,page_id=None,limit=2,@@ -213,7 +203,7 @@ class TestGetUserInstallations:)# Act - request second page- result = await get_user_installations(+ result = await search_user_installations(provider=ProviderType.GITHUB,page_id=encode_page_id(2), # Second page starts at offset 2limit=2,@@ -226,13 +216,13 @@ class TestGetUserInstallations:@pytest.mark.asyncio-class TestGetUserRepositories:- """Test suite for get_user_repositories function."""+class TestSearchRepositories:+ """Test suite for search_repositories function (handles both user repos and search)."""@pytest.mark.asyncio@patch('openhands.app_server.git.git_router.ProviderHandler')- async def test_returns_repositories_with_correct_structure(self, mock_handler_cls):- """Test that get_user_repositories returns correct RepositoryPage structure."""+ async def test_returns_user_repositories_without_query(self, mock_handler_cls):+ """Test that repositories_search returns user repositories when no query is provided."""# Arrangemock_handler = MagicMock()mock_handler.get_repositories = AsyncMock(@@ -266,10 +256,10 @@ class TestGetUserRepositories:user_id='user-123',)- # Act- result = await get_user_repositories(+ # Act - call without query to get user repos+ result = await search_repositories(provider=ProviderType.GITHUB,- sort='updated',+ query=None,installation_id=None,page_id=None,limit=10,@@ -283,6 +273,135 @@ class TestGetUserRepositories:assert result.items[2].id == '3'assert result.next_page_id is None # No more pages+ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_search_repositories_with_query(self, mock_handler_cls):+ """Test repository search when query is provided.++ This tests the search path (with query) which calls search_repositories+ instead of get_repositories, and verifies sort_order is parsed correctly.+ """+ # Arrange+ mock_handler = MagicMock()+ mock_handler.search_repositories = AsyncMock(+ return_value=[+ Repository(+ id='10',+ full_name='org/searched-repo',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ ),+ Repository(+ id='11',+ full_name='user/searched-repo',+ git_provider=ProviderType.GITHUB,+ is_public=False,+ ),+ ]+ )+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act - call with query and sort_order to trigger search path+ result = await search_repositories(+ provider=ProviderType.GITHUB,+ query='my-search-term',+ installation_id=None,+ page_id=None,+ limit=10,+ sort_order=SortOrder.STAR_DESC, # This should be parsed into sort='stars', order='desc'+ user_context=mock_context,+ )++ # Assert - verify search_repositories was called (not get_repositories)+ mock_handler.search_repositories.assert_called_once()+ call_kwargs = mock_handler.search_repositories.call_args.kwargs++ # Verify query is passed+ assert call_kwargs.get('query') == 'my-search-term'++ # Verify sort and order are parsed from sort_order ('stars-desc' -> sort='stars', order='desc')+ assert call_kwargs.get('sort') == 'stars'+ assert call_kwargs.get('order') == 'desc'++ # Verify per_page is limit + 1+ assert call_kwargs.get('per_page') == 11++ # Verify results are returned+ assert len(result.items) == 2+ assert result.items[0].id == '10'+ assert result.items[1].id == '11'++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_search_repositories_sort_order_asc(self, mock_handler_cls):+ """Test that sort_order ascending is parsed correctly."""+ # Arrange+ mock_handler = MagicMock()+ mock_handler.search_repositories = AsyncMock(return_value=[])+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act - call with sort_order ascending+ await search_repositories(+ provider=ProviderType.GITHUB,+ query='test',+ installation_id=None,+ page_id=None,+ limit=10,+ sort_order=SortOrder.FORKS_ASC,+ user_context=mock_context,+ )++ # Assert+ call_kwargs = mock_handler.search_repositories.call_args.kwargs+ assert call_kwargs.get('sort') == 'forks'+ assert call_kwargs.get('order') == 'asc'++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_search_repositories_default_sort_order(self, mock_handler_cls):+ """Test default sort order when sort_order is not provided."""+ # Arrange+ mock_handler = MagicMock()+ mock_handler.search_repositories = AsyncMock(return_value=[])+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act - call with query but no sort_order (uses default: stars, desc)+ await search_repositories(+ provider=ProviderType.GITHUB,+ query='test',+ installation_id=None,+ page_id=None,+ limit=10,+ sort_order=None,+ user_context=mock_context,+ )++ # Assert - defaults should be used+ call_kwargs = mock_handler.search_repositories.call_args.kwargs+ assert call_kwargs.get('sort') == 'stars' # Default+ assert call_kwargs.get('order') == 'desc' # Default+@pytest.mark.asyncio@patch('openhands.app_server.git.git_router.ProviderHandler')async def test_pagination_works_across_pages(self, mock_handler_cls):@@ -343,12 +462,13 @@ class TestGetUserRepositories:)# Act - First page (page=1)- result_page1 = await get_user_repositories(+ result_page1 = await search_repositories(provider=ProviderType.GITHUB,- sort='pushed',+ query=None,installation_id=None,page_id=None, # This means page 1limit=2,+ sort_order=None,user_context=mock_context,)@@ -359,12 +479,13 @@ class TestGetUserRepositories:assert result_page1.next_page_id == encode_page_id(2)# Act - Second page (page=2)- result_page2 = await get_user_repositories(+ result_page2 = await search_repositories(provider=ProviderType.GITHUB,- sort='pushed',+ query=None,installation_id=None,page_id=encode_page_id(2), # This means page 2limit=2,+ sort_order=None,user_context=mock_context,)@@ -392,9 +513,9 @@ class TestGetUserRepositories:)# Act- await get_user_repositories(+ await search_repositories(provider=ProviderType.GITHUB,- sort='stars',+ query=None,installation_id=None,page_id=None,limit=10,@@ -404,7 +525,7 @@ class TestGetUserRepositories:# Assert - verify get_repositories was called with the sort parametermock_handler.get_repositories.assert_called_once()call_kwargs = mock_handler.get_repositories.call_args.kwargs- assert call_kwargs.get('sort') == 'stars'+ assert call_kwargs.get('sort') == 'pushed'@pytest.mark.asyncio@patch('openhands.app_server.git.git_router.ProviderHandler')@@ -423,12 +544,13 @@ class TestGetUserRepositories:)# Act- await get_user_repositories(+ await search_repositories(provider=ProviderType.GITHUB,- sort='pushed',+ query=None,installation_id='app-123',page_id=None,limit=10,+ sort_order=None,user_context=mock_context,)@@ -436,3 +558,380 @@ class TestGetUserRepositories:mock_handler.get_repositories.assert_called_once()call_kwargs = mock_handler.get_repositories.call_args.kwargsassert call_kwargs.get('installation_id') == 'app-123'++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_returns_paginated_search_results(self, mock_handler_cls):+ """Test that search repositories are returned with pagination when query is provided."""+ # Arrange+ mock_handler = MagicMock()+ mock_handler.search_repositories = AsyncMock(+ return_value=[+ Repository(+ id='1',+ full_name='user/repo1',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ ),+ Repository(+ id='2',+ full_name='user/repo2',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ ),+ Repository(+ id='3',+ full_name='user/repo3',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ ),+ ]+ )+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act+ result = await search_repositories(+ provider=ProviderType.GITHUB,+ query='test',+ page_id=None,+ limit=2,+ sort_order=SortOrder.STAR_DESC,+ user_context=mock_context,+ )++ # Assert+ assert result.items == [+ Repository(+ id='1',+ full_name='user/repo1',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ ),+ Repository(+ id='2',+ full_name='user/repo2',+ git_provider=ProviderType.GITHUB,+ is_public=True,+ ),+ ]+ assert result.next_page_id == encode_page_id(2)++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_parses_sort_order_correctly(self, mock_handler_cls):+ """Test that sort_order enum is parsed into sort and order components."""+ # Arrange+ mock_handler = MagicMock()+ mock_handler.search_repositories = AsyncMock(return_value=[])+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act+ await search_repositories(+ provider=ProviderType.GITHUB,+ query='test',+ page_id=None,+ limit=5,+ sort_order=SortOrder.FORKS_ASC,+ user_context=mock_context,+ )++ # Assert - verify search_repositories was called with parsed sort and order+ mock_handler.search_repositories.assert_called_once()+ call_kwargs = mock_handler.search_repositories.call_args.kwargs+ assert call_kwargs.get('sort') == 'forks'+ assert call_kwargs.get('order') == 'asc'++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_returns_empty_first_page(self, mock_handler_cls):+ """Test that empty results return empty items with no next_page_id."""+ # Arrange+ mock_handler = MagicMock()+ mock_handler.search_repositories = AsyncMock(return_value=[])+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act+ result = await search_repositories(+ provider=ProviderType.GITHUB,+ query='nonexistent-repo-xyz',+ page_id=None,+ limit=5,+ sort_order=SortOrder.STAR_DESC,+ user_context=mock_context,+ )++ # Assert+ assert result.items == []+ assert result.next_page_id is None++ def test_returns_401_when_no_provider_tokens(self, test_client, monkeypatch):+ """Test that 401 is returned when no provider tokens."""+ with patch(+ 'openhands.app_server.user.auth_user_context.AuthUserContext.get_provider_tokens',+ AsyncMock(return_value=None),+ ):+ response = test_client.get(+ '/git/repositories/search',+ params={'provider': 'github', 'query': 'test'},+ )+ assert response.status_code == status.HTTP_401_UNAUTHORIZED+++class TestSearchBranches:+ """Test suite for search_branches function."""++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_returns_paginated_branches(self, mock_handler_cls):+ """Test that search branches are returned with pagination."""+ # Arrange+ mock_handler = MagicMock()+ mock_handler.search_branches = AsyncMock(+ return_value=[+ Branch(name='main', commit_sha='abc123', protected=False),+ Branch(name='develop', commit_sha='def456', protected=False),+ Branch(name='feature-branch', commit_sha='ghi789', protected=False),+ ]+ )+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act+ result = await search_branches(+ provider=ProviderType.GITHUB,+ repository='user/repo',+ query='main',+ page_id=None,+ limit=2,+ user_context=mock_context,+ )++ # Assert+ assert len(result.items) == 2+ assert result.items[0].name == 'main'+ assert result.items[1].name == 'develop'+ assert result.next_page_id == encode_page_id(2)++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_passes_parameters_to_provider(self, mock_handler_cls):+ """Test that all parameters are passed through to the provider."""+ # Arrange+ mock_handler = MagicMock()+ mock_handler.search_branches = AsyncMock(return_value=[])+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act+ await search_branches(+ provider=ProviderType.GITHUB,+ repository='user/repo',+ query='feature',+ page_id=None,+ limit=10,+ user_context=mock_context,+ )++ # Assert+ mock_handler.search_branches.assert_called_once()+ call_kwargs = mock_handler.search_branches.call_args.kwargs+ assert call_kwargs.get('selected_provider') == ProviderType.GITHUB+ assert call_kwargs.get('repository') == 'user/repo'+ assert call_kwargs.get('query') == 'feature'+ assert call_kwargs.get('per_page') == 11 # limit + 1++ def test_returns_401_when_no_provider_tokens(self, test_client):+ """Test that 401 is returned when no provider tokens."""+ with patch(+ 'openhands.app_server.user.auth_user_context.AuthUserContext.get_provider_tokens',+ AsyncMock(return_value=None),+ ):+ response = test_client.get(+ '/git/branches/search',+ params={+ 'provider': 'github',+ 'repository': 'user/repo',+ 'query': 'main',+ },+ )+ assert response.status_code == status.HTTP_401_UNAUTHORIZED+++class TestSearchSuggestedTasks:+ """Test suite for search_suggested_tasks function."""++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_returns_paginated_tasks(self, mock_handler_cls):+ """Test that suggested tasks are returned with pagination."""+ # Arrange+ mock_handler = MagicMock()+ mock_handler.get_suggested_tasks = AsyncMock(+ return_value=[+ SuggestedTask(+ git_provider=ProviderType.GITHUB,+ task_type=TaskType.OPEN_ISSUE,+ repo='user/repo',+ issue_number=1,+ title='Fix bug in login',+ ),+ SuggestedTask(+ git_provider=ProviderType.GITHUB,+ task_type=TaskType.OPEN_PR,+ repo='user/repo',+ issue_number=2,+ title='Add new feature',+ ),+ SuggestedTask(+ git_provider=ProviderType.GITHUB,+ task_type=TaskType.OPEN_ISSUE,+ repo='user/repo2',+ issue_number=3,+ title='Update documentation',+ ),+ ]+ )+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act+ result = await search_suggested_tasks(+ page_id=None,+ limit=2,+ user_context=mock_context,+ )++ # Assert+ assert len(result.items) == 2+ assert result.items[0].issue_number == 1+ assert result.items[1].issue_number == 2+ assert result.next_page_id == encode_page_id(2)++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_returns_second_page(self, mock_handler_cls):+ """Test that second page returns correct items."""+ # Arrange+ mock_handler = MagicMock()+ mock_handler.get_suggested_tasks = AsyncMock(+ return_value=[+ SuggestedTask(+ git_provider=ProviderType.GITHUB,+ task_type=TaskType.OPEN_ISSUE,+ repo='user/repo',+ issue_number=1,+ title='Fix bug in login',+ ),+ SuggestedTask(+ git_provider=ProviderType.GITHUB,+ task_type=TaskType.OPEN_PR,+ repo='user/repo',+ issue_number=2,+ title='Add new feature',+ ),+ SuggestedTask(+ git_provider=ProviderType.GITHUB,+ task_type=TaskType.OPEN_ISSUE,+ repo='user/repo2',+ issue_number=3,+ title='Update documentation',+ ),+ ]+ )+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act - request second page+ result = await search_suggested_tasks(+ page_id=encode_page_id(2),+ limit=2,+ user_context=mock_context,+ )++ # Assert+ assert len(result.items) == 1+ assert result.items[0].issue_number == 3+ assert result.next_page_id is None++ @pytest.mark.asyncio+ @patch('openhands.app_server.git.git_router.ProviderHandler')+ async def test_returns_empty_when_no_tasks(self, mock_handler_cls):+ """Test that empty results return empty items."""+ # Arrange+ mock_handler = MagicMock()+ mock_handler.get_suggested_tasks = AsyncMock(return_value=[])+ mock_handler_cls.return_value = mock_handler++ mock_context = _make_mock_user_context(+ provider_tokens={+ ProviderType.GITHUB: ProviderToken(user_id='user-123', token='token')+ },+ user_id='user-123',+ )++ # Act+ result = await search_suggested_tasks(+ page_id=None,+ limit=10,+ user_context=mock_context,+ )++ # Assert+ assert result.items == []+ assert result.next_page_id is None++ def test_returns_401_when_no_provider_tokens(self, test_client):+ """Test that 401 is returned when no provider tokens."""+ with patch(+ 'openhands.app_server.user.auth_user_context.AuthUserContext.get_provider_tokens',+ AsyncMock(return_value=None),+ ):+ response = test_client.get('/git/suggested-tasks/search')+ assert response.status_code == status.HTTP_401_UNAUTHORIZED