Skip to main content

gitflow_github/
pr.rs

1//! GitHub Pull Request 提供者实现。
2//!
3//! 通过 `gh` CLI 实现 [`PrProvider`] trait,支持 Pull Request 的创建、列表、查看、
4//! 关闭、合并、检出、草稿状态切换和分支同步。
5//! 命令执行通过 [`CommandRunner`] 抽象,捕获 stdout 并解析 JSON。
6
7use async_trait::async_trait;
8use gitflow_core::{
9    CoreError, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, fetch_capped,
10    pr::{CreatePrArgs, ListPrArgs, PrData, PrProvider},
11    types::{CommentData, MergeResult, MergeStrategy, State},
12};
13use serde::Deserialize;
14use tracing::debug;
15
16use crate::{
17    error::parse_gh_error,
18    runner::{CommandRunner, RealCommandRunner},
19};
20
21/// `gh pr` 请求的 JSON 字段列表。
22const PR_FIELDS: &str = "number,title,body,state,isDraft,author,baseRefName,headRefName,createdAt,\
23                         updatedAt,mergedAt,milestone,url";
24
25/// `gh repo view --json defaultBranchRef` 的响应类型。
26#[derive(Debug, Deserialize)]
27struct RepoViewResponse {
28    #[serde(rename = "defaultBranchRef")]
29    default_branch_ref: DefaultBranchRef,
30}
31
32/// `defaultBranchRef` 对象,仅取 `name` 字段。
33#[derive(Debug, Deserialize)]
34struct DefaultBranchRef {
35    name: String,
36}
37
38/// GitHub Pull Request 提供者,通过 `gh` CLI 操作。
39///
40/// 该结构体通过调用 `gh` CLI 实现 [`PrProvider`] trait 的所有方法,
41/// 使上层命令能够以统一的方式操作 GitHub Pull Request。
42///
43/// 命令执行通过 [`CommandRunner`] 抽象,生产环境默认使用
44/// [`RealCommandRunner`],测试可注入自定义 runner 以模拟成功或失败场景。
45///
46/// # Examples
47///
48/// ```no_run
49/// use gitflow_github::GitHubPrProvider;
50///
51/// let provider = GitHubPrProvider::new("octocat/hello-world");
52/// ```
53#[derive(Debug, Clone)]
54pub struct GitHubPrProvider<R: CommandRunner = RealCommandRunner> {
55    /// GitHub `owner/repo`,如 `"byx-darwin/gitflow-cli"`。
56    repo: String,
57    /// 用于执行 `gh` CLI 命令的 runner。
58    runner: R,
59}
60
61impl GitHubPrProvider<RealCommandRunner> {
62    /// 创建新的 GitHub Pull Request 提供者,使用真实的进程执行器。
63    ///
64    /// `repo` 格式为 `owner/repo`。
65    #[must_use]
66    pub fn new(repo: impl Into<String>) -> Self {
67        Self {
68            repo: repo.into(),
69            runner: RealCommandRunner,
70        }
71    }
72
73    /// Create a new provider from a shared [`Session`].
74    ///
75    /// This enables state reuse across multiple operations in workflow chains.
76    #[must_use]
77    pub fn with_session(session: &gitflow_core::Session) -> Self {
78        Self {
79            repo: session.repo.clone(),
80            runner: RealCommandRunner,
81        }
82    }
83}
84
85impl<R: CommandRunner> GitHubPrProvider<R> {
86    /// 使用自定义 [`CommandRunner`] 创建提供者。
87    ///
88    /// 主要用于测试,可注入模拟 runner 以控制 `gh` CLI 的输出。
89    /// `repo` 格式为 `owner/repo`。
90    #[must_use]
91    pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
92        Self {
93            repo: repo.into(),
94            runner,
95        }
96    }
97
98    /// [`PrProvider::list`] 的实际实现。
99    ///
100    /// 抽成普通(非 `async_trait` 装箱)的关联函数,避开泛型 `AsyncFn` 闭包
101    /// 在 `async_trait` 装箱 Future 内部触发的 HRTB `Send` 检查缺陷。
102    async fn list_impl(&self, args: ListPrArgs) -> Result<Paged<PrData>> {
103        let cap = args.limit.unwrap_or(DEFAULT_LIST_LIMIT);
104        let state = args.state.map(|state| match state {
105            State::Open => "open",
106            State::Closed => "closed",
107            State::All => "all",
108        });
109        let repo = &self.repo;
110        let runner = &self.runner;
111
112        debug!(repo = %self.repo, cap, "spawning `gh pr list`");
113
114        fetch_capped(FetchStrategy::SingleShot, cap, |_page, limit| async move {
115            let limit_str = limit.to_string();
116            let mut cmd_args: Vec<&str> = vec!["pr", "list", "--repo", repo, "--json", PR_FIELDS];
117
118            if let Some(state) = state {
119                cmd_args.push("--state");
120                cmd_args.push(state);
121            }
122            cmd_args.push("--limit");
123            cmd_args.push(&limit_str);
124
125            let output = runner
126                .run("gh", &cmd_args)
127                .await
128                .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
129
130            if !output.status.success() {
131                return Err(parse_gh_error(&output.stderr).into());
132            }
133
134            let prs: Vec<PrData> =
135                serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
136            Ok(prs)
137        })
138        .await
139    }
140}
141
142#[async_trait]
143impl<R: CommandRunner + Clone + 'static> PrProvider for GitHubPrProvider<R> {
144    async fn create(&self, args: CreatePrArgs) -> Result<PrData> {
145        let repo = args.repo.as_deref().unwrap_or(&self.repo);
146
147        let mut cmd_args: Vec<&str> = vec![
148            "pr",
149            "create",
150            "--repo",
151            repo,
152            "--title",
153            &args.title,
154            "--head",
155            &args.head,
156            "--base",
157            &args.base,
158        ];
159
160        let final_body =
161            gitflow_core::pr::format_closing_body(&args.body, &args.closes_issues, "Closes");
162
163        if let Some(body) = &final_body {
164            cmd_args.push("--body");
165            cmd_args.push(body);
166        }
167
168        if args.draft {
169            cmd_args.push("--draft");
170        }
171
172        let resolved_milestone_title;
173        if let Some(identifier) = &args.milestone {
174            let milestone_provider =
175                crate::GitHubMilestoneProvider::with_runner(repo, self.runner.clone());
176            let resolved =
177                gitflow_core::label::resolve_milestone_identifier(&milestone_provider, identifier)
178                    .await?;
179            resolved_milestone_title = resolved.title;
180            cmd_args.push("--milestone");
181            cmd_args.push(&resolved_milestone_title);
182        }
183
184        debug!(
185            repo = %self.repo,
186            title = %args.title,
187            head = %args.head,
188            base = %args.base,
189            "spawning `gh pr create`"
190        );
191
192        let output = self
193            .runner
194            .run("gh", &cmd_args)
195            .await
196            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
197
198        if !output.status.success() {
199            return Err(parse_gh_error(&output.stderr).into());
200        }
201
202        // Parse the PR URL from stdout (format: https://github.com/owner/repo/pull/123)
203        let stdout = String::from_utf8_lossy(&output.stdout);
204        let pr_number = parse_pr_number_from_url(&stdout).ok_or_else(|| {
205            CoreError::Platform(format!("Failed to parse PR URL from output: {stdout}"))
206        })?;
207
208        // Fetch full PR details via view
209        self.view(pr_number).await
210    }
211
212    async fn list(&self, args: ListPrArgs) -> Result<Paged<PrData>> {
213        self.list_impl(args).await
214    }
215
216    async fn view(&self, number: u64) -> Result<PrData> {
217        debug!(repo = %self.repo, number, "spawning `gh pr view`");
218
219        let number_str = number.to_string();
220        let output = self
221            .runner
222            .run(
223                "gh",
224                &[
225                    "pr",
226                    "view",
227                    &number_str,
228                    "--repo",
229                    &self.repo,
230                    "--json",
231                    PR_FIELDS,
232                ],
233            )
234            .await
235            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
236
237        if !output.status.success() {
238            return Err(parse_gh_error(&output.stderr).into());
239        }
240
241        let pr: PrData =
242            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
243
244        Ok(pr)
245    }
246
247    /// 关闭指定编号的 PR。
248    ///
249    /// 调用 `gh pr close <number> --repo <repo>` 关闭 PR,
250    /// 并返回更新后的完整 PR 数据。
251    ///
252    /// # Errors
253    ///
254    /// 当 PR 不存在、已关闭或 `gh` CLI 调用失败时返回错误。
255    async fn close(&self, number: u64) -> Result<PrData> {
256        debug!(repo = %self.repo, number, "spawning `gh pr close`");
257
258        let number_str = number.to_string();
259        let output = self
260            .runner
261            .run("gh", &["pr", "close", &number_str, "--repo", &self.repo])
262            .await
263            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
264
265        if !output.status.success() {
266            return Err(parse_gh_error(&output.stderr).into());
267        }
268
269        // Fetch updated PR details
270        self.view(number).await
271    }
272
273    /// 重新打开指定编号的 PR。
274    ///
275    /// 调用 `gh pr reopen <number> --repo <repo>` 重新打开已关闭的 PR,
276    /// 并返回更新后的完整 PR 数据。
277    ///
278    /// # Errors
279    ///
280    /// 当 PR 不存在、未关闭或 `gh` CLI 调用失败时返回错误。
281    async fn reopen(&self, number: u64) -> Result<PrData> {
282        debug!(repo = %self.repo, number, "spawning `gh pr reopen`");
283
284        let number_str = number.to_string();
285        let output = self
286            .runner
287            .run("gh", &["pr", "reopen", &number_str, "--repo", &self.repo])
288            .await
289            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
290
291        if !output.status.success() {
292            return Err(parse_gh_error(&output.stderr).into());
293        }
294
295        // Fetch updated PR details
296        self.view(number).await
297    }
298
299    /// 在指定 PR 上添加评论。
300    ///
301    /// 调用 `gh api repos/{repo}/issues/{number}/comments -X POST` 创建评论,
302    /// 直接从 POST 响应中解析新创建的评论数据。
303    /// (PR 评论使用与 Issue 评论相同的 API 端点。)
304    ///
305    /// # Errors
306    ///
307    /// 当 PR 不存在、`body` 为空或 `gh` CLI 调用失败时返回错误。
308    async fn comment(&self, number: u64, body: &str) -> Result<CommentData> {
309        debug!(repo = %self.repo, number, "spawning `gh api` POST to create PR comment");
310
311        let api_path = format!(
312            "repos/{repo}/issues/{number}/comments",
313            repo = self.repo,
314            number = number
315        );
316
317        let body_field = format!("body={body}");
318        let output = self
319            .runner
320            .run("gh", &["api", &api_path, "-X", "POST", "-f", &body_field])
321            .await
322            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh api: {e}")))?;
323
324        if !output.status.success() {
325            return Err(parse_gh_error(&output.stderr).into());
326        }
327
328        let comment: crate::issue::GitHubCommentApiResponse =
329            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
330
331        Ok(comment.into())
332    }
333
334    /// 合并指定编号的 PR。
335    ///
336    /// 调用 `gh pr merge <number> --repo <repo>` 并根据 `strategy` 参数
337    /// 添加 `--squash`、`--rebase` 或 `--merge` 标志。
338    /// 未指定策略时使用 `--merge`(标准合并)。
339    /// `auto` 为 `true` 时追加 `--auto`,由 GitHub 在必需检查通过后自动合并,
340    /// 调用立即返回;此时 `merged` 为 `false`(排队不等于已合并)。
341    ///
342    /// # Errors
343    ///
344    /// 当 PR 不存在、存在冲突无法合并或 `gh` CLI 调用失败时返回错误。
345    async fn merge(
346        &self,
347        number: u64,
348        strategy: Option<MergeStrategy>,
349        auto: bool,
350    ) -> Result<MergeResult> {
351        debug!(repo = %self.repo, number, ?strategy, auto, "spawning `gh pr merge`");
352
353        let number_str = number.to_string();
354        let mut cmd_args: Vec<&str> = vec!["pr", "merge", &number_str, "--repo", &self.repo];
355
356        match strategy {
357            Some(MergeStrategy::Squash) => cmd_args.push("--squash"),
358            Some(MergeStrategy::Rebase) => cmd_args.push("--rebase"),
359            Some(MergeStrategy::Merge) | None => cmd_args.push("--merge"),
360        }
361
362        if auto {
363            cmd_args.push("--auto");
364        }
365
366        let output = self
367            .runner
368            .run("gh", &cmd_args)
369            .await
370            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
371
372        if !output.status.success() {
373            return Err(parse_gh_error(&output.stderr).into());
374        }
375
376        // `gh pr merge` outputs a human-readable message, not JSON.
377        let message = String::from_utf8_lossy(&output.stdout).trim().to_string();
378        // gh prints nothing for a queued merge; without a message the caller cannot
379        // tell "scheduled" apart from "failed", since both report merged == false.
380        let message = if message.is_empty() && auto {
381            "已排队合并:GitHub 将在必需检查通过后自动合并".to_string()
382        } else {
383            message
384        };
385        Ok(MergeResult {
386            merged: !auto,
387            sha: None,
388            message: Some(message),
389        })
390    }
391
392    /// 在本地检出指定 PR 的分支。
393    ///
394    /// 调用 `gh pr checkout <number> --repo <repo>` 在本地工作区创建并切换到
395    /// PR 的来源分支。如果本地已存在该分支,则尝试更新它。
396    ///
397    /// # Errors
398    ///
399    /// 当 PR 不存在、本地 git 操作失败或 `gh` CLI 调用失败时返回错误。
400    async fn checkout(&self, number: u64) -> Result<()> {
401        debug!(repo = %self.repo, number, "spawning `gh pr checkout`");
402
403        let number_str = number.to_string();
404        let output = self
405            .runner
406            .run("gh", &["pr", "checkout", &number_str, "--repo", &self.repo])
407            .await
408            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
409
410        if !output.status.success() {
411            return Err(parse_gh_error(&output.stderr).into());
412        }
413
414        Ok(())
415    }
416
417    /// 将草稿 PR 标记为可审查状态(ready for review)。
418    ///
419    /// 调用 `gh pr ready <number> --repo <repo>` 将草稿 PR 转为可审查状态,
420    /// 并通过 `gh pr view` 重新获取更新后的 PR 数据。
421    ///
422    /// # Errors
423    ///
424    /// 当 PR 不存在、不是草稿状态或 `gh` CLI 调用失败时返回错误。
425    async fn mark_ready(&self, number: u64) -> Result<PrData> {
426        debug!(repo = %self.repo, number, "spawning `gh pr ready`");
427
428        let number_str = number.to_string();
429        let output = self
430            .runner
431            .run("gh", &["pr", "ready", &number_str, "--repo", &self.repo])
432            .await
433            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
434
435        if !output.status.success() {
436            return Err(parse_gh_error(&output.stderr).into());
437        }
438
439        // `gh pr ready` does not return JSON; re-fetch the PR to get updated data.
440        self.view(number).await
441    }
442
443    /// 将 PR 标记为草稿状态(work in progress)。
444    ///
445    /// 调用 `gh pr convert-to-draft <number> --repo <repo>` 将可审查的 PR 转为草稿,
446    /// 并通过 `gh pr view` 重新获取更新后的 PR 数据。
447    ///
448    /// # Errors
449    ///
450    /// 当 PR 不存在、已是草稿状态或 `gh` CLI 调用失败时返回错误。
451    async fn mark_wip(&self, number: u64) -> Result<PrData> {
452        debug!(repo = %self.repo, number, "spawning `gh pr convert-to-draft`");
453
454        let number_str = number.to_string();
455        let output = self
456            .runner
457            .run(
458                "gh",
459                &["pr", "convert-to-draft", &number_str, "--repo", &self.repo],
460            )
461            .await
462            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
463
464        if !output.status.success() {
465            return Err(parse_gh_error(&output.stderr).into());
466        }
467
468        // `gh pr convert-to-draft` does not return JSON; re-fetch the PR.
469        self.view(number).await
470    }
471
472    /// 同步 PR 的分支(将 base 分支的最新变更合入 head 分支)。
473    ///
474    /// 调用 `gh pr update-branch <number> --repo <repo>` 将 PR 的来源分支
475    /// 更新到与目标分支的最新状态同步,解决分支过时问题。
476    ///
477    /// # Errors
478    ///
479    /// 当 PR 不存在、同步存在冲突或 `gh` CLI 调用失败时返回错误。
480    async fn sync_branch(&self, number: u64) -> Result<()> {
481        debug!(repo = %self.repo, number, "spawning `gh pr update-branch`");
482
483        let number_str = number.to_string();
484        let output = self
485            .runner
486            .run(
487                "gh",
488                &["pr", "update-branch", &number_str, "--repo", &self.repo],
489            )
490            .await
491            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
492
493        if !output.status.success() {
494            return Err(parse_gh_error(&output.stderr).into());
495        }
496
497        Ok(())
498    }
499
500    /// 获取指定 PR 的统一差异格式(unified diff)文本。
501    ///
502    /// 调用 `gh pr diff <number> --repo <repo>` 获取平台原生的 unified diff
503    /// 输出,可直接用于 `git apply`。
504    ///
505    /// # Errors
506    ///
507    /// 当 PR 不存在或 `gh` CLI 调用失败时返回错误。
508    async fn diff(&self, number: u64) -> Result<String> {
509        debug!(repo = %self.repo, number, "spawning `gh pr diff`");
510
511        let number_str = number.to_string();
512        let output = self
513            .runner
514            .run("gh", &["pr", "diff", &number_str, "--repo", &self.repo])
515            .await
516            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh pr diff: {e}")))?;
517
518        if !output.status.success() {
519            return Err(parse_gh_error(&output.stderr).into());
520        }
521
522        Ok(String::from_utf8_lossy(&output.stdout).into_owned())
523    }
524
525    /// 获取指定 PR 的 patch 格式文本(含邮件头信息)。
526    ///
527    /// 调用 `gh api repos/{repo}/pulls/{number}` 并设置 `Accept` 头为
528    /// `application/vnd.github.v3.patch`,返回包含 commit 元数据的 patch 格式输出,
529    /// 可用于 `git am`。
530    ///
531    /// # Errors
532    ///
533    /// 当 PR 不存在或 `gh` CLI 调用失败时返回错误。
534    async fn patch(&self, number: u64) -> Result<String> {
535        debug!(repo = %self.repo, number, "spawning `gh api pr patch`");
536
537        let api_path = format!(
538            "repos/{repo}/pulls/{number}",
539            repo = self.repo,
540            number = number
541        );
542
543        let output = self
544            .runner
545            .run(
546                "gh",
547                &[
548                    "api",
549                    &api_path,
550                    "-H",
551                    "Accept: application/vnd.github.v3.patch",
552                ],
553            )
554            .await
555            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh api pr patch: {e}")))?;
556
557        if !output.status.success() {
558            return Err(parse_gh_error(&output.stderr).into());
559        }
560
561        Ok(String::from_utf8_lossy(&output.stdout).into_owned())
562    }
563
564    /// 查询仓库配置的默认分支(如 `main`、`dev`)。
565    ///
566    /// 调用 `gh repo view --json defaultBranchRef` 并解析 `name` 字段。
567    ///
568    /// # Errors
569    ///
570    /// 当 `gh` CLI 调用失败或响应无法解析时返回错误。
571    async fn default_branch(&self) -> Result<String> {
572        debug!(repo = %self.repo, "spawning `gh repo view`");
573
574        let output = self
575            .runner
576            .run(
577                "gh",
578                &[
579                    "repo",
580                    "view",
581                    "--repo",
582                    &self.repo,
583                    "--json",
584                    "defaultBranchRef",
585                ],
586            )
587            .await
588            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
589
590        if !output.status.success() {
591            return Err(parse_gh_error(&output.stderr).into());
592        }
593
594        let resp: RepoViewResponse =
595            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
596
597        Ok(resp.default_branch_ref.name)
598    }
599}
600
601/// Parse PR number from GitHub URL.
602///
603/// Extracts the numeric PR number from URLs like:
604/// - `https://github.com/owner/repo/pull/123`
605/// - `https://github.enterprise.com/org/project/pull/456`
606fn parse_pr_number_from_url(url: &str) -> Option<u64> {
607    url.lines().find_map(|line| {
608        let line = line.trim();
609        if line.contains("/pull/") {
610            line.rsplit('/').next().and_then(|s| s.parse().ok())
611        } else {
612            None
613        }
614    })
615}
616
617#[cfg(test)]
618mod tests {
619    use super::*;
620    use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
621
622    #[test]
623    fn test_should_construct_github_pr_provider() {
624        let provider = GitHubPrProvider::new("octocat/hello-world");
625        assert_eq!(provider.repo, "octocat/hello-world");
626    }
627
628    #[test]
629    fn test_should_construct_github_pr_provider_from_string() {
630        let repo = String::from("octocat/hello-world");
631        let provider = GitHubPrProvider::new(repo);
632        assert_eq!(provider.repo, "octocat/hello-world");
633    }
634
635    #[test]
636    fn test_should_deserialize_pr_data_from_gh_output() {
637        // 模拟 `gh pr view --json ...` 的实际输出
638        let gh_json = br#"{
639            "number": 123,
640            "title": "Add new feature",
641            "body": "This PR adds a new feature",
642            "state": "open",
643            "draft": false,
644            "author": {"login": "alice", "id": "2"},
645            "baseBranch": "main",
646            "headBranch": "feature/new-thing",
647            "createdAt": "2026-02-20T14:00:00Z",
648            "updatedAt": "2026-02-21T10:30:00Z",
649            "url": "https://github.com/octocat/hello-world/pull/123"
650        }"#;
651
652        let pr: PrData = serde_json::from_slice(gh_json).expect("valid PrData JSON");
653        assert_eq!(pr.number, 123);
654        assert_eq!(pr.title, "Add new feature");
655        assert_eq!(pr.state, State::Open);
656        assert!(!pr.draft);
657        assert_eq!(pr.author.login, "alice");
658        assert_eq!(pr.base_branch, "main");
659        assert_eq!(pr.head_branch, "feature/new-thing");
660        assert_eq!(pr.url, "https://github.com/octocat/hello-world/pull/123");
661    }
662
663    #[test]
664    fn test_should_deserialize_pr_with_missing_timestamps_as_none() {
665        // gh CLI is not known to ever omit createdAt/updatedAt, but PrData's
666        // fields are now Option<DateTime<Utc>> at the core level (#380) — this
667        // pins that the github path tolerates their absence gracefully rather
668        // than erroring, since this crate has no intermediate struct or
669        // fallback logic of its own for PrData.
670        let gh_json = br#"{
671            "number": 9,
672            "title": "No timestamps",
673            "state": "open",
674            "draft": false,
675            "author": {"login": "octocat", "id": "1"},
676            "baseBranch": "main",
677            "headBranch": "feature/x",
678            "mergedAt": null,
679            "url": "https://github.com/octocat/hello-world/pull/9"
680        }"#;
681
682        let pr: PrData =
683            serde_json::from_slice(gh_json).expect("missing timestamps must not error");
684        assert!(pr.created_at.is_none());
685        assert!(pr.updated_at.is_none());
686    }
687
688    #[test]
689    fn test_should_distinguish_merged_from_closed_via_merged_at() {
690        // gh reports both as state MERGED/CLOSED → State::Closed, so merged_at is the
691        // only signal that separates a merged PR from one closed without merging.
692        let merged: PrData = serde_json::from_slice(
693            br#"{
694                "number": 1, "title": "m", "state": "merged", "draft": false,
695                "author": {"login": "alice", "id": "2"},
696                "baseBranch": "main", "headBranch": "feature/m",
697                "createdAt": "2026-02-20T14:00:00Z", "updatedAt": "2026-02-21T10:30:00Z",
698                "mergedAt": "2026-02-21T10:30:00Z",
699                "url": "https://github.com/o/r/pull/1"
700            }"#,
701        )
702        .expect("merged PrData");
703
704        let closed_unmerged: PrData = serde_json::from_slice(
705            br#"{
706                "number": 2, "title": "c", "state": "closed", "draft": false,
707                "author": {"login": "alice", "id": "2"},
708                "baseBranch": "main", "headBranch": "feature/c",
709                "createdAt": "2026-02-20T14:00:00Z", "updatedAt": "2026-02-21T10:30:00Z",
710                "mergedAt": null,
711                "url": "https://github.com/o/r/pull/2"
712            }"#,
713        )
714        .expect("closed PrData");
715
716        assert_eq!(merged.state, closed_unmerged.state, "state alone is equal");
717        assert!(
718            merged.merged_at.is_some(),
719            "mergedAt must populate merged_at"
720        );
721        assert!(
722            closed_unmerged.merged_at.is_none(),
723            "null mergedAt must stay None, not become some timestamp"
724        );
725    }
726
727    #[test]
728    fn test_should_deserialize_empty_pr_list_from_gh_output() {
729        let gh_json = b"[]";
730        let prs: Vec<PrData> = serde_json::from_slice(gh_json).expect("valid PrData list");
731        assert!(prs.is_empty());
732    }
733
734    #[test]
735    fn test_should_deserialize_draft_pr_from_gh_output() {
736        let gh_json = br#"{
737            "number": 456,
738            "title": "WIP: experiment",
739            "body": null,
740            "state": "open",
741            "draft": true,
742            "author": {"login": "bob", "id": "3"},
743            "baseBranch": "main",
744            "headBranch": "wip/experiment",
745            "createdAt": "2026-03-10T09:00:00Z",
746            "updatedAt": "2026-03-10T09:00:00Z",
747            "url": "https://github.com/octocat/hello-world/pull/456"
748        }"#;
749
750        let pr: PrData = serde_json::from_slice(gh_json).expect("valid PrData JSON");
751        assert!(pr.draft);
752        assert!(pr.body.is_none());
753        assert_eq!(pr.title, "WIP: experiment");
754    }
755
756    #[test]
757    fn test_should_debug_format_provider() {
758        let provider = GitHubPrProvider::new("octocat/hello-world");
759        let debug = format!("{provider:?}");
760        assert!(debug.contains("GitHubPrProvider"));
761        assert!(debug.contains("octocat/hello-world"));
762    }
763
764    // --- close/reopen: deserialized PrData tests ---
765
766    #[test]
767    fn test_should_deserialize_closed_pr_from_gh_close_output() {
768        // 模拟 `gh pr close --json ...` 的返回数据
769        let gh_json = br#"{
770            "number": 50,
771            "title": "Obsolete change",
772            "body": "Superseded by #55",
773            "state": "closed",
774            "draft": false,
775            "author": {"login": "dev", "id": "10"},
776            "baseBranch": "main",
777            "headBranch": "feature/obsolete",
778            "createdAt": "2026-05-01T08:00:00Z",
779            "updatedAt": "2026-05-02T12:00:00Z",
780            "url": "https://github.com/octocat/hello-world/pull/50"
781        }"#;
782
783        let pr: PrData = serde_json::from_slice(gh_json).expect("valid closed PrData");
784        assert_eq!(pr.number, 50);
785        assert_eq!(pr.state, State::Closed);
786    }
787
788    #[test]
789    fn test_should_deserialize_reopened_pr_from_gh_reopen_output() {
790        let gh_json = br#"{
791            "number": 50,
792            "title": "Obsolete change",
793            "body": "Actually still needed",
794            "state": "open",
795            "draft": false,
796            "author": {"login": "dev", "id": "10"},
797            "baseBranch": "main",
798            "headBranch": "feature/obsolete",
799            "createdAt": "2026-05-01T08:00:00Z",
800            "updatedAt": "2026-05-03T09:00:00Z",
801            "url": "https://github.com/octocat/hello-world/pull/50"
802        }"#;
803
804        let pr: PrData = serde_json::from_slice(gh_json).expect("valid reopened PrData");
805        assert_eq!(pr.number, 50);
806        assert_eq!(pr.state, State::Open);
807    }
808
809    // --- comment: CommentData deserialization tests ---
810
811    #[test]
812    fn test_should_deserialize_comment_data_from_gh_pr_comment_output() {
813        // 模拟 `gh pr comment --json id,body,author,createdAt` 的输出
814        let gh_json = br#"{
815            "id": 2002,
816            "body": "Approved, merging now.",
817            "author": {"login": "reviewer", "id": "88"},
818            "createdAt": "2026-06-20T16:00:00Z"
819        }"#;
820
821        let comment: CommentData = serde_json::from_slice(gh_json).expect("valid CommentData");
822        assert_eq!(comment.id, 2002);
823        assert_eq!(comment.body, "Approved, merging now.");
824        assert_eq!(comment.author.login, "reviewer");
825        assert_eq!(comment.author.id, "88");
826    }
827
828    #[tokio::test]
829    async fn test_should_return_newly_created_pr_comment_not_stale() {
830        use crate::runner::MockCommandRunner;
831
832        // Mock `gh api POST` response — the comment just created
833        let post_response_json = r#"{
834            "id": 8888888888,
835            "body": "NEW PR comment",
836            "user": {"login": "reviewer", "id": 99},
837            "created_at": "2026-08-04T13:00:00Z"
838        }"#;
839
840        let runner = MockCommandRunner::success(post_response_json);
841        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
842
843        let result = provider.comment(7, "NEW PR comment").await.unwrap();
844
845        // The returned id must be the NEW comment's id, not a stale one
846        assert_eq!(result.id, 8_888_888_888);
847        assert_eq!(result.body, "NEW PR comment");
848        assert_eq!(result.author.login, "reviewer");
849    }
850
851    #[tokio::test]
852    async fn test_should_return_error_when_pr_comment_api_fails() {
853        use crate::runner::MockCommandRunner;
854
855        let runner = MockCommandRunner::failure(
856            r#"{"message": "Not Found", "documentation_url": "https://docs.github.com"}"#,
857            1,
858        );
859        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
860
861        let result = provider.comment(999, "test").await;
862
863        assert!(result.is_err());
864        let err = result.unwrap_err();
865        // `parse_gh_error` returns `PlatformCliError`, which converts to
866        // `CoreError::Cli` (matching the existing comment error-path test).
867        assert!(
868            matches!(err, CoreError::Cli(_)),
869            "expected Cli error, got: {err:?}"
870        );
871    }
872
873    // --- merge: MergeResult deserialization tests ---
874
875    #[test]
876    fn test_should_deserialize_merge_result_from_gh_merge_output() {
877        // `gh pr merge` 返回人类可读文本,不是 JSON。
878        // MergeResult 由代码构造,但需确保序列化/反序列化正确。
879        let gh_text = b"Pull request #123 was successfully merged.\n";
880        let message = String::from_utf8_lossy(gh_text).trim().to_string();
881        let result = MergeResult {
882            merged: true,
883            sha: None,
884            message: Some(message),
885        };
886
887        assert!(result.merged);
888        assert!(result.message.as_deref().is_some());
889        assert_eq!(
890            result.message.as_deref(),
891            Some("Pull request #123 was successfully merged.")
892        );
893    }
894
895    #[test]
896    fn test_should_roundtrip_merge_result_via_serde() {
897        let result = MergeResult {
898            merged: true,
899            sha: Some("deadbeef1234".into()),
900            message: Some("Squash merged".into()),
901        };
902        let json = serde_json::to_string(&result).expect("serialize");
903        let round_tripped: MergeResult = serde_json::from_str(&json).expect("deserialize");
904        assert!(round_tripped.merged);
905        assert_eq!(round_tripped.sha, result.sha);
906        assert_eq!(round_tripped.message, result.message);
907    }
908
909    #[test]
910    fn test_should_serialize_merge_result_skips_null_fields() {
911        let result = MergeResult {
912            merged: false,
913            sha: None,
914            message: None,
915        };
916        let json = serde_json::to_string(&result).expect("serialize");
917        assert!(!json.contains("null"));
918        assert_eq!(json, r#"{"merged":false}"#);
919    }
920
921    // --- provider construction / clone tests ---
922
923    #[test]
924    fn test_should_create_provider_with_different_repos() {
925        let r1 = GitHubPrProvider::new("org/repo-a");
926        let r2 = GitHubPrProvider::new("org/repo-b");
927        assert_eq!(r1.repo, "org/repo-a");
928        assert_eq!(r2.repo, "org/repo-b");
929    }
930
931    #[test]
932    fn test_should_clone_github_pr_provider() {
933        let original = GitHubPrProvider::new("owner/repo");
934        let cloned = original.clone();
935        assert_eq!(original.repo, cloned.repo);
936    }
937
938    #[test]
939    fn test_should_parse_pr_number_from_url() {
940        assert_eq!(
941            parse_pr_number_from_url("https://github.com/owner/repo/pull/123"),
942            Some(123)
943        );
944        assert_eq!(
945            parse_pr_number_from_url("https://github.enterprise.com/org/project/pull/456"),
946            Some(456)
947        );
948    }
949
950    #[test]
951    fn test_should_parse_pr_number_from_multiline_output() {
952        let output = "some header\nhttps://github.com/owner/repo/pull/789\nsome footer";
953        assert_eq!(parse_pr_number_from_url(output), Some(789));
954    }
955
956    #[test]
957    fn test_should_return_none_when_no_pr_url() {
958        assert_eq!(parse_pr_number_from_url("no pull url here"), None);
959        assert_eq!(parse_pr_number_from_url(""), None);
960        assert_eq!(
961            parse_pr_number_from_url("https://github.com/owner/repo/issues/123"),
962            None
963        );
964    }
965
966    // --- Failure-path tests using an injected MockCommandRunner ---
967
968    fn sample_create_args() -> CreatePrArgs {
969        CreatePrArgs {
970            title: "Add feature".to_string(),
971            body: Some("Detailed description".to_string()),
972            head: "feature/new".to_string(),
973            base: "main".to_string(),
974            draft: false,
975            repo: None,
976            closes_issues: vec![],
977            milestone: None,
978        }
979    }
980
981    #[test]
982    fn test_should_format_github_body_with_closing_issues() {
983        use gitflow_core::pr::format_closing_body;
984
985        let body = Some("Feature description".to_string());
986        let issues = vec![24u64, 23];
987        let result = format_closing_body(&body, &issues, "Closes");
988        assert_eq!(
989            result,
990            Some("Feature description\n\nCloses #24\nCloses #23".to_string())
991        );
992    }
993
994    #[tokio::test]
995    async fn test_should_return_platform_error_when_gh_fails_for_create() {
996        let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
997        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
998
999        let result = provider.create(sample_create_args()).await;
1000
1001        assert!(result.is_err());
1002        assert!(matches!(
1003            result.unwrap_err(),
1004            gitflow_core::CoreError::Cli(_)
1005        ));
1006    }
1007
1008    #[tokio::test]
1009    async fn test_should_return_platform_error_on_url_parse_failure_for_create() {
1010        // `create` succeeds but stdout has no parseable PR URL, so URL parsing fails.
1011        let runner = MockCommandRunner::success("no pull url here");
1012        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1013
1014        let result = provider.create(sample_create_args()).await;
1015
1016        assert!(result.is_err());
1017        assert!(matches!(
1018            result.unwrap_err(),
1019            gitflow_core::CoreError::Platform(_)
1020        ));
1021    }
1022
1023    #[tokio::test]
1024    async fn test_should_return_platform_error_when_gh_fails_for_list() {
1025        let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
1026        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1027
1028        let result = provider.list(ListPrArgs::default()).await;
1029
1030        assert!(result.is_err());
1031        assert!(matches!(
1032            result.unwrap_err(),
1033            gitflow_core::CoreError::Cli(_)
1034        ));
1035    }
1036
1037    #[tokio::test]
1038    async fn test_should_return_serialization_error_on_invalid_json_for_list() {
1039        let runner = MockCommandRunner::success("invalid json");
1040        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1041
1042        let result = provider.list(ListPrArgs::default()).await;
1043
1044        assert!(result.is_err());
1045        assert!(matches!(
1046            result.unwrap_err(),
1047            gitflow_core::CoreError::Serialization(_)
1048        ));
1049    }
1050
1051    #[tokio::test]
1052    async fn test_should_return_platform_error_when_gh_fails_for_view() {
1053        let runner = MockCommandRunner::failure(r#"{"message": "PR not found"}"#, 256);
1054        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1055
1056        let result = provider.view(999).await;
1057
1058        assert!(result.is_err());
1059        assert!(matches!(
1060            result.unwrap_err(),
1061            gitflow_core::CoreError::Cli(_)
1062        ));
1063    }
1064
1065    #[tokio::test]
1066    async fn test_should_return_serialization_error_on_invalid_json_for_view() {
1067        let runner = MockCommandRunner::success("invalid json");
1068        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1069
1070        let result = provider.view(1).await;
1071
1072        assert!(result.is_err());
1073        assert!(matches!(
1074            result.unwrap_err(),
1075            gitflow_core::CoreError::Serialization(_)
1076        ));
1077    }
1078
1079    #[tokio::test]
1080    async fn test_should_return_platform_error_when_gh_fails_for_close() {
1081        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1082        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1083
1084        let result = provider.close(42).await;
1085
1086        assert!(result.is_err());
1087        assert!(matches!(
1088            result.unwrap_err(),
1089            gitflow_core::CoreError::Cli(_)
1090        ));
1091    }
1092
1093    #[tokio::test]
1094    async fn test_should_return_platform_error_when_gh_fails_for_reopen() {
1095        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1096        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1097
1098        let result = provider.reopen(42).await;
1099
1100        assert!(result.is_err());
1101        assert!(matches!(
1102            result.unwrap_err(),
1103            gitflow_core::CoreError::Cli(_)
1104        ));
1105    }
1106
1107    #[tokio::test]
1108    async fn test_should_return_platform_error_when_gh_fails_for_merge() {
1109        let runner = MockCommandRunner::failure(r#"{"message": "Merge conflict"}"#, 256);
1110        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1111
1112        let result = provider.merge(42, None, false).await;
1113
1114        assert!(result.is_err());
1115        assert!(matches!(
1116            result.unwrap_err(),
1117            gitflow_core::CoreError::Cli(_)
1118        ));
1119    }
1120
1121    #[tokio::test]
1122    async fn test_should_forward_auto_and_report_not_merged_for_queued_merge() {
1123        // Observed behaviour: `gh pr merge --auto` exits 0 with empty stdout.
1124        let runner = MockCommandRunner::success("");
1125        let provider = GitHubPrProvider::with_runner("owner/repo", runner.clone());
1126
1127        let result = provider
1128            .merge(42, Some(MergeStrategy::Squash), true)
1129            .await
1130            .expect("queued merge should succeed");
1131
1132        let args = &runner.recorded_calls()[0].1;
1133        assert!(
1134            args.iter().any(|a| a == "--auto"),
1135            "`--auto` must be forwarded to gh, got {args:?}"
1136        );
1137        assert!(
1138            !result.merged,
1139            "a scheduled merge has not landed, so merged must be false"
1140        );
1141        let message = result.message.unwrap_or_default();
1142        assert!(
1143            message.contains("排队"),
1144            "empty gh stdout must be replaced by a scheduled-merge message, got {message:?}"
1145        );
1146    }
1147
1148    #[tokio::test]
1149    async fn test_should_return_platform_error_on_invalid_json_for_merge() {
1150        // `gh pr merge` returns human-readable text, so any successful output is a
1151        // valid message. A failing exit status is the merge failure path instead.
1152        let runner = MockCommandRunner::failure("invalid json", 256);
1153        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1154
1155        let result = provider.merge(42, Some(MergeStrategy::Squash), false).await;
1156
1157        assert!(result.is_err());
1158        assert!(matches!(
1159            result.unwrap_err(),
1160            gitflow_core::CoreError::Cli(_)
1161        ));
1162    }
1163
1164    #[tokio::test]
1165    async fn test_should_return_platform_error_when_gh_fails_for_checkout() {
1166        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1167        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1168
1169        let result = provider.checkout(42).await;
1170
1171        assert!(result.is_err());
1172        assert!(matches!(
1173            result.unwrap_err(),
1174            gitflow_core::CoreError::Cli(_)
1175        ));
1176    }
1177
1178    #[tokio::test]
1179    async fn test_should_return_platform_error_when_gh_fails_for_sync_branch() {
1180        let runner = MockCommandRunner::failure(r#"{"message": "Conflict"}"#, 256);
1181        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1182
1183        let result = provider.sync_branch(42).await;
1184
1185        assert!(result.is_err());
1186        assert!(matches!(
1187            result.unwrap_err(),
1188            gitflow_core::CoreError::Cli(_)
1189        ));
1190    }
1191
1192    #[tokio::test]
1193    async fn test_should_return_platform_error_when_gh_fails_for_mark_ready() {
1194        let runner = MockCommandRunner::failure(r#"{"message": "Not a draft"}"#, 256);
1195        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1196
1197        let result = provider.mark_ready(42).await;
1198
1199        assert!(result.is_err());
1200        assert!(matches!(
1201            result.unwrap_err(),
1202            gitflow_core::CoreError::Cli(_)
1203        ));
1204    }
1205
1206    #[tokio::test]
1207    async fn test_should_return_platform_error_when_gh_fails_for_mark_wip() {
1208        let runner = MockCommandRunner::failure(r#"{"message": "Already a draft"}"#, 256);
1209        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1210
1211        let result = provider.mark_wip(42).await;
1212
1213        assert!(result.is_err());
1214        assert!(matches!(
1215            result.unwrap_err(),
1216            gitflow_core::CoreError::Cli(_)
1217        ));
1218    }
1219
1220    #[tokio::test]
1221    async fn test_should_return_platform_error_when_gh_fails_for_comment() {
1222        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1223        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1224
1225        let result = provider.comment(42, "a comment").await;
1226
1227        assert!(result.is_err());
1228        assert!(matches!(
1229            result.unwrap_err(),
1230            gitflow_core::CoreError::Cli(_)
1231        ));
1232    }
1233
1234    // --- diff() tests ---
1235
1236    #[tokio::test]
1237    async fn test_should_fetch_pr_diff() {
1238        let diff_output = "diff --git a/file.txt b/file.txt\nindex 1234567..abcdefg 100644\n--- \
1239                           a/file.txt\n+++ b/file.txt\n@@ -1 +1 @@\n-old\n+new\n";
1240        let runner = MockCommandRunner::success(diff_output);
1241        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1242
1243        let result = provider.diff(42).await.expect("diff should succeed");
1244        assert_eq!(result, diff_output);
1245    }
1246
1247    #[tokio::test]
1248    async fn test_should_return_error_when_pr_diff_fails() {
1249        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1250        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1251
1252        let result = provider.diff(999).await;
1253        assert!(result.is_err());
1254        assert!(matches!(
1255            result.unwrap_err(),
1256            gitflow_core::CoreError::Cli(_)
1257        ));
1258    }
1259
1260    // --- patch() tests ---
1261
1262    #[tokio::test]
1263    async fn test_should_fetch_pr_patch() {
1264        let patch_output =
1265            "From abc123\nSubject: [PATCH] Update file\n\ndiff --git a/file.txt b/file.txt\n";
1266        let runner = MockCommandRunner::success(patch_output);
1267        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1268
1269        let result = provider.patch(42).await.expect("patch should succeed");
1270        assert_eq!(result, patch_output);
1271    }
1272
1273    #[tokio::test]
1274    async fn test_should_return_error_when_pr_patch_fails() {
1275        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1276        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1277
1278        let result = provider.patch(999).await;
1279        assert!(result.is_err());
1280        assert!(matches!(
1281            result.unwrap_err(),
1282            gitflow_core::CoreError::Cli(_)
1283        ));
1284    }
1285
1286    // --- default_branch() tests ---
1287
1288    #[tokio::test]
1289    async fn test_should_return_default_branch_on_success() {
1290        let runner = MockCommandRunner::success(r#"{"defaultBranchRef":{"name":"dev"}}"#);
1291        let provider = GitHubPrProvider::with_runner("octocat/hello-world", runner);
1292
1293        let result = provider.default_branch().await;
1294
1295        assert!(result.is_ok());
1296        assert_eq!(result.expect("already checked"), "dev");
1297    }
1298
1299    #[tokio::test]
1300    async fn test_should_send_expected_argv_for_default_branch() {
1301        let runner = MockCommandRunner::success(r#"{"defaultBranchRef":{"name":"dev"}}"#);
1302        let provider = GitHubPrProvider::with_runner("octocat/hello-world", runner.clone());
1303
1304        let _ = provider.default_branch().await;
1305
1306        let calls = runner.recorded_calls();
1307        assert_eq!(calls[0].0, "gh");
1308        assert_eq!(
1309            calls[0].1,
1310            vec![
1311                "repo",
1312                "view",
1313                "--repo",
1314                "octocat/hello-world",
1315                "--json",
1316                "defaultBranchRef",
1317            ]
1318        );
1319    }
1320
1321    #[tokio::test]
1322    async fn test_should_return_error_when_repo_view_fails() {
1323        let runner = MockCommandRunner::failure("gh: Not Found (HTTP 404)", 1);
1324        let provider = GitHubPrProvider::with_runner("octocat/nonexistent", runner);
1325
1326        let result = provider.default_branch().await;
1327
1328        assert!(result.is_err());
1329    }
1330
1331    #[tokio::test]
1332    async fn test_should_request_default_cap_plus_one_for_pr_list() {
1333        let runner = MockCommandRunner::success("[]");
1334        let provider = GitHubPrProvider::with_runner("owner/repo", runner.clone());
1335        let paged = provider
1336            .list(ListPrArgs::default())
1337            .await
1338            .expect("list should succeed");
1339        assert!(!paged.truncated);
1340        let recorded = &runner.recorded_calls()[0].1;
1341        assert!(
1342            recorded
1343                .windows(2)
1344                .any(|w| w[0] == "--limit" && w[1] == "1001"),
1345            "实际 argv: {recorded:?}"
1346        );
1347    }
1348
1349    #[tokio::test]
1350    async fn test_should_still_forward_state_filter_for_pr_list() {
1351        let runner = MockCommandRunner::success("[]");
1352        let provider = GitHubPrProvider::with_runner("owner/repo", runner.clone());
1353        let args = ListPrArgs {
1354            state: Some(State::Open),
1355            ..ListPrArgs::default()
1356        };
1357        provider.list(args).await.expect("list should succeed");
1358        let recorded = &runner.recorded_calls()[0].1;
1359        assert!(
1360            recorded
1361                .windows(2)
1362                .any(|w| w[0] == "--state" && w[1] == "open")
1363        );
1364    }
1365
1366    #[tokio::test]
1367    async fn test_should_produce_complete_argv_for_pr_list_with_state() {
1368        let runner = MockCommandRunner::success("[]");
1369        let provider = GitHubPrProvider::with_runner("owner/repo", runner.clone());
1370        let args = ListPrArgs {
1371            state: Some(State::Open),
1372            ..ListPrArgs::default()
1373        };
1374        provider.list(args).await.expect("list should succeed");
1375        let recorded = &runner.recorded_calls()[0];
1376        assert_eq!(recorded.0, "gh");
1377        assert_eq!(
1378            recorded.1,
1379            vec![
1380                "pr",
1381                "list",
1382                "--repo",
1383                "owner/repo",
1384                "--json",
1385                PR_FIELDS,
1386                "--state",
1387                "open",
1388                "--limit",
1389                "1001",
1390            ]
1391        );
1392    }
1393
1394    // --- milestone wiring: create ---
1395
1396    const MILESTONE_LIST_JSON: &str = r#"[
1397        {"number": 3, "title": "v2.0", "state": "open", "description": null}
1398    ]"#;
1399
1400    #[tokio::test]
1401    async fn test_should_wire_resolved_milestone_title_into_pr_create() {
1402        // Sequence:
1403        // 1. milestone resolution: `gh api repos/owner/repo/milestones?...`
1404        // 2. `gh pr create ... --milestone v2.0`
1405        // 3. `gh pr view <number>` (create() delegates to view())
1406        let runner = SequencedMockCommandRunner::from_results(&[
1407            (true, MILESTONE_LIST_JSON),
1408            (true, "https://github.com/owner/repo/pull/42"),
1409            (
1410                true,
1411                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"}"#,
1412            ),
1413        ]);
1414        let provider = GitHubPrProvider::with_runner("owner/repo", runner.clone());
1415
1416        let mut args = sample_create_args();
1417        args.milestone = Some("3".to_string());
1418
1419        let pr = provider.create(args).await.expect("create should succeed");
1420        assert_eq!(
1421            pr.milestone,
1422            Some(gitflow_core::types::MilestoneRef {
1423                number: 3,
1424                title: "v2.0".into()
1425            })
1426        );
1427
1428        let calls = runner.recorded_calls();
1429        assert_eq!(calls.len(), 3, "expected exactly 3 gh invocations");
1430        let create_call = &calls[1].1;
1431        assert!(
1432            create_call
1433                .windows(2)
1434                .any(|w| w[0] == "--milestone" && w[1] == "v2.0"),
1435            "pr create argv must carry the resolved milestone title, got: {create_call:?}"
1436        );
1437    }
1438
1439    #[tokio::test]
1440    async fn test_should_propagate_error_when_milestone_identifier_not_found_on_pr_create() {
1441        let runner = SequencedMockCommandRunner::from_results(&[(true, MILESTONE_LIST_JSON)]);
1442        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1443
1444        let mut args = sample_create_args();
1445        args.milestone = Some("does-not-exist".to_string());
1446
1447        let result = provider.create(args).await;
1448        assert!(result.is_err());
1449    }
1450}