use async_trait::async_trait;
use chrono::{DateTime, Utc};
use gitflow_core::{
CoreError, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, Session, fetch_capped,
pr::{CreatePrArgs, ListPrArgs, PrData, PrProvider},
types::{CommentData, MergeResult, MergeStrategy, State, UserSummary},
};
use serde::Deserialize;
use tracing::debug;
use crate::{
error::parse_gitcode_error,
runner::{CommandRunner, RealCommandRunner},
};
#[derive(Debug, Clone, Deserialize)]
struct PrApiResponse {
number: u64,
title: String,
#[serde(default)]
body: Option<String>,
#[serde(default)]
state: Option<String>,
#[serde(default)]
draft: bool,
#[serde(default)]
user: Option<PrUserApi>,
#[serde(default)]
head: Option<PrBranchApi>,
#[serde(default)]
base: Option<PrBranchApi>,
#[serde(default)]
created_at: Option<String>,
#[serde(default)]
updated_at: Option<String>,
#[serde(default)]
merged_at: Option<String>,
#[serde(default)]
html_url: Option<String>,
#[serde(default)]
milestone: Option<PrMilestoneRefApi>,
}
#[derive(Debug, Clone, Deserialize)]
struct PrCloseReopenApiResponse {
number: u64,
}
#[derive(Debug, Clone, Deserialize)]
struct PrMilestoneRefApi {
number: u64,
title: String,
}
impl From<PrMilestoneRefApi> for gitflow_core::types::MilestoneRef {
fn from(api: PrMilestoneRefApi) -> Self {
Self {
number: api.number,
title: api.title,
}
}
}
#[derive(Debug, Clone, Deserialize)]
struct PrUserApi {
#[serde(default)]
login: String,
#[serde(default)]
id: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
struct PrBranchApi {
#[serde(default, rename = "ref")]
branch_ref: String,
}
#[derive(Debug, Clone, Deserialize)]
struct PrCommentApiResponse {
#[serde(deserialize_with = "gitflow_core::types::deserialize_u64_or_string")]
id: u64,
#[serde(default)]
body: String,
#[serde(default)]
author: Option<String>,
#[serde(default)]
user: Option<PrUserApi>,
#[serde(default)]
created_at: Option<String>,
}
impl From<PrCommentApiResponse> for CommentData {
fn from(api: PrCommentApiResponse) -> Self {
let author = api.user.map_or_else(
|| UserSummary {
login: api.author.unwrap_or_else(|| "unknown".into()),
id: String::new(),
},
|u| UserSummary {
login: u.login,
id: u.id.unwrap_or_default(),
},
);
let created_at = api.created_at.as_deref().and_then(|s| {
DateTime::parse_from_rfc3339(s)
.map(|dt| dt.with_timezone(&Utc))
.or_else(|_| {
chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S")
.map(|ndt| ndt.and_utc())
})
.ok()
});
Self {
id: api.id,
body: api.body,
author,
created_at,
}
}
}
impl From<PrApiResponse> for PrData {
fn from(api: PrApiResponse) -> Self {
let parse_time = |s: Option<String>| {
s.and_then(|v| DateTime::parse_from_rfc3339(&v).ok())
.map(|dt| dt.with_timezone(&Utc))
};
Self {
number: api.number,
title: api.title,
body: api.body,
state: match api.state.as_deref() {
Some("closed" | "merged") => State::Closed,
_ => State::Open,
},
draft: api.draft,
author: api.user.map_or(
UserSummary {
login: "unknown".into(),
id: String::new(),
},
|u| UserSummary {
login: u.login,
id: u.id.unwrap_or_default(),
},
),
base_branch: api.base.map_or_else(String::new, |b| b.branch_ref),
head_branch: api.head.map_or_else(String::new, |h| h.branch_ref),
created_at: parse_time(api.created_at),
updated_at: parse_time(api.updated_at),
merged_at: parse_time(api.merged_at),
url: api.html_url.unwrap_or_default(),
milestone: api.milestone.map(Into::into),
}
}
}
#[derive(Debug, Clone)]
pub struct GitCodePrProvider<R: CommandRunner = RealCommandRunner> {
repo: String,
runner: R,
}
impl GitCodePrProvider<RealCommandRunner> {
#[must_use]
pub fn new(repo: impl Into<String>) -> Self {
Self {
repo: repo.into(),
runner: RealCommandRunner,
}
}
#[must_use]
pub fn with_session(session: &Session) -> Self {
Self {
repo: session.repo.clone(),
runner: RealCommandRunner,
}
}
}
impl<R: CommandRunner> GitCodePrProvider<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 binary = crate::gitcode_binary();
let binary = &binary;
let cap = args.limit.unwrap_or(DEFAULT_LIST_LIMIT);
let repo = &self.repo;
let runner = &self.runner;
let state = args.state;
let per_page = cap.saturating_add(1).min(crate::GITCODE_API_MAX_PER_PAGE);
debug!(repo = %self.repo, cap, per_page, "spawning `gitcode pr list`");
fetch_capped(
FetchStrategy::Paged { per_page },
cap,
|page, per_page| async move {
let page_str = page.to_string();
let per_page_str = per_page.to_string();
let mut cmd_args: Vec<&str> = vec!["pr", "list", "--repo", repo, "--json"];
if let Some(state) = &state {
cmd_args.push("--state");
cmd_args.push(match state {
State::Open => "open",
State::Closed => "closed",
State::All => "all",
});
}
cmd_args.push("--per-page");
cmd_args.push(&per_page_str);
cmd_args.push("--page");
cmd_args.push(&page_str);
let output = runner
.run(binary, &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
let apis: Vec<PrApiResponse> =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(apis.into_iter().map(PrData::from).collect())
},
)
.await
}
}
#[async_trait]
impl<R: CommandRunner + Clone + 'static> PrProvider for GitCodePrProvider<R> {
async fn create(&self, args: CreatePrArgs) -> Result<PrData> {
let binary = crate::gitcode_binary();
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,
"--json",
];
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");
}
debug!(
repo = %self.repo,
title = %args.title,
head = %args.head,
base = %args.base,
"spawning `gitcode pr create`"
);
let output = self
.runner
.run(&binary, &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
let api: PrApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
let mut pr_data: PrData = api.into();
if let Some(identifier) = &args.milestone {
let milestone_provider =
crate::GitCodeMilestoneProvider::with_runner(repo, self.runner.clone());
let resolved =
gitflow_core::label::resolve_milestone_identifier(&milestone_provider, identifier)
.await?;
let number_str = pr_data.number.to_string();
let milestone_number_str = resolved.number.to_string();
let edit_output = self
.runner
.run(
&binary,
&[
"pr",
"edit",
&number_str,
"--repo",
repo,
"--milestone",
&milestone_number_str,
],
)
.await
.map_err(|e| {
CoreError::Platform(format!(
"PR #{} created, but attaching milestone failed to spawn: {e}",
pr_data.number
))
})?;
if !edit_output.status.success() {
return Err(CoreError::Platform(format!(
"PR #{} created, but attaching milestone failed: {}",
pr_data.number,
String::from_utf8_lossy(&edit_output.stderr)
)));
}
pr_data.milestone = Some(resolved);
}
Ok(pr_data)
}
async fn list(&self, args: ListPrArgs) -> Result<Paged<PrData>> {
self.list_impl(args).await
}
async fn view(&self, number: u64) -> Result<PrData> {
let binary = crate::gitcode_binary();
let number_str = number.to_string();
debug!(repo = %self.repo, number, "spawning `gitcode pr view`");
let output = self
.runner
.run(
&binary,
&["pr", "view", &number_str, "--repo", &self.repo, "--json"],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
let api: PrApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api.into())
}
async fn close(&self, number: u64) -> Result<PrData> {
let binary = crate::gitcode_binary();
let number_str = number.to_string();
debug!(repo = %self.repo, number, "spawning `gitcode pr close`");
let output = self
.runner
.run(
&binary,
&[
"pr",
"close",
&number_str,
"--repo",
&self.repo,
"--yes",
"--json",
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
let close_result: PrCloseReopenApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
self.view(close_result.number).await
}
async fn reopen(&self, number: u64) -> Result<PrData> {
let binary = crate::gitcode_binary();
let number_str = number.to_string();
debug!(repo = %self.repo, number, "spawning `gitcode pr reopen`");
let output = self
.runner
.run(
&binary,
&[
"pr",
"reopen",
&number_str,
"--repo",
&self.repo,
"--yes",
"--json",
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
let reopen_result: PrCloseReopenApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
self.view(reopen_result.number).await
}
async fn comment(&self, number: u64, body: &str) -> Result<CommentData> {
let binary = crate::gitcode_binary();
let number_str = number.to_string();
debug!(repo = %self.repo, number, "spawning `gitcode pr comment`");
let output = self
.runner
.run(
&binary,
&[
"pr",
"comment",
&number_str,
"--repo",
&self.repo,
"--body",
body,
"--json",
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
let api: PrCommentApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api.into())
}
async fn merge(
&self,
number: u64,
strategy: Option<MergeStrategy>,
auto: bool,
) -> Result<MergeResult> {
if auto {
return Err(CoreError::Platform(
"GitCode CLI 不支持排队合并(auto)。请改用 GitHub/GitLab,或在 CI \
通过后手动合并。"
.into(),
));
}
let binary = crate::gitcode_binary();
let number_str = number.to_string();
let mut cmd_args: Vec<&str> =
vec!["pr", "merge", &number_str, "--repo", &self.repo, "--yes"];
let strategy_value;
if let Some(strategy) = strategy {
strategy_value = match strategy {
MergeStrategy::Merge => "merge",
MergeStrategy::Squash => "squash",
MergeStrategy::Rebase => "rebase",
};
cmd_args.push("--method");
cmd_args.push(strategy_value);
}
debug!(repo = %self.repo, number, ?strategy, "spawning `gitcode pr merge`");
let output = self
.runner
.run(&binary, &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_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<()> {
let binary = crate::gitcode_binary();
let number_str = number.to_string();
debug!(repo = %self.repo, number, "spawning `gc pr checkout`");
let output = self
.runner
.run(
&binary,
&["pr", "checkout", &number_str, "--repo", &self.repo],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
Ok(())
}
async fn mark_ready(&self, number: u64) -> Result<PrData> {
let binary = crate::gitcode_binary();
let number_str = number.to_string();
debug!(repo = %self.repo, number, "spawning `gc pr ready`");
let output = self
.runner
.run(&binary, &["pr", "ready", &number_str, "--repo", &self.repo])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
self.view(number).await
}
async fn mark_wip(&self, number: u64) -> Result<PrData> {
let binary = crate::gitcode_binary();
let number_str = number.to_string();
debug!(repo = %self.repo, number, "spawning `gc pr convert-to-draft`");
let output = self
.runner
.run(
&binary,
&["pr", "convert-to-draft", &number_str, "--repo", &self.repo],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
self.view(number).await
}
async fn sync_branch(&self, number: u64) -> Result<()> {
let binary = crate::gitcode_binary();
let number_str = number.to_string();
debug!(repo = %self.repo, number, "spawning `gc pr update-branch`");
let output = self
.runner
.run(
&binary,
&["pr", "update-branch", &number_str, "--repo", &self.repo],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
Ok(())
}
async fn diff(&self, number: u64) -> Result<String> {
let binary = crate::gitcode_binary();
let number_str = number.to_string();
debug!(repo = %self.repo, number, "spawning `gc mr diff`");
let output = self
.runner
.run(&binary, &["mr", "diff", &number_str, "-R", &self.repo])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode mr diff: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
Ok(String::from_utf8_lossy(&output.stdout).into_owned())
}
async fn patch(&self, number: u64) -> Result<String> {
let binary = crate::gitcode_binary();
let number_str = number.to_string();
debug!(repo = %self.repo, number, "spawning `gc mr patch`");
let output = self
.runner
.run(&binary, &["mr", "patch", &number_str, "-R", &self.repo])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode mr patch: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
Ok(String::from_utf8_lossy(&output.stdout).into_owned())
}
async fn default_branch(&self) -> Result<String> {
Err(CoreError::Platform(
"GitCode CLI 不支持查询仓库默认分支。请显式传入 --base,或改用 GitHub/GitLab。".into(),
))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
fn real_gitcode_pr_json() -> &'static str {
r###"{
"id": 8957463,
"number": 52,
"title": "test(badge): 引擎规则函数测试覆盖",
"body": "## Summary\n\nCloses #88",
"description": "## Summary\n\nCloses #88",
"state": "merged",
"html_url": "https://gitcode.com/byx-darwin/go-beniofit/merge_requests/52",
"diff_url": "",
"patch_url": "",
"draft": false,
"merged": true,
"merged_at": "2026-07-30T13:23:13+08:00",
"created_at": "2026-07-30T12:40:46+08:00",
"updated_at": "2026-07-30T13:23:13+08:00",
"user": {
"id": "66767cd4096c81780c61bf07",
"login": "byx-darwin",
"name": "baoyx",
"email": "",
"avatar_url": "https://cdn-img.gitcode.com/avatar.png",
"html_url": "https://gitcode.com/byx-darwin",
"created_at": ""
},
"head": {
"label": "test/88-engine-rule-coverage",
"ref": "test/88-engine-rule-coverage",
"sha": "8f1d3f31d7ee598a16f40fcac55b86154122c93c"
},
"base": {
"label": "master",
"ref": "master",
"sha": "bba7d724c8c73531acf1dca5f639b2a273c26eae"
},
"labels": [],
"assignees": [],
"additions": 120,
"deletions": 3,
"changed_files": 1,
"commits": 2,
"comments": 0,
"mergeable": true,
"mergeable_state": "can_be_merged",
"milestone": null,
"closed_at": "2026-07-30T13:23:13+08:00",
"requested_reviewers": []
}"###
}
#[test]
fn test_should_map_real_gitcode_pr_response_to_pr_data() {
let api: PrApiResponse =
serde_json::from_str(real_gitcode_pr_json()).expect(r"valid gitcode v0.6.1 PR JSON");
let pr: PrData = api.into();
assert_eq!(pr.number, 52);
assert_eq!(pr.title, r"test(badge): 引擎规则函数测试覆盖");
assert_eq!(pr.state, State::Closed, r"merged 必须映射为 Closed");
assert!(!pr.draft);
assert_eq!(pr.author.login, "byx-darwin");
assert_eq!(pr.author.id, "66767cd4096c81780c61bf07");
assert_eq!(pr.base_branch, "master");
assert_eq!(pr.head_branch, "test/88-engine-rule-coverage");
assert_eq!(
pr.url,
"https://gitcode.com/byx-darwin/go-beniofit/merge_requests/52"
);
assert_eq!(
pr.created_at.map(|dt| dt.to_rfc3339()),
Some("2026-07-30T04:40:46+00:00".to_string())
);
}
#[test]
fn test_should_map_open_pr_with_minimal_gitcode_fields() {
let json = r#"{
"id": 1,
"number": 7,
"title": "New work",
"state": "open",
"html_url": "https://gitcode.com/o/r/merge_requests/7",
"draft": true,
"user": {"id": "u1", "login": "dev"},
"head": {"ref": "feature/x"},
"base": {"ref": "main"}
}"#;
let api: PrApiResponse = serde_json::from_str(json).expect(r"minimal gitcode PR JSON");
let pr: PrData = api.into();
assert_eq!(pr.state, State::Open);
assert!(pr.draft);
assert_eq!(pr.body, None);
assert_eq!(pr.head_branch, "feature/x");
assert_eq!(pr.base_branch, "main");
assert_eq!(pr.author.login, "dev");
assert!(
pr.created_at.is_none(),
"missing created_at must stay None, not fall back to Utc::now()"
);
assert!(
pr.updated_at.is_none(),
"missing updated_at must stay None, not fall back to Utc::now()"
);
}
#[test]
fn test_should_construct_gitcode_pr_provider() {
let provider = GitCodePrProvider::new("octocat/hello-world");
assert_eq!(provider.repo, "octocat/hello-world");
}
#[test]
fn test_should_construct_gitcode_pr_provider_from_string() {
let repo = String::from("octocat/hello-world");
let provider = GitCodePrProvider::new(repo);
assert_eq!(provider.repo, "octocat/hello-world");
}
#[test]
fn test_should_deserialize_empty_pr_list_from_gc_output() {
let gc_json = b"[]";
let prs: Vec<PrData> = serde_json::from_slice(gc_json).expect("valid PrData list");
assert!(prs.is_empty());
}
#[test]
fn test_should_debug_format_provider() {
let provider = GitCodePrProvider::new("octocat/hello-world");
let debug = format!("{provider:?}");
assert!(debug.contains("GitCodePrProvider"));
assert!(debug.contains("octocat/hello-world"));
}
#[test]
fn test_should_deserialize_comment_data_from_gc_pr_comment_output() {
let gc_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(gc_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");
}
#[test]
fn test_should_keep_pr_comment_created_at_none_when_gc_api_omits_it() {
let gc_json = br#"{
"id": 2003,
"body": "No timestamp provided.",
"user": {"login": "reviewer", "id": "88"}
}"#;
let api: PrCommentApiResponse =
serde_json::from_slice(gc_json).expect("valid PrCommentApiResponse");
let comment = CommentData::from(api);
assert!(
comment.created_at.is_none(),
"missing created_at must stay None, not fall back to Utc::now()"
);
}
#[test]
fn test_should_deserialize_merge_result_from_gc_merge_output() {
let gc_text = b"Pull request #123 was successfully merged.\n";
let message = String::from_utf8_lossy(gc_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 = GitCodePrProvider::new("org/repo-a");
let r2 = GitCodePrProvider::new("org/repo-b");
assert_eq!(r1.repo, "org/repo-a");
assert_eq!(r2.repo, "org/repo-b");
}
#[test]
fn test_should_clone_gitcode_pr_provider() {
let original = GitCodePrProvider::new("owner/repo");
let cloned = original.clone();
assert_eq!(original.repo, cloned.repo);
}
fn sample_create_args() -> CreatePrArgs {
CreatePrArgs {
title: "New feature".to_string(),
body: Some("Adds a feature".to_string()),
head: "feature/x".to_string(),
base: "main".to_string(),
draft: false,
repo: None,
closes_issues: vec![],
milestone: None,
}
}
#[test]
fn test_should_format_gitcode_body_with_closing_issues() {
use gitflow_core::pr::format_closing_body;
let body = Some("PR description".to_string());
let issues = vec![10u64, 11];
let result = format_closing_body(&body, &issues, "Closes");
assert_eq!(
result,
Some("PR description\n\nCloses #10\nCloses #11".to_string())
);
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_create() {
let runner = MockCommandRunner::failure("validation failed", 256);
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.create(sample_create_args()).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_create() {
let runner = MockCommandRunner::success("not valid json");
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.create(sample_create_args()).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
fn pr_milestone_list_fixture() -> String {
r#"[{"number": 3, "title": "v2.0", "description": null, "state": "open", "due_on": null, "closed_issues": 0, "open_issues": 0}]"#.to_string()
}
#[tokio::test]
async fn test_should_attach_milestone_via_create_then_edit_two_step() {
let runner = SequencedMockCommandRunner::from_results(&[
(
true,
r#"{"number":52,"title":"Add feature","body":null,"state":"open","draft":false,"user":{"login":"alice","id":"2"},"head":{"ref":"feature/x"},"base":{"ref":"main"},"created_at":"2026-02-20T14:00:00Z","updated_at":"2026-02-20T14:00:00Z","html_url":"https://gitcode.com/owner/repo/merge_requests/52"}"#,
),
(true, &pr_milestone_list_fixture()),
(true, ""),
]);
let provider = GitCodePrProvider::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.number, 52);
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,
"must call: pr create, milestone list, pr edit"
);
assert_eq!(calls[0].1[0], "pr");
assert_eq!(calls[0].1[1], "create");
assert!(
!calls[0].1.iter().any(|a| a == "--milestone"),
"pr create has no --milestone flag; must not be passed, got: {:?}",
calls[0].1
);
assert_eq!(
calls[1].1.first().map(String::as_str),
Some("milestone"),
"second call must resolve the milestone via `gitcode milestone list`, got: {:?}",
calls[1].1
);
let edit_call = &calls[2].1;
assert_eq!(edit_call[0], "pr");
assert_eq!(edit_call[1], "edit");
assert_eq!(edit_call[2], "52");
assert!(
edit_call
.windows(2)
.any(|w| w[0] == "--milestone" && w[1] == "3"),
"pr edit argv must carry the resolved milestone NUMBER, got: {edit_call:?}"
);
}
#[tokio::test]
async fn test_should_resolve_milestone_against_overridden_repo_on_pr_create() {
let runner = SequencedMockCommandRunner::from_results(&[
(
true,
r#"{"number":52,"title":"Add feature","body":null,"state":"open","draft":false,"user":{"login":"alice","id":"2"},"head":{"ref":"feature/x"},"base":{"ref":"main"},"created_at":"2026-02-20T14:00:00Z","updated_at":"2026-02-20T14:00:00Z","html_url":"https://gitcode.com/other/repo/merge_requests/52"}"#,
),
(true, &pr_milestone_list_fixture()),
(true, ""),
]);
let provider = GitCodePrProvider::with_runner("owner/repo", runner.clone());
let mut args = sample_create_args();
args.repo = Some("other/repo".to_string());
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,
"must call: pr create, milestone list, pr edit"
);
let create_call = &calls[0].1;
assert!(
create_call
.windows(2)
.any(|w| w[0] == "--repo" && w[1] == "other/repo"),
"pr create must target the overridden repo, got: {create_call:?}"
);
let milestone_list_call = &calls[1].1;
assert!(
milestone_list_call
.windows(2)
.any(|w| w[0] == "-R" && w[1] == "other/repo"),
"milestone resolution must target the overridden repo (\"other/repo\"), not the \
provider default (\"owner/repo\"), got: {milestone_list_call:?}"
);
let edit_call = &calls[2].1;
assert!(
edit_call
.windows(2)
.any(|w| w[0] == "--repo" && w[1] == "other/repo"),
"pr edit must target the overridden repo, got: {edit_call:?}"
);
}
#[tokio::test]
async fn test_should_surface_created_pr_number_when_milestone_attach_fails_to_spawn() {
let runner = SequencedMockCommandRunner::from_results(&[
(
true,
r#"{"number":52,"title":"Add feature","body":null,"state":"open","draft":false,"user":{"login":"alice","id":"2"},"head":{"ref":"feature/x"},"base":{"ref":"main"},"created_at":"2026-02-20T14:00:00Z","updated_at":"2026-02-20T14:00:00Z","html_url":"https://gitcode.com/owner/repo/merge_requests/52"}"#,
),
(true, &pr_milestone_list_fixture()),
(false, "gitcode: 403 Forbidden"),
]);
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let mut args = sample_create_args();
args.milestone = Some("3".to_string());
let err = provider
.create(args)
.await
.expect_err("milestone attach failure must surface, not be swallowed");
let msg = format!("{err}");
assert!(
matches!(err, gitflow_core::CoreError::Platform(_)),
"expected CoreError::Platform, got {msg}"
);
assert!(
msg.contains("52"),
"error must name the already-created PR number, got: {msg}"
);
assert!(
msg.contains("milestone"),
"error must mention milestone attachment, got: {msg}"
);
}
#[tokio::test]
async fn test_should_propagate_error_when_milestone_identifier_not_found_on_pr_create_two_step()
{
let runner = SequencedMockCommandRunner::from_results(&[
(
true,
r#"{"number":52,"title":"Add feature","body":null,"state":"open","draft":false,"user":{"login":"alice","id":"2"},"head":{"ref":"feature/x"},"base":{"ref":"main"},"created_at":"2026-02-20T14:00:00Z","updated_at":"2026-02-20T14:00:00Z","html_url":"https://gitcode.com/owner/repo/merge_requests/52"}"#,
),
(true, "[]"),
]);
let provider = GitCodePrProvider::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());
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_list() {
let runner = MockCommandRunner::failure("forbidden", 256);
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.list(ListPrArgs::default()).await;
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");
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.list(ListPrArgs::default()).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_page_through_gitcode_pr_list_with_incrementing_page_numbers() {
let one = real_gitcode_pr_json();
let page = format!("[{}]", vec![one; 100].join(","));
let runner = SequencedMockCommandRunner::from_results(&[(true, &page), (true, &page)]);
let provider = GitCodePrProvider::with_runner("owner/repo", runner.clone());
let paged = provider
.list(ListPrArgs {
state: Some(State::Open),
limit: Some(100),
})
.await
.expect("list should succeed");
assert_eq!(paged.items.len(), 100);
assert!(paged.truncated);
let calls = runner.recorded_calls();
assert_eq!(
calls.len(),
2,
"必须真的翻到第二页,实际调用数: {}",
calls.len()
);
let first = &calls[0].1;
assert!(
first
.windows(2)
.any(|w| w[0] == "--per-page" && w[1] == "100"),
"实际 argv: {first:?}"
);
assert!(
first.windows(2).any(|w| w[0] == "--page" && w[1] == "1"),
"实际 argv: {first:?}"
);
assert!(
!first.iter().any(|a| a == "--limit"),
"实际 argv: {first:?}"
);
assert!(
calls[1]
.1
.windows(2)
.any(|w| w[0] == "--page" && w[1] == "2"),
"页号必须递增,实际 argv: {:?}",
calls[1].1
);
}
#[tokio::test]
async fn test_should_produce_complete_argv_for_gitcode_pr_list_with_state() {
let runner = MockCommandRunner::success("[]");
let provider = GitCodePrProvider::with_runner("owner/repo", runner.clone());
let args = ListPrArgs {
state: Some(State::Open),
..ListPrArgs::default()
};
provider.list(args).await.expect("list should succeed");
assert_eq!(
runner.recorded_calls()[0].1,
vec![
"pr",
"list",
"--repo",
"owner/repo",
"--json",
"--state",
"open",
"--per-page",
"100",
"--page",
"1",
]
);
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_view() {
let runner = MockCommandRunner::failure("pr not found", 256);
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.view(999).await;
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("not valid json");
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.view(1).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_close() {
let runner = MockCommandRunner::failure("not found", 256);
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.close(42).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_reopen() {
let runner = MockCommandRunner::failure("not found", 256);
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.reopen(42).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_merge() {
let runner = MockCommandRunner::failure("merge conflict", 256);
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.merge(42, None, false).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_comment() {
let runner = MockCommandRunner::failure("not found", 256);
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.comment(42, "a comment").await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_checkout() {
let runner = MockCommandRunner::failure("git error", 256);
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.checkout(42).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_sync_branch() {
let runner = MockCommandRunner::failure("sync conflict", 256);
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.sync_branch(42).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_mark_ready() {
let runner = MockCommandRunner::failure("not a draft", 256);
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.mark_ready(42).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_mark_wip() {
let runner = MockCommandRunner::failure("already a draft", 256);
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.mark_wip(42).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_fetch_mr_diff() {
use gitflow_core::pr::PrProvider;
let diff_output = "diff --git a/src/main.rs b/src/main.rs\nindex 1234567..abcdefg \
100644\n--- a/src/main.rs\n+++ b/src/main.rs\n@@ -1 +1 @@\n-old\n+new\n";
let runner = MockCommandRunner::success(diff_output);
let provider = GitCodePrProvider::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_mr_diff_fails() {
use gitflow_core::pr::PrProvider;
let runner = MockCommandRunner::failure("404 not found", 256);
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.diff(999).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_fetch_mr_patch() {
use gitflow_core::pr::PrProvider;
let patch_output =
"From abc123\nSubject: [PATCH] Update file\n\ndiff --git a/src/main.rs b/src/main.rs\n";
let runner = MockCommandRunner::success(patch_output);
let provider = GitCodePrProvider::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_mr_patch_fails() {
use gitflow_core::pr::PrProvider;
let runner = MockCommandRunner::failure("404 not found", 256);
let provider = GitCodePrProvider::with_runner("owner/repo", runner);
let result = provider.patch(999).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
use crate::runner::RecordingMockRunner;
#[tokio::test]
async fn test_should_not_pass_field_list_to_pr_view() {
let runner = RecordingMockRunner::success(real_gitcode_pr_json());
let provider = GitCodePrProvider::with_runner("octocat/hello-world", runner.clone());
let pr = provider
.view(20)
.await
.expect("view should parse real schema");
assert_eq!(pr.number, 52);
let calls = runner.calls();
assert_eq!(calls.len(), 1);
assert_eq!(
calls[0],
vec![
"pr",
"view",
"20",
"--repo",
"octocat/hello-world",
"--json"
],
"gitcode --json 是布尔标志,不得携带字段列表位置参数"
);
}
#[tokio::test]
async fn test_should_pass_yes_flag_to_pr_close() {
let runner = RecordingMockRunner::success(real_gitcode_pr_json());
let provider = GitCodePrProvider::with_runner("o/r", runner.clone());
provider.close(9).await.expect("close should succeed");
let args = &runner.calls()[0];
assert!(
args.contains(&"--yes".to_string()),
"close 必须跳过确认提示"
);
assert!(
!args
.windows(2)
.any(|w| { w[0] == "--json" && w[1] != "--yes" && !w[1].starts_with('-') }),
"--json 后不得跟随字段列表"
);
}
#[tokio::test]
async fn test_should_deserialize_real_gitcode_pr_close_response_via_view() {
let runner = SequencedMockCommandRunner::from_results(&[
(
true,
r#"{"number":6,"state":"closed","owner":"byx-darwin","repo":"NexaTrade","url":"https://gitcode.com/byx-darwin/NexaTrade/merge_requests/6"}"#,
),
(true, real_gitcode_pr_json()),
]);
let provider = GitCodePrProvider::with_runner("owner/repo", runner.clone());
let pr = provider.close(6).await.expect("close should succeed");
assert_eq!(pr.number, 52); let calls = runner.recorded_calls();
assert_eq!(calls.len(), 2, "close 必须先 close 再 view 两次调用");
assert!(calls[0].1.contains(&"close".to_string()));
assert!(calls[1].1.contains(&"view".to_string()));
}
#[tokio::test]
async fn test_should_deserialize_real_gitcode_pr_reopen_response_via_view() {
let runner = SequencedMockCommandRunner::from_results(&[
(
true,
r#"{"number":6,"state":"opened","owner":"byx-darwin","repo":"NexaTrade","url":"https://gitcode.com/byx-darwin/NexaTrade/merge_requests/6"}"#,
),
(true, real_gitcode_pr_json()),
]);
let provider = GitCodePrProvider::with_runner("owner/repo", runner.clone());
let pr = provider.reopen(6).await.expect("reopen should succeed");
assert_eq!(pr.number, 52);
let calls = runner.recorded_calls();
assert_eq!(calls.len(), 2, "reopen 必须先 reopen 再 view 两次调用");
assert!(calls[0].1.contains(&"reopen".to_string()));
assert!(calls[1].1.contains(&"view".to_string()));
}
#[tokio::test]
async fn test_should_propagate_view_error_after_close_succeeds() {
let runner = SequencedMockCommandRunner::from_results(&[
(true, r#"{"number":6,"state":"closed"}"#),
(false, "gitcode: pr not found"),
]);
let provider = GitCodePrProvider::with_runner("owner/repo", runner.clone());
let err = provider
.close(6)
.await
.expect_err("view failure must propagate");
assert!(matches!(err, CoreError::Cli(_)));
}
#[tokio::test]
async fn test_should_pass_user_limit_to_pr_list_via_per_page() {
let runner = RecordingMockRunner::success(&format!("[{}]", real_gitcode_pr_json()));
let provider = GitCodePrProvider::with_runner("o/r", runner.clone());
let prs = provider
.list(ListPrArgs {
state: Some(State::Open),
limit: Some(5),
})
.await
.expect("list should succeed");
assert_eq!(prs.items.len(), 1);
let args = &runner.calls()[0];
assert!(args.windows(2).any(|w| w[0] == "--per-page" && w[1] == "6"));
assert!(args.windows(2).any(|w| w[0] == "--page" && w[1] == "1"));
assert!(args.contains(&"--state".to_string()));
assert!(args.contains(&"open".to_string()));
}
#[tokio::test]
async fn test_should_map_squash_strategy_to_method_flag() {
let runner = RecordingMockRunner::success("Merged pull request !52");
let provider = GitCodePrProvider::with_runner("o/r", runner.clone());
let result = provider
.merge(52, Some(MergeStrategy::Squash), false)
.await
.expect("merge");
assert!(result.merged);
let args = &runner.calls()[0];
let method_pos = args
.iter()
.position(|a| a == "--method")
.expect("--method must be passed");
assert_eq!(args[method_pos + 1], "squash");
}
#[tokio::test]
async fn test_should_map_all_merge_strategies() {
for (strategy, expected) in [
(MergeStrategy::Merge, "merge"),
(MergeStrategy::Squash, "squash"),
(MergeStrategy::Rebase, "rebase"),
] {
let runner = RecordingMockRunner::success("done");
let provider = GitCodePrProvider::with_runner("o/r", runner.clone());
provider
.merge(1, Some(strategy), false)
.await
.expect("merge");
let args = &runner.calls()[0];
let pos = args.iter().position(|a| a == "--method").expect("--method");
assert_eq!(args[pos + 1], expected);
}
}
#[tokio::test]
async fn test_should_omit_method_flag_when_no_strategy() {
let runner = RecordingMockRunner::success("done");
let provider = GitCodePrProvider::with_runner("o/r", runner.clone());
provider.merge(1, None, false).await.expect("merge");
assert!(!runner.calls()[0].contains(&"--method".to_string()));
}
#[tokio::test]
async fn test_should_reject_auto_merge_without_spawning_cli() {
let runner = RecordingMockRunner::success("done");
let provider = GitCodePrProvider::with_runner("o/r", runner.clone());
let err = provider
.merge(1, None, true)
.await
.expect_err("GitCode has no queued-merge semantics, so auto must error");
assert!(
matches!(err, gitflow_core::CoreError::Platform(_)),
"expected CoreError::Platform, got {err:?}"
);
assert!(
runner.calls().is_empty(),
"must reject before spawning the CLI, not silently degrade to an immediate merge"
);
}
#[tokio::test]
async fn test_should_not_pass_field_list_to_pr_comment() {
let comment_json = r#"{"id": "9001", "body": "LGTM", "user": {"login": "rev", "id": "u9"}, "created_at": "2026-07-30T12:00:00+08:00"}"#;
let runner = RecordingMockRunner::success(comment_json);
let provider = GitCodePrProvider::with_runner("o/r", runner.clone());
let comment = provider
.comment(52, "LGTM")
.await
.expect("comment should parse");
assert_eq!(comment.id, 9001);
assert_eq!(comment.author.login, "rev");
assert_eq!(
runner.calls()[0],
vec![
"pr", "comment", "52", "--repo", "o/r", "--body", "LGTM", "--json"
]
);
}
#[test]
fn test_should_parse_comment_with_legacy_string_author() {
let json = r#"{"id": "7", "body": "old format", "author": "alice", "created_at": "2026-07-07 10:40:20"}"#;
let api: PrCommentApiResponse = serde_json::from_str(json).expect("legacy shape");
let comment: CommentData = api.into();
assert_eq!(comment.author.login, "alice");
assert_eq!(
comment.created_at.map(|dt| dt.to_rfc3339()),
Some("2026-07-07T10:40:20+00:00".to_string())
);
}
#[tokio::test]
async fn test_should_error_without_cli_call_for_default_branch() {
use crate::runner::RecordingMockRunner;
let runner = RecordingMockRunner::success("should not be called");
let provider = GitCodePrProvider::with_runner("group/project", runner.clone());
let result = provider.default_branch().await;
assert!(result.is_err());
assert!(runner.calls().is_empty());
}
}
#[cfg(test)]
mod contract_tests {
use gitflow_core::pr::ListPrArgs;
use super::*;
use crate::runner::MockCommandRunner;
const PR_LIST_FIXTURE: &str = include_str!("../tests/fixtures/pr_list_gitcode_v0.6.json");
#[tokio::test]
async fn test_should_parse_real_gitcode_v061_pr_list_output() {
let provider = GitCodePrProvider::with_runner(
"byx-darwin/go-beniofit",
MockCommandRunner::success(PR_LIST_FIXTURE),
);
let prs = provider
.list(ListPrArgs::default())
.await
.expect("contract fixture must parse");
let prs = prs.items;
assert_eq!(prs.len(), 1);
let pr = &prs[0];
assert_eq!(pr.number, 52);
assert_eq!(pr.state, State::Closed);
assert_eq!(pr.author.login, "byx-darwin");
assert_eq!(pr.head_branch, "test/88-engine-rule-coverage");
assert_eq!(pr.base_branch, "master");
assert!(pr.url.starts_with("https://gitcode.com/"));
}
}