use async_trait::async_trait;
use chrono::{DateTime, Utc};
use gitflow_core::{
CoreError, Result,
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)]
html_url: Option<String>,
}
#[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().map_or_else(Utc::now, |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())
})
.unwrap_or_else(|_| Utc::now())
});
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_or_else(Utc::now, |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),
url: api.html_url.unwrap_or_default(),
}
}
}
#[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,
}
}
}
impl<R: CommandRunner> GitCodePrProvider<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 GitCodePrProvider<R> {
async fn create(&self, args: CreatePrArgs) -> Result<PrData> {
let binary = crate::gitcode_binary();
let mut cmd_args: Vec<&str> = vec![
"pr",
"create",
"--repo",
args.repo.as_deref().unwrap_or(&self.repo),
"--title",
&args.title,
"--head",
&args.head,
"--base",
&args.base,
"--json",
];
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 `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)?;
Ok(api.into())
}
async fn list(&self, args: ListPrArgs) -> Result<Vec<PrData>> {
let binary = crate::gitcode_binary();
let mut cmd_args: Vec<&str> = vec!["pr", "list", "--repo", &self.repo, "--json"];
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 `gitcode pr list`");
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 apis: Vec<PrApiResponse> =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(apis.into_iter().map(PrData::from).collect())
}
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 api: PrApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api.into())
}
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 api: PrApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api.into())
}
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>) -> Result<MergeResult> {
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(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::runner::MockCommandRunner;
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.to_rfc3339(), "2026-07-30T04:40:46+00:00");
}
#[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");
}
#[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_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,
}
}
#[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(_)
));
}
#[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_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).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(_)
));
}
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_pass_limit_flag_to_pr_list() {
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.len(), 1);
let args = &runner.calls()[0];
assert!(args.contains(&"--limit".to_string()));
assert!(args.contains(&"5".to_string()));
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))
.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)).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).await.expect("merge");
assert!(!runner.calls()[0].contains(&"--method".to_string()));
}
#[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.to_rfc3339(), "2026-07-07T10:40:20+00:00");
}
}
#[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");
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/"));
}
}