Support compare URLs in extract_upstream_repository

Fetch commit lists from compare URLs for cherry-pick workflow.

Author: opohorel

agents/tests/unit/test_tools.py

@@ -48,6 +48,10 @@
     SearchTextToolInput,
 )
 from tools.filesystem import GetCWDTool, GetCWDToolInput, RemoveTool, RemoveToolInput
+from tools.upstream_tools import (
+    ExtractUpstreamRepositoryTool,
+    ExtractUpstreamRepositoryInput,
+)
 
 
 @pytest.mark.parametrize(
@@ -706,3 +710,276 @@ async def test_find_rej_files(git_repo):
     (git_repo / "foo-bar.rej").write_text("rej content 2")
     result = await find_rej_files(git_repo)
     assert sorted(result) == sorted(["file.txt.rej", "foo-bar.rej"])
+
+
+# Tests for ExtractUpstreamRepositoryTool
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "url, expected_owner, expected_repo, expected_commit",
+    [
+        # Regular commit URLs
+        (
+            "https://github.com/owner/repo/commit/abc123def456",
+            "owner",
+            "repo",
+            "abc123def456",
+        ),
+        (
+            "https://github.com/owner/repo/commit/abc123def456.patch",
+            "owner",
+            "repo",
+            "abc123def456",
+        ),
+        (
+            "https://gitlab.com/owner/repo/-/commit/abc123def456",
+            "owner",
+            "repo",
+            "abc123def456",
+        ),
+    ],
+)
+async def test_extract_upstream_repository_commit_url(url, expected_owner, expected_repo, expected_commit):
+    """Test that regular commit URLs are properly parsed without API calls."""
+    tool = ExtractUpstreamRepositoryTool()
+    
+    output = await tool.run(
+        input=ExtractUpstreamRepositoryInput(upstream_fix_url=url)
+    ).middleware(GlobalTrajectoryMiddleware(pretty=True))
+    
+    result = output.to_json_safe()
+    
+    # Verify the results
+    expected_netloc = "github.com" if "github" in url else "gitlab.com"
+    assert result.repo_url == f"https://{expected_netloc}/{expected_owner}/{expected_repo}.git"
+    assert result.commit_hash == expected_commit
+    assert result.is_pr is False
+    assert result.is_compare is False
+
+
+@pytest.mark.asyncio
+async def test_extract_upstream_repository_pr_url():
+    """Test that PR URLs fetch commit hash from GitHub API."""
+    import aiohttp
+    from unittest.mock import AsyncMock, MagicMock, patch
+    
+    tool = ExtractUpstreamRepositoryTool()
+    url = "https://github.com/owner/repo/pull/123"
+    
+    # Mock GitHub API response
+    mock_data = {"head": {"sha": "pr_commit_hash_abc123"}}
+    
+    mock_response = AsyncMock()
+    mock_response.status = 200
+    mock_response.raise_for_status = MagicMock()
+    mock_response.json = AsyncMock(return_value=mock_data)
+    mock_response.__aenter__ = AsyncMock(return_value=mock_response)
+    mock_response.__aexit__ = AsyncMock(return_value=None)
+    
+    mock_session = MagicMock()
+    mock_session.get = MagicMock(return_value=mock_response)
+    mock_session.__aenter__ = AsyncMock(return_value=mock_session)
+    mock_session.__aexit__ = AsyncMock(return_value=None)
+    
+    with patch('tools.upstream_tools.aiohttp.ClientSession', return_value=mock_session):
+        output = await tool.run(
+            input=ExtractUpstreamRepositoryInput(upstream_fix_url=url)
+        ).middleware(GlobalTrajectoryMiddleware(pretty=True))
+    
+    result = output.to_json_safe()
+    
+    # Verify the results
+    assert result.repo_url == "https://github.com/owner/repo.git"
+    assert result.commit_hash == "pr_commit_hash_abc123"
+    assert result.is_pr is True
+    assert result.pr_number == "123"
+    assert result.is_compare is False
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "url, expected_owner, expected_repo, expected_base_ref, expected_target_ref, is_github",
+    [
+        (
+            "https://github.com/git-lfs/git-lfs/compare/v3.7.0...v3.7.1",
+            "git-lfs",
+            "git-lfs",
+            "v3.7.0",
+            "v3.7.1",
+            True,
+        ),
+        (
+            "https://github.com/owner/repo/compare/v1.0.0...v2.0.0.patch",
+            "owner",
+            "repo",
+            "v1.0.0",
+            "v2.0.0",
+            True,
+        ),
+        (
+            "https://gitlab.com/owner/project/-/compare/release-1.0...release-2.0",
+            "owner",
+            "project",
+            "release-1.0",
+            "release-2.0",
+            False,
+        ),
+        (
+            "https://github.com/libsndfile/libsndfile/compare/1.2.2..1.2.3",
+            "libsndfile",
+            "libsndfile",
+            "1.2.2",
+            "1.2.3",
+            True,
+        ),
+    ],
+)
+async def test_extract_upstream_repository_compare_url(
+    url, expected_owner, expected_repo, expected_base_ref, expected_target_ref, is_github
+):
+    """Test that compare URLs are properly parsed and repository info is extracted."""
+    import aiohttp
+    from unittest.mock import AsyncMock, MagicMock, patch
+    
+    tool = ExtractUpstreamRepositoryTool()
+    
+    # Create mock response data
+    if is_github:
+        mock_data = {
+            "commits": [
+                {"sha": "abc123"},
+                {"sha": "def456"},
+                {"sha": "ghi789"}
+            ]
+        }
+    else:
+        # GitLab returns commits in reverse order (newest first)
+        mock_data = {
+            "commits": [
+                {"id": "ghi789"},
+                {"id": "def456"},
+                {"id": "abc123"}
+            ]
+        }
+    
+    # Mock the aiohttp session and response
+    mock_response = AsyncMock()
+    mock_response.status = 200
+    mock_response.raise_for_status = MagicMock()
+    mock_response.json = AsyncMock(return_value=mock_data)
+    mock_response.__aenter__ = AsyncMock(return_value=mock_response)
+    mock_response.__aexit__ = AsyncMock(return_value=None)
+    
+    mock_session = MagicMock()
+    mock_session.get = MagicMock(return_value=mock_response)
+    mock_session.__aenter__ = AsyncMock(return_value=mock_session)
+    mock_session.__aexit__ = AsyncMock(return_value=None)
+    
+    with patch('tools.upstream_tools.aiohttp.ClientSession', return_value=mock_session):
+        output = await tool.run(
+            input=ExtractUpstreamRepositoryInput(upstream_fix_url=url)
+        ).middleware(GlobalTrajectoryMiddleware(pretty=True))
+    
+    result = output.to_json_safe()
+    
+    # Verify the results
+    expected_netloc = "github.com" if is_github else "gitlab.com"
+    assert result.repo_url == f"https://{expected_netloc}/{expected_owner}/{expected_repo}.git"
+    assert result.is_compare is True
+    assert result.is_pr is False
+    assert result.base_ref == expected_base_ref
+    assert result.target_ref == expected_target_ref
+    assert result.compare_commits == ["abc123", "def456", "ghi789"]
+    assert result.commit_hash == "ghi789"  # Should be the last (newest) commit
+
+
+@pytest.mark.asyncio
+async def test_extract_upstream_repository_compare_url_with_special_chars():
+    """Test that compare URLs with special characters in refs are properly URL-encoded."""
+    import aiohttp
+    from unittest.mock import AsyncMock, MagicMock, patch
+    
+    tool = ExtractUpstreamRepositoryTool()
+    url = "https://github.com/owner/repo/compare/feature/branch-1...bugfix/issue-123"
+    
+    mock_data = {
+        "commits": [
+            {"sha": "commit1"},
+            {"sha": "commit2"}
+        ]
+    }
+    
+    mock_response = AsyncMock()
+    mock_response.status = 200
+    mock_response.raise_for_status = MagicMock()
+    mock_response.json = AsyncMock(return_value=mock_data)
+    mock_response.__aenter__ = AsyncMock(return_value=mock_response)
+    mock_response.__aexit__ = AsyncMock(return_value=None)
+    
+    mock_session = MagicMock()
+    mock_session.get = MagicMock(return_value=mock_response)
+    mock_session.__aenter__ = AsyncMock(return_value=mock_session)
+    mock_session.__aexit__ = AsyncMock(return_value=None)
+    
+    with patch('tools.upstream_tools.aiohttp.ClientSession', return_value=mock_session):
+        output = await tool.run(
+            input=ExtractUpstreamRepositoryInput(upstream_fix_url=url)
+        ).middleware(GlobalTrajectoryMiddleware(pretty=True))
+    
+    result = output.to_json_safe()
+    
+    # Verify URL encoding happened
+    call_args = mock_session.get.call_args
+    called_url = call_args[0][0]
+    
+    # Check that slashes in branch names were URL-encoded
+    assert "feature%2Fbranch-1" in called_url
+    assert "bugfix%2Fissue-123" in called_url
+    assert result.base_ref == "feature/branch-1"
+    assert result.target_ref == "bugfix/issue-123"
+
+
+@pytest.mark.asyncio
+async def test_extract_upstream_repository_compare_url_api_failure():
+    """Test that compare URLs gracefully fall back when API fails."""
+    import aiohttp
+    from unittest.mock import AsyncMock, MagicMock, patch
+    
+    tool = ExtractUpstreamRepositoryTool()
+    url = "https://github.com/owner/repo/compare/v1.0.0...v2.0.0"
+    
+    # Mock aiohttp session to raise aiohttp.ClientError
+    mock_response = AsyncMock()
+    mock_response.raise_for_status = MagicMock(side_effect=aiohttp.ClientError("API Error"))
+    mock_response.__aenter__ = AsyncMock(return_value=mock_response)
+    mock_response.__aexit__ = AsyncMock(return_value=None)
+    
+    mock_session = MagicMock()
+    mock_session.get = MagicMock(return_value=mock_response)
+    mock_session.__aenter__ = AsyncMock(return_value=mock_session)
+    mock_session.__aexit__ = AsyncMock(return_value=None)
+    
+    with patch('tools.upstream_tools.aiohttp.ClientSession', return_value=mock_session):
+        output = await tool.run(
+            input=ExtractUpstreamRepositoryInput(upstream_fix_url=url)
+        ).middleware(GlobalTrajectoryMiddleware(pretty=True))
+    
+    result = output.to_json_safe()
+    
+    # Should fall back gracefully
+    assert result.is_compare is True
+    assert result.commit_hash == "v2.0.0"  # Falls back to target_ref
+    assert result.compare_commits is None  # No commits fetched
+
+
+@pytest.mark.asyncio
+async def test_extract_upstream_repository_invalid_url():
+    """Test that invalid URLs raise appropriate errors."""
+    tool = ExtractUpstreamRepositoryTool()
+    url = "https://github.com/invalid/url/structure"
+    
+    with pytest.raises(ToolError) as exc_info:
+        await tool.run(
+            input=ExtractUpstreamRepositoryInput(upstream_fix_url=url)
+        ).middleware(GlobalTrajectoryMiddleware(pretty=True))
+    
+    assert "Could not extract commit hash from URL" in str(exc_info.value)