use async_trait::async_trait;
use gitflow_core::{
CoreError, Result,
pr::{CreatePrArgs, ListPrArgs, PrData, PrProvider},
types::{CommentData, MergeResult, MergeStrategy, State},
};
use tracing::debug;
use crate::{
error::parse_gh_error,
runner::{CommandRunner, RealCommandRunner},
};
const PR_FIELDS: &str =
"number,title,body,state,isDraft,author,baseRefName,headRefName,createdAt,updatedAt,url";
#[derive(Debug, Clone)]
pub struct GitHubPrProvider<R: CommandRunner = RealCommandRunner> {
repo: String,
runner: R,
}
impl GitHubPrProvider<RealCommandRunner> {
#[must_use]
pub fn new(repo: impl Into<String>) -> Self {
Self {
repo: repo.into(),
runner: RealCommandRunner,
}
}
}
impl<R: CommandRunner> GitHubPrProvider<R> {
#[must_use]
pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
Self {
repo: repo.into(),
runner,
}
}
}
#[async_trait]
impl<R: CommandRunner + 'static> PrProvider for GitHubPrProvider<R> {
async fn create(&self, args: CreatePrArgs) -> Result<PrData> {
let repo = args.repo.as_deref().unwrap_or(&self.repo);
let mut cmd_args: Vec<&str> = vec![
"pr",
"create",
"--repo",
repo,
"--title",
&args.title,
"--head",
&args.head,
"--base",
&args.base,
];
if let Some(body) = &args.body {
cmd_args.push("--body");
cmd_args.push(body);
}
if args.draft {
cmd_args.push("--draft");
}
debug!(
repo = %self.repo,
title = %args.title,
head = %args.head,
base = %args.base,
"spawning `gh pr create`"
);
let output = self
.runner
.run("gh", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
let stdout = String::from_utf8_lossy(&output.stdout);
let pr_number = parse_pr_number_from_url(&stdout).ok_or_else(|| {
CoreError::Platform(format!("Failed to parse PR URL from output: {stdout}"))
})?;
self.view(pr_number).await
}
async fn list(&self, args: ListPrArgs) -> Result<Vec<PrData>> {
let mut cmd_args: Vec<&str> = vec!["pr", "list", "--repo", &self.repo, "--json", PR_FIELDS];
if let Some(state) = &args.state {
cmd_args.push("--state");
cmd_args.push(match state {
State::Open => "open",
State::Closed => "closed",
});
}
let limit_str = args.limit.map(|limit| limit.to_string());
if let Some(ref limit) = limit_str {
cmd_args.push("--limit");
cmd_args.push(limit);
}
debug!(repo = %self.repo, "spawning `gh pr list`");
let output = self
.runner
.run("gh", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
let prs: Vec<PrData> =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(prs)
}
async fn view(&self, number: u64) -> Result<PrData> {
debug!(repo = %self.repo, number, "spawning `gh pr view`");
let number_str = number.to_string();
let output = self
.runner
.run(
"gh",
&[
"pr",
"view",
&number_str,
"--repo",
&self.repo,
"--json",
PR_FIELDS,
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
let pr: PrData =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(pr)
}
async fn close(&self, number: u64) -> Result<PrData> {
debug!(repo = %self.repo, number, "spawning `gh pr close`");
let number_str = number.to_string();
let output = self
.runner
.run("gh", &["pr", "close", &number_str, "--repo", &self.repo])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
self.view(number).await
}
async fn reopen(&self, number: u64) -> Result<PrData> {
debug!(repo = %self.repo, number, "spawning `gh pr reopen`");
let number_str = number.to_string();
let output = self
.runner
.run("gh", &["pr", "reopen", &number_str, "--repo", &self.repo])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
self.view(number).await
}
async fn comment(&self, number: u64, body: &str) -> Result<CommentData> {
debug!(repo = %self.repo, number, "spawning `gh api` POST to create PR comment");
let api_path = format!(
"repos/{repo}/issues/{number}/comments",
repo = self.repo,
number = number
);
let body_field = format!("body={body}");
let output = self
.runner
.run("gh", &["api", &api_path, "-X", "POST", "-f", &body_field])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh api: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
let comment: crate::issue::GitHubCommentApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(comment.into())
}
async fn merge(&self, number: u64, strategy: Option<MergeStrategy>) -> Result<MergeResult> {
debug!(repo = %self.repo, number, ?strategy, "spawning `gh pr merge`");
let number_str = number.to_string();
let mut cmd_args: Vec<&str> = vec!["pr", "merge", &number_str, "--repo", &self.repo];
match strategy {
Some(MergeStrategy::Squash) => cmd_args.push("--squash"),
Some(MergeStrategy::Rebase) => cmd_args.push("--rebase"),
Some(MergeStrategy::Merge) | None => cmd_args.push("--merge"),
}
let output = self
.runner
.run("gh", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
let message = String::from_utf8_lossy(&output.stdout).trim().to_string();
Ok(MergeResult {
merged: true,
sha: None,
message: Some(message),
})
}
async fn checkout(&self, number: u64) -> Result<()> {
debug!(repo = %self.repo, number, "spawning `gh pr checkout`");
let number_str = number.to_string();
let output = self
.runner
.run("gh", &["pr", "checkout", &number_str, "--repo", &self.repo])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
Ok(())
}
async fn mark_ready(&self, number: u64) -> Result<PrData> {
debug!(repo = %self.repo, number, "spawning `gh pr ready`");
let number_str = number.to_string();
let output = self
.runner
.run("gh", &["pr", "ready", &number_str, "--repo", &self.repo])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
self.view(number).await
}
async fn mark_wip(&self, number: u64) -> Result<PrData> {
debug!(repo = %self.repo, number, "spawning `gh pr convert-to-draft`");
let number_str = number.to_string();
let output = self
.runner
.run(
"gh",
&["pr", "convert-to-draft", &number_str, "--repo", &self.repo],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
self.view(number).await
}
async fn sync_branch(&self, number: u64) -> Result<()> {
debug!(repo = %self.repo, number, "spawning `gh pr update-branch`");
let number_str = number.to_string();
let output = self
.runner
.run(
"gh",
&["pr", "update-branch", &number_str, "--repo", &self.repo],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
Ok(())
}
}
fn parse_pr_number_from_url(url: &str) -> Option<u64> {
url.lines().find_map(|line| {
let line = line.trim();
if line.contains("/pull/") {
line.rsplit('/').next().and_then(|s| s.parse().ok())
} else {
None
}
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::runner::MockCommandRunner;
#[test]
fn test_should_construct_github_pr_provider() {
let provider = GitHubPrProvider::new("octocat/hello-world");
assert_eq!(provider.repo, "octocat/hello-world");
}
#[test]
fn test_should_construct_github_pr_provider_from_string() {
let repo = String::from("octocat/hello-world");
let provider = GitHubPrProvider::new(repo);
assert_eq!(provider.repo, "octocat/hello-world");
}
#[test]
fn test_should_deserialize_pr_data_from_gh_output() {
let gh_json = br#"{
"number": 123,
"title": "Add new feature",
"body": "This PR adds a new feature",
"state": "open",
"draft": false,
"author": {"login": "alice", "id": "2"},
"baseBranch": "main",
"headBranch": "feature/new-thing",
"createdAt": "2026-02-20T14:00:00Z",
"updatedAt": "2026-02-21T10:30:00Z",
"url": "https://github.com/octocat/hello-world/pull/123"
}"#;
let pr: PrData = serde_json::from_slice(gh_json).expect("valid PrData JSON");
assert_eq!(pr.number, 123);
assert_eq!(pr.title, "Add new feature");
assert_eq!(pr.state, State::Open);
assert!(!pr.draft);
assert_eq!(pr.author.login, "alice");
assert_eq!(pr.base_branch, "main");
assert_eq!(pr.head_branch, "feature/new-thing");
assert_eq!(pr.url, "https://github.com/octocat/hello-world/pull/123");
}
#[test]
fn test_should_deserialize_empty_pr_list_from_gh_output() {
let gh_json = b"[]";
let prs: Vec<PrData> = serde_json::from_slice(gh_json).expect("valid PrData list");
assert!(prs.is_empty());
}
#[test]
fn test_should_deserialize_draft_pr_from_gh_output() {
let gh_json = br#"{
"number": 456,
"title": "WIP: experiment",
"body": null,
"state": "open",
"draft": true,
"author": {"login": "bob", "id": "3"},
"baseBranch": "main",
"headBranch": "wip/experiment",
"createdAt": "2026-03-10T09:00:00Z",
"updatedAt": "2026-03-10T09:00:00Z",
"url": "https://github.com/octocat/hello-world/pull/456"
}"#;
let pr: PrData = serde_json::from_slice(gh_json).expect("valid PrData JSON");
assert!(pr.draft);
assert!(pr.body.is_none());
assert_eq!(pr.title, "WIP: experiment");
}
#[test]
fn test_should_debug_format_provider() {
let provider = GitHubPrProvider::new("octocat/hello-world");
let debug = format!("{provider:?}");
assert!(debug.contains("GitHubPrProvider"));
assert!(debug.contains("octocat/hello-world"));
}
#[test]
fn test_should_deserialize_closed_pr_from_gh_close_output() {
let gh_json = br#"{
"number": 50,
"title": "Obsolete change",
"body": "Superseded by #55",
"state": "closed",
"draft": false,
"author": {"login": "dev", "id": "10"},
"baseBranch": "main",
"headBranch": "feature/obsolete",
"createdAt": "2026-05-01T08:00:00Z",
"updatedAt": "2026-05-02T12:00:00Z",
"url": "https://github.com/octocat/hello-world/pull/50"
}"#;
let pr: PrData = serde_json::from_slice(gh_json).expect("valid closed PrData");
assert_eq!(pr.number, 50);
assert_eq!(pr.state, State::Closed);
}
#[test]
fn test_should_deserialize_reopened_pr_from_gh_reopen_output() {
let gh_json = br#"{
"number": 50,
"title": "Obsolete change",
"body": "Actually still needed",
"state": "open",
"draft": false,
"author": {"login": "dev", "id": "10"},
"baseBranch": "main",
"headBranch": "feature/obsolete",
"createdAt": "2026-05-01T08:00:00Z",
"updatedAt": "2026-05-03T09:00:00Z",
"url": "https://github.com/octocat/hello-world/pull/50"
}"#;
let pr: PrData = serde_json::from_slice(gh_json).expect("valid reopened PrData");
assert_eq!(pr.number, 50);
assert_eq!(pr.state, State::Open);
}
#[test]
fn test_should_deserialize_comment_data_from_gh_pr_comment_output() {
let gh_json = br#"{
"id": 2002,
"body": "Approved, merging now.",
"author": {"login": "reviewer", "id": "88"},
"createdAt": "2026-06-20T16:00:00Z"
}"#;
let comment: CommentData = serde_json::from_slice(gh_json).expect("valid CommentData");
assert_eq!(comment.id, 2002);
assert_eq!(comment.body, "Approved, merging now.");
assert_eq!(comment.author.login, "reviewer");
assert_eq!(comment.author.id, "88");
}
#[tokio::test]
async fn test_should_return_newly_created_pr_comment_not_stale() {
use crate::runner::MockCommandRunner;
let post_response_json = r#"{
"id": 8888888888,
"body": "NEW PR comment",
"user": {"login": "reviewer", "id": 99},
"created_at": "2026-08-04T13:00:00Z"
}"#;
let runner = MockCommandRunner::success(post_response_json);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.comment(7, "NEW PR comment").await.unwrap();
assert_eq!(result.id, 8_888_888_888);
assert_eq!(result.body, "NEW PR comment");
assert_eq!(result.author.login, "reviewer");
}
#[tokio::test]
async fn test_should_return_error_when_pr_comment_api_fails() {
use crate::runner::MockCommandRunner;
let runner = MockCommandRunner::failure(
r#"{"message": "Not Found", "documentation_url": "https://docs.github.com"}"#,
1,
);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.comment(999, "test").await;
assert!(result.is_err());
let err = result.unwrap_err();
assert!(
matches!(err, CoreError::Cli(_)),
"expected Cli error, got: {err:?}"
);
}
#[test]
fn test_should_deserialize_merge_result_from_gh_merge_output() {
let gh_text = b"Pull request #123 was successfully merged.\n";
let message = String::from_utf8_lossy(gh_text).trim().to_string();
let result = MergeResult {
merged: true,
sha: None,
message: Some(message),
};
assert!(result.merged);
assert!(result.message.as_deref().is_some());
assert_eq!(
result.message.as_deref(),
Some("Pull request #123 was successfully merged.")
);
}
#[test]
fn test_should_roundtrip_merge_result_via_serde() {
let result = MergeResult {
merged: true,
sha: Some("deadbeef1234".into()),
message: Some("Squash merged".into()),
};
let json = serde_json::to_string(&result).expect("serialize");
let round_tripped: MergeResult = serde_json::from_str(&json).expect("deserialize");
assert!(round_tripped.merged);
assert_eq!(round_tripped.sha, result.sha);
assert_eq!(round_tripped.message, result.message);
}
#[test]
fn test_should_serialize_merge_result_skips_null_fields() {
let result = MergeResult {
merged: false,
sha: None,
message: None,
};
let json = serde_json::to_string(&result).expect("serialize");
assert!(!json.contains("null"));
assert_eq!(json, r#"{"merged":false}"#);
}
#[test]
fn test_should_create_provider_with_different_repos() {
let r1 = GitHubPrProvider::new("org/repo-a");
let r2 = GitHubPrProvider::new("org/repo-b");
assert_eq!(r1.repo, "org/repo-a");
assert_eq!(r2.repo, "org/repo-b");
}
#[test]
fn test_should_clone_github_pr_provider() {
let original = GitHubPrProvider::new("owner/repo");
let cloned = original.clone();
assert_eq!(original.repo, cloned.repo);
}
fn sample_create_args() -> CreatePrArgs {
CreatePrArgs {
title: "Add feature".to_string(),
body: Some("Detailed description".to_string()),
head: "feature/new".to_string(),
base: "main".to_string(),
draft: false,
repo: None,
}
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_create() {
let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.create(sample_create_args()).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_on_url_parse_failure_for_create() {
let runner = MockCommandRunner::success("no pull url here");
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.create(sample_create_args()).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Platform(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_list() {
let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.list(ListPrArgs::default()).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_list() {
let runner = MockCommandRunner::success("invalid json");
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.list(ListPrArgs::default()).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_view() {
let runner = MockCommandRunner::failure(r#"{"message": "PR not found"}"#, 256);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.view(999).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_view() {
let runner = MockCommandRunner::success("invalid json");
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.view(1).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_close() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.close(42).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_reopen() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.reopen(42).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_merge() {
let runner = MockCommandRunner::failure(r#"{"message": "Merge conflict"}"#, 256);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.merge(42, None).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_on_invalid_json_for_merge() {
let runner = MockCommandRunner::failure("invalid json", 256);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.merge(42, Some(MergeStrategy::Squash)).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_checkout() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.checkout(42).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_sync_branch() {
let runner = MockCommandRunner::failure(r#"{"message": "Conflict"}"#, 256);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.sync_branch(42).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_mark_ready() {
let runner = MockCommandRunner::failure(r#"{"message": "Not a draft"}"#, 256);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.mark_ready(42).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_mark_wip() {
let runner = MockCommandRunner::failure(r#"{"message": "Already a draft"}"#, 256);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.mark_wip(42).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_comment() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.comment(42, "a comment").await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
}