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, Result,
10    pr::{CreatePrArgs, ListPrArgs, PrData, PrProvider},
11    types::{CommentData, MergeResult, MergeStrategy, State},
12};
13use tracing::debug;
14
15use crate::{
16    error::parse_gh_error,
17    runner::{CommandRunner, RealCommandRunner},
18};
19
20/// `gh pr` 请求的 JSON 字段列表。
21const PR_FIELDS: &str =
22    "number,title,body,state,isDraft,author,baseRefName,headRefName,createdAt,updatedAt,url";
23
24/// GitHub Pull Request 提供者,通过 `gh` CLI 操作。
25///
26/// 该结构体通过调用 `gh` CLI 实现 [`PrProvider`] trait 的所有方法,
27/// 使上层命令能够以统一的方式操作 GitHub Pull Request。
28///
29/// 命令执行通过 [`CommandRunner`] 抽象,生产环境默认使用
30/// [`RealCommandRunner`],测试可注入自定义 runner 以模拟成功或失败场景。
31///
32/// # Examples
33///
34/// ```no_run
35/// use gitflow_github::GitHubPrProvider;
36///
37/// let provider = GitHubPrProvider::new("octocat/hello-world");
38/// ```
39#[derive(Debug, Clone)]
40pub struct GitHubPrProvider<R: CommandRunner = RealCommandRunner> {
41    /// GitHub `owner/repo`,如 `"byx-darwin/gitflow-cli"`。
42    repo: String,
43    /// 用于执行 `gh` CLI 命令的 runner。
44    runner: R,
45}
46
47impl GitHubPrProvider<RealCommandRunner> {
48    /// 创建新的 GitHub Pull Request 提供者,使用真实的进程执行器。
49    ///
50    /// `repo` 格式为 `owner/repo`。
51    #[must_use]
52    pub fn new(repo: impl Into<String>) -> Self {
53        Self {
54            repo: repo.into(),
55            runner: RealCommandRunner,
56        }
57    }
58}
59
60impl<R: CommandRunner> GitHubPrProvider<R> {
61    /// 使用自定义 [`CommandRunner`] 创建提供者。
62    ///
63    /// 主要用于测试,可注入模拟 runner 以控制 `gh` CLI 的输出。
64    /// `repo` 格式为 `owner/repo`。
65    #[must_use]
66    pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
67        Self {
68            repo: repo.into(),
69            runner,
70        }
71    }
72}
73
74#[async_trait]
75impl<R: CommandRunner + 'static> PrProvider for GitHubPrProvider<R> {
76    async fn create(&self, args: CreatePrArgs) -> Result<PrData> {
77        let repo = args.repo.as_deref().unwrap_or(&self.repo);
78
79        let mut cmd_args: Vec<&str> = vec![
80            "pr",
81            "create",
82            "--repo",
83            repo,
84            "--title",
85            &args.title,
86            "--head",
87            &args.head,
88            "--base",
89            &args.base,
90        ];
91
92        if let Some(body) = &args.body {
93            cmd_args.push("--body");
94            cmd_args.push(body);
95        }
96
97        if args.draft {
98            cmd_args.push("--draft");
99        }
100
101        debug!(
102            repo = %self.repo,
103            title = %args.title,
104            head = %args.head,
105            base = %args.base,
106            "spawning `gh pr create`"
107        );
108
109        let output = self
110            .runner
111            .run("gh", &cmd_args)
112            .await
113            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
114
115        if !output.status.success() {
116            return Err(parse_gh_error(&output.stderr).into());
117        }
118
119        // Parse the PR URL from stdout (format: https://github.com/owner/repo/pull/123)
120        let stdout = String::from_utf8_lossy(&output.stdout);
121        let pr_number = parse_pr_number_from_url(&stdout).ok_or_else(|| {
122            CoreError::Platform(format!("Failed to parse PR URL from output: {stdout}"))
123        })?;
124
125        // Fetch full PR details via view
126        self.view(pr_number).await
127    }
128
129    async fn list(&self, args: ListPrArgs) -> Result<Vec<PrData>> {
130        let mut cmd_args: Vec<&str> = vec!["pr", "list", "--repo", &self.repo, "--json", PR_FIELDS];
131
132        if let Some(state) = &args.state {
133            cmd_args.push("--state");
134            cmd_args.push(match state {
135                State::Open => "open",
136                State::Closed => "closed",
137            });
138        }
139
140        let limit_str = args.limit.map(|limit| limit.to_string());
141        if let Some(ref limit) = limit_str {
142            cmd_args.push("--limit");
143            cmd_args.push(limit);
144        }
145
146        debug!(repo = %self.repo, "spawning `gh pr list`");
147
148        let output = self
149            .runner
150            .run("gh", &cmd_args)
151            .await
152            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
153
154        if !output.status.success() {
155            return Err(parse_gh_error(&output.stderr).into());
156        }
157
158        let prs: Vec<PrData> =
159            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
160
161        Ok(prs)
162    }
163
164    async fn view(&self, number: u64) -> Result<PrData> {
165        debug!(repo = %self.repo, number, "spawning `gh pr view`");
166
167        let number_str = number.to_string();
168        let output = self
169            .runner
170            .run(
171                "gh",
172                &[
173                    "pr",
174                    "view",
175                    &number_str,
176                    "--repo",
177                    &self.repo,
178                    "--json",
179                    PR_FIELDS,
180                ],
181            )
182            .await
183            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
184
185        if !output.status.success() {
186            return Err(parse_gh_error(&output.stderr).into());
187        }
188
189        let pr: PrData =
190            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
191
192        Ok(pr)
193    }
194
195    /// 关闭指定编号的 PR。
196    ///
197    /// 调用 `gh pr close <number> --repo <repo>` 关闭 PR,
198    /// 并返回更新后的完整 PR 数据。
199    ///
200    /// # Errors
201    ///
202    /// 当 PR 不存在、已关闭或 `gh` CLI 调用失败时返回错误。
203    async fn close(&self, number: u64) -> Result<PrData> {
204        debug!(repo = %self.repo, number, "spawning `gh pr close`");
205
206        let number_str = number.to_string();
207        let output = self
208            .runner
209            .run("gh", &["pr", "close", &number_str, "--repo", &self.repo])
210            .await
211            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
212
213        if !output.status.success() {
214            return Err(parse_gh_error(&output.stderr).into());
215        }
216
217        // Fetch updated PR details
218        self.view(number).await
219    }
220
221    /// 重新打开指定编号的 PR。
222    ///
223    /// 调用 `gh pr reopen <number> --repo <repo>` 重新打开已关闭的 PR,
224    /// 并返回更新后的完整 PR 数据。
225    ///
226    /// # Errors
227    ///
228    /// 当 PR 不存在、未关闭或 `gh` CLI 调用失败时返回错误。
229    async fn reopen(&self, number: u64) -> Result<PrData> {
230        debug!(repo = %self.repo, number, "spawning `gh pr reopen`");
231
232        let number_str = number.to_string();
233        let output = self
234            .runner
235            .run("gh", &["pr", "reopen", &number_str, "--repo", &self.repo])
236            .await
237            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
238
239        if !output.status.success() {
240            return Err(parse_gh_error(&output.stderr).into());
241        }
242
243        // Fetch updated PR details
244        self.view(number).await
245    }
246
247    /// 在指定 PR 上添加评论。
248    ///
249    /// 调用 `gh api repos/{repo}/issues/{number}/comments -X POST` 创建评论,
250    /// 直接从 POST 响应中解析新创建的评论数据。
251    /// (PR 评论使用与 Issue 评论相同的 API 端点。)
252    ///
253    /// # Errors
254    ///
255    /// 当 PR 不存在、`body` 为空或 `gh` CLI 调用失败时返回错误。
256    async fn comment(&self, number: u64, body: &str) -> Result<CommentData> {
257        debug!(repo = %self.repo, number, "spawning `gh api` POST to create PR comment");
258
259        let api_path = format!(
260            "repos/{repo}/issues/{number}/comments",
261            repo = self.repo,
262            number = number
263        );
264
265        let body_field = format!("body={body}");
266        let output = self
267            .runner
268            .run("gh", &["api", &api_path, "-X", "POST", "-f", &body_field])
269            .await
270            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh api: {e}")))?;
271
272        if !output.status.success() {
273            return Err(parse_gh_error(&output.stderr).into());
274        }
275
276        let comment: crate::issue::GitHubCommentApiResponse =
277            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
278
279        Ok(comment.into())
280    }
281
282    /// 合并指定编号的 PR。
283    ///
284    /// 调用 `gh pr merge <number> --repo <repo>` 并根据 `strategy` 参数
285    /// 添加 `--squash`、`--rebase` 或 `--merge` 标志。
286    /// 未指定策略时使用 `--merge`(标准合并)。
287    ///
288    /// # Errors
289    ///
290    /// 当 PR 不存在、存在冲突无法合并或 `gh` CLI 调用失败时返回错误。
291    async fn merge(&self, number: u64, strategy: Option<MergeStrategy>) -> Result<MergeResult> {
292        debug!(repo = %self.repo, number, ?strategy, "spawning `gh pr merge`");
293
294        let number_str = number.to_string();
295        let mut cmd_args: Vec<&str> = vec!["pr", "merge", &number_str, "--repo", &self.repo];
296
297        match strategy {
298            Some(MergeStrategy::Squash) => cmd_args.push("--squash"),
299            Some(MergeStrategy::Rebase) => cmd_args.push("--rebase"),
300            Some(MergeStrategy::Merge) | None => cmd_args.push("--merge"),
301        }
302
303        let output = self
304            .runner
305            .run("gh", &cmd_args)
306            .await
307            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
308
309        if !output.status.success() {
310            return Err(parse_gh_error(&output.stderr).into());
311        }
312
313        // `gh pr merge` outputs a human-readable message, not JSON.
314        let message = String::from_utf8_lossy(&output.stdout).trim().to_string();
315        Ok(MergeResult {
316            merged: true,
317            sha: None,
318            message: Some(message),
319        })
320    }
321
322    /// 在本地检出指定 PR 的分支。
323    ///
324    /// 调用 `gh pr checkout <number> --repo <repo>` 在本地工作区创建并切换到
325    /// PR 的来源分支。如果本地已存在该分支,则尝试更新它。
326    ///
327    /// # Errors
328    ///
329    /// 当 PR 不存在、本地 git 操作失败或 `gh` CLI 调用失败时返回错误。
330    async fn checkout(&self, number: u64) -> Result<()> {
331        debug!(repo = %self.repo, number, "spawning `gh pr checkout`");
332
333        let number_str = number.to_string();
334        let output = self
335            .runner
336            .run("gh", &["pr", "checkout", &number_str, "--repo", &self.repo])
337            .await
338            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
339
340        if !output.status.success() {
341            return Err(parse_gh_error(&output.stderr).into());
342        }
343
344        Ok(())
345    }
346
347    /// 将草稿 PR 标记为可审查状态(ready for review)。
348    ///
349    /// 调用 `gh pr ready <number> --repo <repo>` 将草稿 PR 转为可审查状态,
350    /// 并通过 `gh pr view` 重新获取更新后的 PR 数据。
351    ///
352    /// # Errors
353    ///
354    /// 当 PR 不存在、不是草稿状态或 `gh` CLI 调用失败时返回错误。
355    async fn mark_ready(&self, number: u64) -> Result<PrData> {
356        debug!(repo = %self.repo, number, "spawning `gh pr ready`");
357
358        let number_str = number.to_string();
359        let output = self
360            .runner
361            .run("gh", &["pr", "ready", &number_str, "--repo", &self.repo])
362            .await
363            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
364
365        if !output.status.success() {
366            return Err(parse_gh_error(&output.stderr).into());
367        }
368
369        // `gh pr ready` does not return JSON; re-fetch the PR to get updated data.
370        self.view(number).await
371    }
372
373    /// 将 PR 标记为草稿状态(work in progress)。
374    ///
375    /// 调用 `gh pr convert-to-draft <number> --repo <repo>` 将可审查的 PR 转为草稿,
376    /// 并通过 `gh pr view` 重新获取更新后的 PR 数据。
377    ///
378    /// # Errors
379    ///
380    /// 当 PR 不存在、已是草稿状态或 `gh` CLI 调用失败时返回错误。
381    async fn mark_wip(&self, number: u64) -> Result<PrData> {
382        debug!(repo = %self.repo, number, "spawning `gh pr convert-to-draft`");
383
384        let number_str = number.to_string();
385        let output = self
386            .runner
387            .run(
388                "gh",
389                &["pr", "convert-to-draft", &number_str, "--repo", &self.repo],
390            )
391            .await
392            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
393
394        if !output.status.success() {
395            return Err(parse_gh_error(&output.stderr).into());
396        }
397
398        // `gh pr convert-to-draft` does not return JSON; re-fetch the PR.
399        self.view(number).await
400    }
401
402    /// 同步 PR 的分支(将 base 分支的最新变更合入 head 分支)。
403    ///
404    /// 调用 `gh pr update-branch <number> --repo <repo>` 将 PR 的来源分支
405    /// 更新到与目标分支的最新状态同步,解决分支过时问题。
406    ///
407    /// # Errors
408    ///
409    /// 当 PR 不存在、同步存在冲突或 `gh` CLI 调用失败时返回错误。
410    async fn sync_branch(&self, number: u64) -> Result<()> {
411        debug!(repo = %self.repo, number, "spawning `gh pr update-branch`");
412
413        let number_str = number.to_string();
414        let output = self
415            .runner
416            .run(
417                "gh",
418                &["pr", "update-branch", &number_str, "--repo", &self.repo],
419            )
420            .await
421            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
422
423        if !output.status.success() {
424            return Err(parse_gh_error(&output.stderr).into());
425        }
426
427        Ok(())
428    }
429
430    /// 获取指定 PR 的统一差异格式(unified diff)文本。
431    ///
432    /// 调用 `gh pr diff <number> --repo <repo>` 获取平台原生的 unified diff
433    /// 输出,可直接用于 `git apply`。
434    ///
435    /// # Errors
436    ///
437    /// 当 PR 不存在或 `gh` CLI 调用失败时返回错误。
438    async fn diff(&self, number: u64) -> Result<String> {
439        debug!(repo = %self.repo, number, "spawning `gh pr diff`");
440
441        let number_str = number.to_string();
442        let output = self
443            .runner
444            .run("gh", &["pr", "diff", &number_str, "--repo", &self.repo])
445            .await
446            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh pr diff: {e}")))?;
447
448        if !output.status.success() {
449            return Err(parse_gh_error(&output.stderr).into());
450        }
451
452        Ok(String::from_utf8_lossy(&output.stdout).into_owned())
453    }
454
455    /// 获取指定 PR 的 patch 格式文本(含邮件头信息)。
456    ///
457    /// 调用 `gh api repos/{repo}/pulls/{number}` 并设置 `Accept` 头为
458    /// `application/vnd.github.v3.patch`,返回包含 commit 元数据的 patch 格式输出,
459    /// 可用于 `git am`。
460    ///
461    /// # Errors
462    ///
463    /// 当 PR 不存在或 `gh` CLI 调用失败时返回错误。
464    async fn patch(&self, number: u64) -> Result<String> {
465        debug!(repo = %self.repo, number, "spawning `gh api pr patch`");
466
467        let api_path = format!(
468            "repos/{repo}/pulls/{number}",
469            repo = self.repo,
470            number = number
471        );
472
473        let output = self
474            .runner
475            .run(
476                "gh",
477                &[
478                    "api",
479                    &api_path,
480                    "-H",
481                    "Accept: application/vnd.github.v3.patch",
482                ],
483            )
484            .await
485            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh api pr patch: {e}")))?;
486
487        if !output.status.success() {
488            return Err(parse_gh_error(&output.stderr).into());
489        }
490
491        Ok(String::from_utf8_lossy(&output.stdout).into_owned())
492    }
493}
494
495/// Parse PR number from GitHub URL.
496///
497/// Extracts the numeric PR number from URLs like:
498/// - `https://github.com/owner/repo/pull/123`
499/// - `https://github.enterprise.com/org/project/pull/456`
500fn parse_pr_number_from_url(url: &str) -> Option<u64> {
501    url.lines().find_map(|line| {
502        let line = line.trim();
503        if line.contains("/pull/") {
504            line.rsplit('/').next().and_then(|s| s.parse().ok())
505        } else {
506            None
507        }
508    })
509}
510
511#[cfg(test)]
512mod tests {
513    use super::*;
514    use crate::runner::MockCommandRunner;
515
516    #[test]
517    fn test_should_construct_github_pr_provider() {
518        let provider = GitHubPrProvider::new("octocat/hello-world");
519        assert_eq!(provider.repo, "octocat/hello-world");
520    }
521
522    #[test]
523    fn test_should_construct_github_pr_provider_from_string() {
524        let repo = String::from("octocat/hello-world");
525        let provider = GitHubPrProvider::new(repo);
526        assert_eq!(provider.repo, "octocat/hello-world");
527    }
528
529    #[test]
530    fn test_should_deserialize_pr_data_from_gh_output() {
531        // 模拟 `gh pr view --json ...` 的实际输出
532        let gh_json = br#"{
533            "number": 123,
534            "title": "Add new feature",
535            "body": "This PR adds a new feature",
536            "state": "open",
537            "draft": false,
538            "author": {"login": "alice", "id": "2"},
539            "baseBranch": "main",
540            "headBranch": "feature/new-thing",
541            "createdAt": "2026-02-20T14:00:00Z",
542            "updatedAt": "2026-02-21T10:30:00Z",
543            "url": "https://github.com/octocat/hello-world/pull/123"
544        }"#;
545
546        let pr: PrData = serde_json::from_slice(gh_json).expect("valid PrData JSON");
547        assert_eq!(pr.number, 123);
548        assert_eq!(pr.title, "Add new feature");
549        assert_eq!(pr.state, State::Open);
550        assert!(!pr.draft);
551        assert_eq!(pr.author.login, "alice");
552        assert_eq!(pr.base_branch, "main");
553        assert_eq!(pr.head_branch, "feature/new-thing");
554        assert_eq!(pr.url, "https://github.com/octocat/hello-world/pull/123");
555    }
556
557    #[test]
558    fn test_should_deserialize_empty_pr_list_from_gh_output() {
559        let gh_json = b"[]";
560        let prs: Vec<PrData> = serde_json::from_slice(gh_json).expect("valid PrData list");
561        assert!(prs.is_empty());
562    }
563
564    #[test]
565    fn test_should_deserialize_draft_pr_from_gh_output() {
566        let gh_json = br#"{
567            "number": 456,
568            "title": "WIP: experiment",
569            "body": null,
570            "state": "open",
571            "draft": true,
572            "author": {"login": "bob", "id": "3"},
573            "baseBranch": "main",
574            "headBranch": "wip/experiment",
575            "createdAt": "2026-03-10T09:00:00Z",
576            "updatedAt": "2026-03-10T09:00:00Z",
577            "url": "https://github.com/octocat/hello-world/pull/456"
578        }"#;
579
580        let pr: PrData = serde_json::from_slice(gh_json).expect("valid PrData JSON");
581        assert!(pr.draft);
582        assert!(pr.body.is_none());
583        assert_eq!(pr.title, "WIP: experiment");
584    }
585
586    #[test]
587    fn test_should_debug_format_provider() {
588        let provider = GitHubPrProvider::new("octocat/hello-world");
589        let debug = format!("{provider:?}");
590        assert!(debug.contains("GitHubPrProvider"));
591        assert!(debug.contains("octocat/hello-world"));
592    }
593
594    // --- close/reopen: deserialized PrData tests ---
595
596    #[test]
597    fn test_should_deserialize_closed_pr_from_gh_close_output() {
598        // 模拟 `gh pr close --json ...` 的返回数据
599        let gh_json = br#"{
600            "number": 50,
601            "title": "Obsolete change",
602            "body": "Superseded by #55",
603            "state": "closed",
604            "draft": false,
605            "author": {"login": "dev", "id": "10"},
606            "baseBranch": "main",
607            "headBranch": "feature/obsolete",
608            "createdAt": "2026-05-01T08:00:00Z",
609            "updatedAt": "2026-05-02T12:00:00Z",
610            "url": "https://github.com/octocat/hello-world/pull/50"
611        }"#;
612
613        let pr: PrData = serde_json::from_slice(gh_json).expect("valid closed PrData");
614        assert_eq!(pr.number, 50);
615        assert_eq!(pr.state, State::Closed);
616    }
617
618    #[test]
619    fn test_should_deserialize_reopened_pr_from_gh_reopen_output() {
620        let gh_json = br#"{
621            "number": 50,
622            "title": "Obsolete change",
623            "body": "Actually still needed",
624            "state": "open",
625            "draft": false,
626            "author": {"login": "dev", "id": "10"},
627            "baseBranch": "main",
628            "headBranch": "feature/obsolete",
629            "createdAt": "2026-05-01T08:00:00Z",
630            "updatedAt": "2026-05-03T09:00:00Z",
631            "url": "https://github.com/octocat/hello-world/pull/50"
632        }"#;
633
634        let pr: PrData = serde_json::from_slice(gh_json).expect("valid reopened PrData");
635        assert_eq!(pr.number, 50);
636        assert_eq!(pr.state, State::Open);
637    }
638
639    // --- comment: CommentData deserialization tests ---
640
641    #[test]
642    fn test_should_deserialize_comment_data_from_gh_pr_comment_output() {
643        // 模拟 `gh pr comment --json id,body,author,createdAt` 的输出
644        let gh_json = br#"{
645            "id": 2002,
646            "body": "Approved, merging now.",
647            "author": {"login": "reviewer", "id": "88"},
648            "createdAt": "2026-06-20T16:00:00Z"
649        }"#;
650
651        let comment: CommentData = serde_json::from_slice(gh_json).expect("valid CommentData");
652        assert_eq!(comment.id, 2002);
653        assert_eq!(comment.body, "Approved, merging now.");
654        assert_eq!(comment.author.login, "reviewer");
655        assert_eq!(comment.author.id, "88");
656    }
657
658    #[tokio::test]
659    async fn test_should_return_newly_created_pr_comment_not_stale() {
660        use crate::runner::MockCommandRunner;
661
662        // Mock `gh api POST` response — the comment just created
663        let post_response_json = r#"{
664            "id": 8888888888,
665            "body": "NEW PR comment",
666            "user": {"login": "reviewer", "id": 99},
667            "created_at": "2026-08-04T13:00:00Z"
668        }"#;
669
670        let runner = MockCommandRunner::success(post_response_json);
671        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
672
673        let result = provider.comment(7, "NEW PR comment").await.unwrap();
674
675        // The returned id must be the NEW comment's id, not a stale one
676        assert_eq!(result.id, 8_888_888_888);
677        assert_eq!(result.body, "NEW PR comment");
678        assert_eq!(result.author.login, "reviewer");
679    }
680
681    #[tokio::test]
682    async fn test_should_return_error_when_pr_comment_api_fails() {
683        use crate::runner::MockCommandRunner;
684
685        let runner = MockCommandRunner::failure(
686            r#"{"message": "Not Found", "documentation_url": "https://docs.github.com"}"#,
687            1,
688        );
689        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
690
691        let result = provider.comment(999, "test").await;
692
693        assert!(result.is_err());
694        let err = result.unwrap_err();
695        // `parse_gh_error` returns `PlatformCliError`, which converts to
696        // `CoreError::Cli` (matching the existing comment error-path test).
697        assert!(
698            matches!(err, CoreError::Cli(_)),
699            "expected Cli error, got: {err:?}"
700        );
701    }
702
703    // --- merge: MergeResult deserialization tests ---
704
705    #[test]
706    fn test_should_deserialize_merge_result_from_gh_merge_output() {
707        // `gh pr merge` 返回人类可读文本,不是 JSON。
708        // MergeResult 由代码构造,但需确保序列化/反序列化正确。
709        let gh_text = b"Pull request #123 was successfully merged.\n";
710        let message = String::from_utf8_lossy(gh_text).trim().to_string();
711        let result = MergeResult {
712            merged: true,
713            sha: None,
714            message: Some(message),
715        };
716
717        assert!(result.merged);
718        assert!(result.message.as_deref().is_some());
719        assert_eq!(
720            result.message.as_deref(),
721            Some("Pull request #123 was successfully merged.")
722        );
723    }
724
725    #[test]
726    fn test_should_roundtrip_merge_result_via_serde() {
727        let result = MergeResult {
728            merged: true,
729            sha: Some("deadbeef1234".into()),
730            message: Some("Squash merged".into()),
731        };
732        let json = serde_json::to_string(&result).expect("serialize");
733        let round_tripped: MergeResult = serde_json::from_str(&json).expect("deserialize");
734        assert!(round_tripped.merged);
735        assert_eq!(round_tripped.sha, result.sha);
736        assert_eq!(round_tripped.message, result.message);
737    }
738
739    #[test]
740    fn test_should_serialize_merge_result_skips_null_fields() {
741        let result = MergeResult {
742            merged: false,
743            sha: None,
744            message: None,
745        };
746        let json = serde_json::to_string(&result).expect("serialize");
747        assert!(!json.contains("null"));
748        assert_eq!(json, r#"{"merged":false}"#);
749    }
750
751    // --- provider construction / clone tests ---
752
753    #[test]
754    fn test_should_create_provider_with_different_repos() {
755        let r1 = GitHubPrProvider::new("org/repo-a");
756        let r2 = GitHubPrProvider::new("org/repo-b");
757        assert_eq!(r1.repo, "org/repo-a");
758        assert_eq!(r2.repo, "org/repo-b");
759    }
760
761    #[test]
762    fn test_should_clone_github_pr_provider() {
763        let original = GitHubPrProvider::new("owner/repo");
764        let cloned = original.clone();
765        assert_eq!(original.repo, cloned.repo);
766    }
767
768    #[test]
769    fn test_should_parse_pr_number_from_url() {
770        assert_eq!(
771            parse_pr_number_from_url("https://github.com/owner/repo/pull/123"),
772            Some(123)
773        );
774        assert_eq!(
775            parse_pr_number_from_url("https://github.enterprise.com/org/project/pull/456"),
776            Some(456)
777        );
778    }
779
780    #[test]
781    fn test_should_parse_pr_number_from_multiline_output() {
782        let output = "some header\nhttps://github.com/owner/repo/pull/789\nsome footer";
783        assert_eq!(parse_pr_number_from_url(output), Some(789));
784    }
785
786    #[test]
787    fn test_should_return_none_when_no_pr_url() {
788        assert_eq!(parse_pr_number_from_url("no pull url here"), None);
789        assert_eq!(parse_pr_number_from_url(""), None);
790        assert_eq!(
791            parse_pr_number_from_url("https://github.com/owner/repo/issues/123"),
792            None
793        );
794    }
795
796    // --- Failure-path tests using an injected MockCommandRunner ---
797
798    fn sample_create_args() -> CreatePrArgs {
799        CreatePrArgs {
800            title: "Add feature".to_string(),
801            body: Some("Detailed description".to_string()),
802            head: "feature/new".to_string(),
803            base: "main".to_string(),
804            draft: false,
805            repo: None,
806        }
807    }
808
809    #[tokio::test]
810    async fn test_should_return_platform_error_when_gh_fails_for_create() {
811        let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
812        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
813
814        let result = provider.create(sample_create_args()).await;
815
816        assert!(result.is_err());
817        assert!(matches!(
818            result.unwrap_err(),
819            gitflow_core::CoreError::Cli(_)
820        ));
821    }
822
823    #[tokio::test]
824    async fn test_should_return_platform_error_on_url_parse_failure_for_create() {
825        // `create` succeeds but stdout has no parseable PR URL, so URL parsing fails.
826        let runner = MockCommandRunner::success("no pull url here");
827        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
828
829        let result = provider.create(sample_create_args()).await;
830
831        assert!(result.is_err());
832        assert!(matches!(
833            result.unwrap_err(),
834            gitflow_core::CoreError::Platform(_)
835        ));
836    }
837
838    #[tokio::test]
839    async fn test_should_return_platform_error_when_gh_fails_for_list() {
840        let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
841        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
842
843        let result = provider.list(ListPrArgs::default()).await;
844
845        assert!(result.is_err());
846        assert!(matches!(
847            result.unwrap_err(),
848            gitflow_core::CoreError::Cli(_)
849        ));
850    }
851
852    #[tokio::test]
853    async fn test_should_return_serialization_error_on_invalid_json_for_list() {
854        let runner = MockCommandRunner::success("invalid json");
855        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
856
857        let result = provider.list(ListPrArgs::default()).await;
858
859        assert!(result.is_err());
860        assert!(matches!(
861            result.unwrap_err(),
862            gitflow_core::CoreError::Serialization(_)
863        ));
864    }
865
866    #[tokio::test]
867    async fn test_should_return_platform_error_when_gh_fails_for_view() {
868        let runner = MockCommandRunner::failure(r#"{"message": "PR not found"}"#, 256);
869        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
870
871        let result = provider.view(999).await;
872
873        assert!(result.is_err());
874        assert!(matches!(
875            result.unwrap_err(),
876            gitflow_core::CoreError::Cli(_)
877        ));
878    }
879
880    #[tokio::test]
881    async fn test_should_return_serialization_error_on_invalid_json_for_view() {
882        let runner = MockCommandRunner::success("invalid json");
883        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
884
885        let result = provider.view(1).await;
886
887        assert!(result.is_err());
888        assert!(matches!(
889            result.unwrap_err(),
890            gitflow_core::CoreError::Serialization(_)
891        ));
892    }
893
894    #[tokio::test]
895    async fn test_should_return_platform_error_when_gh_fails_for_close() {
896        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
897        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
898
899        let result = provider.close(42).await;
900
901        assert!(result.is_err());
902        assert!(matches!(
903            result.unwrap_err(),
904            gitflow_core::CoreError::Cli(_)
905        ));
906    }
907
908    #[tokio::test]
909    async fn test_should_return_platform_error_when_gh_fails_for_reopen() {
910        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
911        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
912
913        let result = provider.reopen(42).await;
914
915        assert!(result.is_err());
916        assert!(matches!(
917            result.unwrap_err(),
918            gitflow_core::CoreError::Cli(_)
919        ));
920    }
921
922    #[tokio::test]
923    async fn test_should_return_platform_error_when_gh_fails_for_merge() {
924        let runner = MockCommandRunner::failure(r#"{"message": "Merge conflict"}"#, 256);
925        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
926
927        let result = provider.merge(42, None).await;
928
929        assert!(result.is_err());
930        assert!(matches!(
931            result.unwrap_err(),
932            gitflow_core::CoreError::Cli(_)
933        ));
934    }
935
936    #[tokio::test]
937    async fn test_should_return_platform_error_on_invalid_json_for_merge() {
938        // `gh pr merge` returns human-readable text, so any successful output is a
939        // valid message. A failing exit status is the merge failure path instead.
940        let runner = MockCommandRunner::failure("invalid json", 256);
941        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
942
943        let result = provider.merge(42, Some(MergeStrategy::Squash)).await;
944
945        assert!(result.is_err());
946        assert!(matches!(
947            result.unwrap_err(),
948            gitflow_core::CoreError::Cli(_)
949        ));
950    }
951
952    #[tokio::test]
953    async fn test_should_return_platform_error_when_gh_fails_for_checkout() {
954        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
955        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
956
957        let result = provider.checkout(42).await;
958
959        assert!(result.is_err());
960        assert!(matches!(
961            result.unwrap_err(),
962            gitflow_core::CoreError::Cli(_)
963        ));
964    }
965
966    #[tokio::test]
967    async fn test_should_return_platform_error_when_gh_fails_for_sync_branch() {
968        let runner = MockCommandRunner::failure(r#"{"message": "Conflict"}"#, 256);
969        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
970
971        let result = provider.sync_branch(42).await;
972
973        assert!(result.is_err());
974        assert!(matches!(
975            result.unwrap_err(),
976            gitflow_core::CoreError::Cli(_)
977        ));
978    }
979
980    #[tokio::test]
981    async fn test_should_return_platform_error_when_gh_fails_for_mark_ready() {
982        let runner = MockCommandRunner::failure(r#"{"message": "Not a draft"}"#, 256);
983        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
984
985        let result = provider.mark_ready(42).await;
986
987        assert!(result.is_err());
988        assert!(matches!(
989            result.unwrap_err(),
990            gitflow_core::CoreError::Cli(_)
991        ));
992    }
993
994    #[tokio::test]
995    async fn test_should_return_platform_error_when_gh_fails_for_mark_wip() {
996        let runner = MockCommandRunner::failure(r#"{"message": "Already a draft"}"#, 256);
997        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
998
999        let result = provider.mark_wip(42).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_when_gh_fails_for_comment() {
1010        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1011        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1012
1013        let result = provider.comment(42, "a comment").await;
1014
1015        assert!(result.is_err());
1016        assert!(matches!(
1017            result.unwrap_err(),
1018            gitflow_core::CoreError::Cli(_)
1019        ));
1020    }
1021
1022    // --- diff() tests ---
1023
1024    #[tokio::test]
1025    async fn test_should_fetch_pr_diff() {
1026        let diff_output = "diff --git a/file.txt b/file.txt\nindex 1234567..abcdefg 100644\n--- \
1027                           a/file.txt\n+++ b/file.txt\n@@ -1 +1 @@\n-old\n+new\n";
1028        let runner = MockCommandRunner::success(diff_output);
1029        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1030
1031        let result = provider.diff(42).await.expect("diff should succeed");
1032        assert_eq!(result, diff_output);
1033    }
1034
1035    #[tokio::test]
1036    async fn test_should_return_error_when_pr_diff_fails() {
1037        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1038        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1039
1040        let result = provider.diff(999).await;
1041        assert!(result.is_err());
1042        assert!(matches!(
1043            result.unwrap_err(),
1044            gitflow_core::CoreError::Cli(_)
1045        ));
1046    }
1047
1048    // --- patch() tests ---
1049
1050    #[tokio::test]
1051    async fn test_should_fetch_pr_patch() {
1052        let patch_output =
1053            "From abc123\nSubject: [PATCH] Update file\n\ndiff --git a/file.txt b/file.txt\n";
1054        let runner = MockCommandRunner::success(patch_output);
1055        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1056
1057        let result = provider.patch(42).await.expect("patch should succeed");
1058        assert_eq!(result, patch_output);
1059    }
1060
1061    #[tokio::test]
1062    async fn test_should_return_error_when_pr_patch_fails() {
1063        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1064        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
1065
1066        let result = provider.patch(999).await;
1067        assert!(result.is_err());
1068        assert!(matches!(
1069            result.unwrap_err(),
1070            gitflow_core::CoreError::Cli(_)
1071        ));
1072    }
1073}