forked from cardosofelipe/fast-next-template
Felipe Cardoso
011b21bf0a
- Updated line breaks and indentation across test modules to enhance clarity and maintain consistent style. - Applied changes to workspace, provider, server, and GitWrapper-related test cases. No functional changes introduced.
621 lines
20 KiB
Python
621 lines
20 KiB
Python
"""
|
|
Tests for GitHub provider implementation.
|
|
"""
|
|
|
|
from unittest.mock import MagicMock
|
|
|
|
import pytest
|
|
|
|
from exceptions import APIError, AuthenticationError
|
|
from models import MergeStrategy, PRState
|
|
from providers.github import GitHubProvider
|
|
|
|
|
|
class TestGitHubProviderBasics:
|
|
"""Tests for GitHubProvider basic operations."""
|
|
|
|
def test_provider_name(self):
|
|
"""Test provider name is github."""
|
|
provider = GitHubProvider(token="test-token")
|
|
assert provider.name == "github"
|
|
|
|
def test_parse_repo_url_https(self):
|
|
"""Test parsing HTTPS repo URL."""
|
|
provider = GitHubProvider(token="test-token")
|
|
|
|
owner, repo = provider.parse_repo_url("https://github.com/owner/repo.git")
|
|
|
|
assert owner == "owner"
|
|
assert repo == "repo"
|
|
|
|
def test_parse_repo_url_https_no_git(self):
|
|
"""Test parsing HTTPS URL without .git suffix."""
|
|
provider = GitHubProvider(token="test-token")
|
|
|
|
owner, repo = provider.parse_repo_url("https://github.com/owner/repo")
|
|
|
|
assert owner == "owner"
|
|
assert repo == "repo"
|
|
|
|
def test_parse_repo_url_ssh(self):
|
|
"""Test parsing SSH repo URL."""
|
|
provider = GitHubProvider(token="test-token")
|
|
|
|
owner, repo = provider.parse_repo_url("git@github.com:owner/repo.git")
|
|
|
|
assert owner == "owner"
|
|
assert repo == "repo"
|
|
|
|
def test_parse_repo_url_invalid(self):
|
|
"""Test error on invalid URL."""
|
|
provider = GitHubProvider(token="test-token")
|
|
|
|
with pytest.raises(ValueError, match="Unable to parse"):
|
|
provider.parse_repo_url("invalid-url")
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_github_httpx_client():
|
|
"""Create a mock httpx client for GitHub provider tests."""
|
|
from unittest.mock import AsyncMock
|
|
|
|
mock_response = AsyncMock()
|
|
mock_response.status_code = 200
|
|
mock_response.json = MagicMock(return_value={})
|
|
mock_response.text = ""
|
|
|
|
mock_client = AsyncMock()
|
|
mock_client.request = AsyncMock(return_value=mock_response)
|
|
mock_client.get = AsyncMock(return_value=mock_response)
|
|
mock_client.post = AsyncMock(return_value=mock_response)
|
|
mock_client.patch = AsyncMock(return_value=mock_response)
|
|
mock_client.put = AsyncMock(return_value=mock_response)
|
|
mock_client.delete = AsyncMock(return_value=mock_response)
|
|
|
|
return mock_client
|
|
|
|
|
|
@pytest.fixture
|
|
async def github_provider(test_settings, mock_github_httpx_client):
|
|
"""Create a GitHubProvider with mocked HTTP client."""
|
|
provider = GitHubProvider(
|
|
token=test_settings.github_token,
|
|
settings=test_settings,
|
|
)
|
|
provider._client = mock_github_httpx_client
|
|
|
|
yield provider
|
|
|
|
await provider.close()
|
|
|
|
|
|
@pytest.fixture
|
|
def github_pr_data():
|
|
"""Sample PR data from GitHub API."""
|
|
return {
|
|
"number": 42,
|
|
"title": "Test PR",
|
|
"body": "This is a test pull request",
|
|
"state": "open",
|
|
"head": {"ref": "feature-branch"},
|
|
"base": {"ref": "main"},
|
|
"user": {"login": "test-user"},
|
|
"created_at": "2024-01-15T10:00:00Z",
|
|
"updated_at": "2024-01-15T12:00:00Z",
|
|
"merged_at": None,
|
|
"closed_at": None,
|
|
"html_url": "https://github.com/owner/repo/pull/42",
|
|
"labels": [{"name": "enhancement"}],
|
|
"assignees": [{"login": "assignee1"}],
|
|
"requested_reviewers": [{"login": "reviewer1"}],
|
|
"mergeable": True,
|
|
"draft": False,
|
|
}
|
|
|
|
|
|
class TestGitHubProviderConnection:
|
|
"""Tests for GitHub provider connection."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_is_connected(self, github_provider, mock_github_httpx_client):
|
|
"""Test connection check."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value={"login": "test-user"}
|
|
)
|
|
|
|
result = await github_provider.is_connected()
|
|
|
|
assert result is True
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_is_connected_no_token(self, test_settings):
|
|
"""Test connection fails without token."""
|
|
provider = GitHubProvider(
|
|
token="",
|
|
settings=test_settings,
|
|
)
|
|
|
|
result = await provider.is_connected()
|
|
assert result is False
|
|
|
|
await provider.close()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_authenticated_user(
|
|
self, github_provider, mock_github_httpx_client
|
|
):
|
|
"""Test getting authenticated user."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value={"login": "test-user"}
|
|
)
|
|
|
|
user = await github_provider.get_authenticated_user()
|
|
|
|
assert user == "test-user"
|
|
|
|
|
|
class TestGitHubProviderRepoOperations:
|
|
"""Tests for GitHub repository operations."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_repo_info(self, github_provider, mock_github_httpx_client):
|
|
"""Test getting repository info."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value={
|
|
"name": "repo",
|
|
"full_name": "owner/repo",
|
|
"default_branch": "main",
|
|
}
|
|
)
|
|
|
|
result = await github_provider.get_repo_info("owner", "repo")
|
|
|
|
assert result["name"] == "repo"
|
|
assert result["default_branch"] == "main"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_default_branch(self, github_provider, mock_github_httpx_client):
|
|
"""Test getting default branch."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value={"default_branch": "develop"}
|
|
)
|
|
|
|
branch = await github_provider.get_default_branch("owner", "repo")
|
|
|
|
assert branch == "develop"
|
|
|
|
|
|
class TestGitHubPROperations:
|
|
"""Tests for GitHub PR operations."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_create_pr(self, github_provider, mock_github_httpx_client):
|
|
"""Test creating a pull request."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value={
|
|
"number": 42,
|
|
"html_url": "https://github.com/owner/repo/pull/42",
|
|
}
|
|
)
|
|
|
|
result = await github_provider.create_pr(
|
|
owner="owner",
|
|
repo="repo",
|
|
title="Test PR",
|
|
body="Test body",
|
|
source_branch="feature",
|
|
target_branch="main",
|
|
)
|
|
|
|
assert result.success is True
|
|
assert result.pr_number == 42
|
|
assert result.pr_url == "https://github.com/owner/repo/pull/42"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_create_pr_with_draft(
|
|
self, github_provider, mock_github_httpx_client
|
|
):
|
|
"""Test creating a draft PR."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value={
|
|
"number": 43,
|
|
"html_url": "https://github.com/owner/repo/pull/43",
|
|
}
|
|
)
|
|
|
|
result = await github_provider.create_pr(
|
|
owner="owner",
|
|
repo="repo",
|
|
title="Draft PR",
|
|
body="Draft body",
|
|
source_branch="feature",
|
|
target_branch="main",
|
|
draft=True,
|
|
)
|
|
|
|
assert result.success is True
|
|
assert result.pr_number == 43
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_create_pr_with_options(
|
|
self, github_provider, mock_github_httpx_client
|
|
):
|
|
"""Test creating PR with labels, assignees, reviewers."""
|
|
mock_responses = [
|
|
{
|
|
"number": 44,
|
|
"html_url": "https://github.com/owner/repo/pull/44",
|
|
}, # Create PR
|
|
[{"name": "enhancement"}], # POST add labels
|
|
{}, # POST add assignees
|
|
{}, # POST request reviewers
|
|
]
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
side_effect=mock_responses
|
|
)
|
|
|
|
result = await github_provider.create_pr(
|
|
owner="owner",
|
|
repo="repo",
|
|
title="Test PR",
|
|
body="Test body",
|
|
source_branch="feature",
|
|
target_branch="main",
|
|
labels=["enhancement"],
|
|
assignees=["user1"],
|
|
reviewers=["reviewer1"],
|
|
)
|
|
|
|
assert result.success is True
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_pr(
|
|
self, github_provider, mock_github_httpx_client, github_pr_data
|
|
):
|
|
"""Test getting a pull request."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value=github_pr_data
|
|
)
|
|
|
|
result = await github_provider.get_pr("owner", "repo", 42)
|
|
|
|
assert result.success is True
|
|
assert result.pr["number"] == 42
|
|
assert result.pr["title"] == "Test PR"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_pr_not_found(self, github_provider, mock_github_httpx_client):
|
|
"""Test getting non-existent PR."""
|
|
mock_github_httpx_client.request.return_value.status_code = 404
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value=None
|
|
)
|
|
|
|
result = await github_provider.get_pr("owner", "repo", 999)
|
|
|
|
assert result.success is False
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_list_prs(
|
|
self, github_provider, mock_github_httpx_client, github_pr_data
|
|
):
|
|
"""Test listing pull requests."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value=[github_pr_data, github_pr_data]
|
|
)
|
|
|
|
result = await github_provider.list_prs("owner", "repo")
|
|
|
|
assert result.success is True
|
|
assert len(result.pull_requests) == 2
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_list_prs_with_state_filter(
|
|
self, github_provider, mock_github_httpx_client, github_pr_data
|
|
):
|
|
"""Test listing PRs with state filter."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value=[github_pr_data]
|
|
)
|
|
|
|
result = await github_provider.list_prs("owner", "repo", state=PRState.OPEN)
|
|
|
|
assert result.success is True
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_merge_pr(
|
|
self, github_provider, mock_github_httpx_client, github_pr_data
|
|
):
|
|
"""Test merging a pull request."""
|
|
# Merge returns sha, then get_pr returns the PR data, then delete branch
|
|
mock_responses = [
|
|
{"sha": "merge-commit-sha", "merged": True}, # PUT merge
|
|
github_pr_data, # GET PR for branch info
|
|
None, # DELETE branch
|
|
]
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
side_effect=mock_responses
|
|
)
|
|
|
|
result = await github_provider.merge_pr(
|
|
"owner",
|
|
"repo",
|
|
42,
|
|
merge_strategy=MergeStrategy.SQUASH,
|
|
)
|
|
|
|
assert result.success is True
|
|
assert result.merge_commit_sha == "merge-commit-sha"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_merge_pr_rebase(
|
|
self, github_provider, mock_github_httpx_client, github_pr_data
|
|
):
|
|
"""Test merging with rebase strategy."""
|
|
mock_responses = [
|
|
{"sha": "rebase-commit-sha", "merged": True}, # PUT merge
|
|
github_pr_data, # GET PR for branch info
|
|
None, # DELETE branch
|
|
]
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
side_effect=mock_responses
|
|
)
|
|
|
|
result = await github_provider.merge_pr(
|
|
"owner",
|
|
"repo",
|
|
42,
|
|
merge_strategy=MergeStrategy.REBASE,
|
|
)
|
|
|
|
assert result.success is True
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_pr(
|
|
self, github_provider, mock_github_httpx_client, github_pr_data
|
|
):
|
|
"""Test updating a pull request."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value=github_pr_data
|
|
)
|
|
|
|
result = await github_provider.update_pr(
|
|
"owner",
|
|
"repo",
|
|
42,
|
|
title="Updated Title",
|
|
body="Updated body",
|
|
)
|
|
|
|
assert result.success is True
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_close_pr(
|
|
self, github_provider, mock_github_httpx_client, github_pr_data
|
|
):
|
|
"""Test closing a pull request."""
|
|
github_pr_data["state"] = "closed"
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value=github_pr_data
|
|
)
|
|
|
|
result = await github_provider.close_pr("owner", "repo", 42)
|
|
|
|
assert result.success is True
|
|
|
|
|
|
class TestGitHubBranchOperations:
|
|
"""Tests for GitHub branch operations."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_branch(self, github_provider, mock_github_httpx_client):
|
|
"""Test getting branch info."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value={
|
|
"name": "main",
|
|
"commit": {"sha": "abc123"},
|
|
}
|
|
)
|
|
|
|
result = await github_provider.get_branch("owner", "repo", "main")
|
|
|
|
assert result["name"] == "main"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete_remote_branch(
|
|
self, github_provider, mock_github_httpx_client
|
|
):
|
|
"""Test deleting a remote branch."""
|
|
mock_github_httpx_client.request.return_value.status_code = 204
|
|
|
|
result = await github_provider.delete_remote_branch(
|
|
"owner", "repo", "old-branch"
|
|
)
|
|
|
|
assert result is True
|
|
|
|
|
|
class TestGitHubCommentOperations:
|
|
"""Tests for GitHub comment operations."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_pr_comment(self, github_provider, mock_github_httpx_client):
|
|
"""Test adding a comment to a PR."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value={"id": 1, "body": "Test comment"}
|
|
)
|
|
|
|
result = await github_provider.add_pr_comment(
|
|
"owner", "repo", 42, "Test comment"
|
|
)
|
|
|
|
assert result["body"] == "Test comment"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_list_pr_comments(self, github_provider, mock_github_httpx_client):
|
|
"""Test listing PR comments."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value=[
|
|
{"id": 1, "body": "Comment 1"},
|
|
{"id": 2, "body": "Comment 2"},
|
|
]
|
|
)
|
|
|
|
result = await github_provider.list_pr_comments("owner", "repo", 42)
|
|
|
|
assert len(result) == 2
|
|
|
|
|
|
class TestGitHubLabelOperations:
|
|
"""Tests for GitHub label operations."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_labels(self, github_provider, mock_github_httpx_client):
|
|
"""Test adding labels to a PR."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value=[{"name": "bug"}, {"name": "urgent"}]
|
|
)
|
|
|
|
result = await github_provider.add_labels(
|
|
"owner", "repo", 42, ["bug", "urgent"]
|
|
)
|
|
|
|
assert "bug" in result
|
|
assert "urgent" in result
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_remove_label(self, github_provider, mock_github_httpx_client):
|
|
"""Test removing a label from a PR."""
|
|
mock_responses = [
|
|
None, # DELETE label
|
|
{"labels": []}, # GET issue
|
|
]
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
side_effect=mock_responses
|
|
)
|
|
|
|
result = await github_provider.remove_label("owner", "repo", 42, "bug")
|
|
|
|
assert isinstance(result, list)
|
|
|
|
|
|
class TestGitHubReviewerOperations:
|
|
"""Tests for GitHub reviewer operations."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_request_review(self, github_provider, mock_github_httpx_client):
|
|
"""Test requesting review from users."""
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(return_value={})
|
|
|
|
result = await github_provider.request_review(
|
|
"owner", "repo", 42, ["reviewer1", "reviewer2"]
|
|
)
|
|
|
|
assert result == ["reviewer1", "reviewer2"]
|
|
|
|
|
|
class TestGitHubErrorHandling:
|
|
"""Tests for error handling in GitHub provider."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_authentication_error(
|
|
self, github_provider, mock_github_httpx_client
|
|
):
|
|
"""Test handling authentication errors."""
|
|
mock_github_httpx_client.request.return_value.status_code = 401
|
|
|
|
with pytest.raises(AuthenticationError):
|
|
await github_provider._request("GET", "/user")
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_permission_denied(self, github_provider, mock_github_httpx_client):
|
|
"""Test handling permission denied errors."""
|
|
mock_github_httpx_client.request.return_value.status_code = 403
|
|
mock_github_httpx_client.request.return_value.text = "Permission denied"
|
|
|
|
with pytest.raises(AuthenticationError, match="Insufficient permissions"):
|
|
await github_provider._request("GET", "/protected")
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_rate_limit_error(self, github_provider, mock_github_httpx_client):
|
|
"""Test handling rate limit errors."""
|
|
mock_github_httpx_client.request.return_value.status_code = 403
|
|
mock_github_httpx_client.request.return_value.text = "API rate limit exceeded"
|
|
|
|
with pytest.raises(APIError, match="rate limit"):
|
|
await github_provider._request("GET", "/user")
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_api_error(self, github_provider, mock_github_httpx_client):
|
|
"""Test handling general API errors."""
|
|
mock_github_httpx_client.request.return_value.status_code = 500
|
|
mock_github_httpx_client.request.return_value.text = "Internal Server Error"
|
|
mock_github_httpx_client.request.return_value.json = MagicMock(
|
|
return_value={"message": "Server error"}
|
|
)
|
|
|
|
with pytest.raises(APIError):
|
|
await github_provider._request("GET", "/error")
|
|
|
|
|
|
class TestGitHubPRParsing:
|
|
"""Tests for PR data parsing."""
|
|
|
|
def test_parse_pr_open(self, github_provider, github_pr_data):
|
|
"""Test parsing open PR."""
|
|
pr_info = github_provider._parse_pr(github_pr_data)
|
|
|
|
assert pr_info.number == 42
|
|
assert pr_info.state == PRState.OPEN
|
|
assert pr_info.title == "Test PR"
|
|
assert pr_info.source_branch == "feature-branch"
|
|
assert pr_info.target_branch == "main"
|
|
|
|
def test_parse_pr_merged(self, github_provider, github_pr_data):
|
|
"""Test parsing merged PR."""
|
|
github_pr_data["merged_at"] = "2024-01-16T10:00:00Z"
|
|
|
|
pr_info = github_provider._parse_pr(github_pr_data)
|
|
|
|
assert pr_info.state == PRState.MERGED
|
|
|
|
def test_parse_pr_closed(self, github_provider, github_pr_data):
|
|
"""Test parsing closed PR."""
|
|
github_pr_data["state"] = "closed"
|
|
github_pr_data["closed_at"] = "2024-01-16T10:00:00Z"
|
|
|
|
pr_info = github_provider._parse_pr(github_pr_data)
|
|
|
|
assert pr_info.state == PRState.CLOSED
|
|
|
|
def test_parse_pr_draft(self, github_provider, github_pr_data):
|
|
"""Test parsing draft PR."""
|
|
github_pr_data["draft"] = True
|
|
|
|
pr_info = github_provider._parse_pr(github_pr_data)
|
|
|
|
assert pr_info.draft is True
|
|
|
|
def test_parse_datetime_iso(self, github_provider):
|
|
"""Test parsing ISO datetime strings."""
|
|
dt = github_provider._parse_datetime("2024-01-15T10:30:00Z")
|
|
|
|
assert dt.year == 2024
|
|
assert dt.month == 1
|
|
assert dt.day == 15
|
|
|
|
def test_parse_datetime_none(self, github_provider):
|
|
"""Test parsing None datetime returns now."""
|
|
dt = github_provider._parse_datetime(None)
|
|
|
|
assert dt is not None
|
|
assert dt.tzinfo is not None
|
|
|
|
def test_parse_pr_with_null_body(self, github_provider, github_pr_data):
|
|
"""Test parsing PR with null body."""
|
|
github_pr_data["body"] = None
|
|
|
|
pr_info = github_provider._parse_pr(github_pr_data)
|
|
|
|
assert pr_info.body == ""
|