use async_trait::async_trait;
use gitflow_core::{
CoreError, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, fetch_capped,
pr::{CreatePrArgs, ListPrArgs, PrData, PrProvider},
types::{CommentData, MergeResult, MergeStrategy, State},
};
use serde::Deserialize;
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,mergedAt,milestone,url";
#[derive(Debug, Deserialize)]
struct RepoViewResponse {
#[serde(rename = "defaultBranchRef")]
default_branch_ref: DefaultBranchRef,
}
#[derive(Debug, Deserialize)]
struct DefaultBranchRef {
name: String,
}
#[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,
}
}
#[must_use]
pub fn with_session(session: &gitflow_core::Session) -> Self {
Self {
repo: session.repo.clone(),
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 fn list_impl(&self, args: ListPrArgs) -> Result<Paged<PrData>> {
let cap = args.limit.unwrap_or(DEFAULT_LIST_LIMIT);
let state = args.state.map(|state| match state {
State::Open => "open",
State::Closed => "closed",
State::All => "all",
});
let repo = &self.repo;
let runner = &self.runner;
debug!(repo = %self.repo, cap, "spawning `gh pr list`");
fetch_capped(FetchStrategy::SingleShot, cap, |_page, limit| async move {
let limit_str = limit.to_string();
let mut cmd_args: Vec<&str> = vec!["pr", "list", "--repo", repo, "--json", PR_FIELDS];
if let Some(state) = state {
cmd_args.push("--state");
cmd_args.push(state);
}
cmd_args.push("--limit");
cmd_args.push(&limit_str);
let output = 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)
})
.await
}
}
#[async_trait]
impl<R: CommandRunner + Clone + '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,
];
let final_body =
gitflow_core::pr::format_closing_body(&args.body, &args.closes_issues, "Closes");
if let Some(body) = &final_body {
cmd_args.push("--body");
cmd_args.push(body);
}
if args.draft {
cmd_args.push("--draft");
}
let resolved_milestone_title;
if let Some(identifier) = &args.milestone {
let milestone_provider =
crate::GitHubMilestoneProvider::with_runner(repo, self.runner.clone());
let resolved =
gitflow_core::label::resolve_milestone_identifier(&milestone_provider, identifier)
.await?;
resolved_milestone_title = resolved.title;
cmd_args.push("--milestone");
cmd_args.push(&resolved_milestone_title);
}
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<Paged<PrData>> {
self.list_impl(args).await
}
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>,
auto: bool,
) -> Result<MergeResult> {
debug!(repo = %self.repo, number, ?strategy, auto, "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"),
}
if auto {
cmd_args.push("--auto");
}
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();
let message = if message.is_empty() && auto {
"已排队合并:GitHub 将在必需检查通过后自动合并".to_string()
} else {
message
};
Ok(MergeResult {
merged: !auto,
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(())
}
async fn diff(&self, number: u64) -> Result<String> {
debug!(repo = %self.repo, number, "spawning `gh pr diff`");
let number_str = number.to_string();
let output = self
.runner
.run("gh", &["pr", "diff", &number_str, "--repo", &self.repo])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh pr diff: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
Ok(String::from_utf8_lossy(&output.stdout).into_owned())
}
async fn patch(&self, number: u64) -> Result<String> {
debug!(repo = %self.repo, number, "spawning `gh api pr patch`");
let api_path = format!(
"repos/{repo}/pulls/{number}",
repo = self.repo,
number = number
);
let output = self
.runner
.run(
"gh",
&[
"api",
&api_path,
"-H",
"Accept: application/vnd.github.v3.patch",
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh api pr patch: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
Ok(String::from_utf8_lossy(&output.stdout).into_owned())
}
async fn default_branch(&self) -> Result<String> {
debug!(repo = %self.repo, "spawning `gh repo view`");
let output = self
.runner
.run(
"gh",
&[
"repo",
"view",
"--repo",
&self.repo,
"--json",
"defaultBranchRef",
],
)
.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 resp: RepoViewResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(resp.default_branch_ref.name)
}
}
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, SequencedMockCommandRunner};
#[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_pr_with_missing_timestamps_as_none() {
let gh_json = br#"{
"number": 9,
"title": "No timestamps",
"state": "open",
"draft": false,
"author": {"login": "octocat", "id": "1"},
"baseBranch": "main",
"headBranch": "feature/x",
"mergedAt": null,
"url": "https://github.com/octocat/hello-world/pull/9"
}"#;
let pr: PrData =
serde_json::from_slice(gh_json).expect("missing timestamps must not error");
assert!(pr.created_at.is_none());
assert!(pr.updated_at.is_none());
}
#[test]
fn test_should_distinguish_merged_from_closed_via_merged_at() {
let merged: PrData = serde_json::from_slice(
br#"{
"number": 1, "title": "m", "state": "merged", "draft": false,
"author": {"login": "alice", "id": "2"},
"baseBranch": "main", "headBranch": "feature/m",
"createdAt": "2026-02-20T14:00:00Z", "updatedAt": "2026-02-21T10:30:00Z",
"mergedAt": "2026-02-21T10:30:00Z",
"url": "https://github.com/o/r/pull/1"
}"#,
)
.expect("merged PrData");
let closed_unmerged: PrData = serde_json::from_slice(
br#"{
"number": 2, "title": "c", "state": "closed", "draft": false,
"author": {"login": "alice", "id": "2"},
"baseBranch": "main", "headBranch": "feature/c",
"createdAt": "2026-02-20T14:00:00Z", "updatedAt": "2026-02-21T10:30:00Z",
"mergedAt": null,
"url": "https://github.com/o/r/pull/2"
}"#,
)
.expect("closed PrData");
assert_eq!(merged.state, closed_unmerged.state, "state alone is equal");
assert!(
merged.merged_at.is_some(),
"mergedAt must populate merged_at"
);
assert!(
closed_unmerged.merged_at.is_none(),
"null mergedAt must stay None, not become some timestamp"
);
}
#[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);
}
#[test]
fn test_should_parse_pr_number_from_url() {
assert_eq!(
parse_pr_number_from_url("https://github.com/owner/repo/pull/123"),
Some(123)
);
assert_eq!(
parse_pr_number_from_url("https://github.enterprise.com/org/project/pull/456"),
Some(456)
);
}
#[test]
fn test_should_parse_pr_number_from_multiline_output() {
let output = "some header\nhttps://github.com/owner/repo/pull/789\nsome footer";
assert_eq!(parse_pr_number_from_url(output), Some(789));
}
#[test]
fn test_should_return_none_when_no_pr_url() {
assert_eq!(parse_pr_number_from_url("no pull url here"), None);
assert_eq!(parse_pr_number_from_url(""), None);
assert_eq!(
parse_pr_number_from_url("https://github.com/owner/repo/issues/123"),
None
);
}
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,
closes_issues: vec![],
milestone: None,
}
}
#[test]
fn test_should_format_github_body_with_closing_issues() {
use gitflow_core::pr::format_closing_body;
let body = Some("Feature description".to_string());
let issues = vec![24u64, 23];
let result = format_closing_body(&body, &issues, "Closes");
assert_eq!(
result,
Some("Feature description\n\nCloses #24\nCloses #23".to_string())
);
}
#[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, false).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_forward_auto_and_report_not_merged_for_queued_merge() {
let runner = MockCommandRunner::success("");
let provider = GitHubPrProvider::with_runner("owner/repo", runner.clone());
let result = provider
.merge(42, Some(MergeStrategy::Squash), true)
.await
.expect("queued merge should succeed");
let args = &runner.recorded_calls()[0].1;
assert!(
args.iter().any(|a| a == "--auto"),
"`--auto` must be forwarded to gh, got {args:?}"
);
assert!(
!result.merged,
"a scheduled merge has not landed, so merged must be false"
);
let message = result.message.unwrap_or_default();
assert!(
message.contains("排队"),
"empty gh stdout must be replaced by a scheduled-merge message, got {message:?}"
);
}
#[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), false).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(_)
));
}
#[tokio::test]
async fn test_should_fetch_pr_diff() {
let diff_output = "diff --git a/file.txt b/file.txt\nindex 1234567..abcdefg 100644\n--- \
a/file.txt\n+++ b/file.txt\n@@ -1 +1 @@\n-old\n+new\n";
let runner = MockCommandRunner::success(diff_output);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.diff(42).await.expect("diff should succeed");
assert_eq!(result, diff_output);
}
#[tokio::test]
async fn test_should_return_error_when_pr_diff_fails() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.diff(999).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_fetch_pr_patch() {
let patch_output =
"From abc123\nSubject: [PATCH] Update file\n\ndiff --git a/file.txt b/file.txt\n";
let runner = MockCommandRunner::success(patch_output);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.patch(42).await.expect("patch should succeed");
assert_eq!(result, patch_output);
}
#[tokio::test]
async fn test_should_return_error_when_pr_patch_fails() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let result = provider.patch(999).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_default_branch_on_success() {
let runner = MockCommandRunner::success(r#"{"defaultBranchRef":{"name":"dev"}}"#);
let provider = GitHubPrProvider::with_runner("octocat/hello-world", runner);
let result = provider.default_branch().await;
assert!(result.is_ok());
assert_eq!(result.expect("already checked"), "dev");
}
#[tokio::test]
async fn test_should_send_expected_argv_for_default_branch() {
let runner = MockCommandRunner::success(r#"{"defaultBranchRef":{"name":"dev"}}"#);
let provider = GitHubPrProvider::with_runner("octocat/hello-world", runner.clone());
let _ = provider.default_branch().await;
let calls = runner.recorded_calls();
assert_eq!(calls[0].0, "gh");
assert_eq!(
calls[0].1,
vec![
"repo",
"view",
"--repo",
"octocat/hello-world",
"--json",
"defaultBranchRef",
]
);
}
#[tokio::test]
async fn test_should_return_error_when_repo_view_fails() {
let runner = MockCommandRunner::failure("gh: Not Found (HTTP 404)", 1);
let provider = GitHubPrProvider::with_runner("octocat/nonexistent", runner);
let result = provider.default_branch().await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_should_request_default_cap_plus_one_for_pr_list() {
let runner = MockCommandRunner::success("[]");
let provider = GitHubPrProvider::with_runner("owner/repo", runner.clone());
let paged = provider
.list(ListPrArgs::default())
.await
.expect("list should succeed");
assert!(!paged.truncated);
let recorded = &runner.recorded_calls()[0].1;
assert!(
recorded
.windows(2)
.any(|w| w[0] == "--limit" && w[1] == "1001"),
"实际 argv: {recorded:?}"
);
}
#[tokio::test]
async fn test_should_still_forward_state_filter_for_pr_list() {
let runner = MockCommandRunner::success("[]");
let provider = GitHubPrProvider::with_runner("owner/repo", runner.clone());
let args = ListPrArgs {
state: Some(State::Open),
..ListPrArgs::default()
};
provider.list(args).await.expect("list should succeed");
let recorded = &runner.recorded_calls()[0].1;
assert!(
recorded
.windows(2)
.any(|w| w[0] == "--state" && w[1] == "open")
);
}
#[tokio::test]
async fn test_should_produce_complete_argv_for_pr_list_with_state() {
let runner = MockCommandRunner::success("[]");
let provider = GitHubPrProvider::with_runner("owner/repo", runner.clone());
let args = ListPrArgs {
state: Some(State::Open),
..ListPrArgs::default()
};
provider.list(args).await.expect("list should succeed");
let recorded = &runner.recorded_calls()[0];
assert_eq!(recorded.0, "gh");
assert_eq!(
recorded.1,
vec![
"pr",
"list",
"--repo",
"owner/repo",
"--json",
PR_FIELDS,
"--state",
"open",
"--limit",
"1001",
]
);
}
const MILESTONE_LIST_JSON: &str = r#"[
{"number": 3, "title": "v2.0", "state": "open", "description": null}
]"#;
#[tokio::test]
async fn test_should_wire_resolved_milestone_title_into_pr_create() {
let runner = SequencedMockCommandRunner::from_results(&[
(true, MILESTONE_LIST_JSON),
(true, "https://github.com/owner/repo/pull/42"),
(
true,
r#"{"number":42,"title":"Add feature","body":"Detailed description","state":"open","draft":false,"author":{"login":"alice","id":"2"},"baseBranch":"main","headBranch":"feature/new","createdAt":"2026-02-20T14:00:00Z","updatedAt":"2026-02-21T10:30:00Z","milestone":{"number":3,"title":"v2.0"},"url":"https://github.com/owner/repo/pull/42"}"#,
),
]);
let provider = GitHubPrProvider::with_runner("owner/repo", runner.clone());
let mut args = sample_create_args();
args.milestone = Some("3".to_string());
let pr = provider.create(args).await.expect("create should succeed");
assert_eq!(
pr.milestone,
Some(gitflow_core::types::MilestoneRef {
number: 3,
title: "v2.0".into()
})
);
let calls = runner.recorded_calls();
assert_eq!(calls.len(), 3, "expected exactly 3 gh invocations");
let create_call = &calls[1].1;
assert!(
create_call
.windows(2)
.any(|w| w[0] == "--milestone" && w[1] == "v2.0"),
"pr create argv must carry the resolved milestone title, got: {create_call:?}"
);
}
#[tokio::test]
async fn test_should_propagate_error_when_milestone_identifier_not_found_on_pr_create() {
let runner = SequencedMockCommandRunner::from_results(&[(true, MILESTONE_LIST_JSON)]);
let provider = GitHubPrProvider::with_runner("owner/repo", runner);
let mut args = sample_create_args();
args.milestone = Some("does-not-exist".to_string());
let result = provider.create(args).await;
assert!(result.is_err());
}
}