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
431/// Parse PR number from GitHub URL.
432///
433/// Extracts the numeric PR number from URLs like:
434/// - `https://github.com/owner/repo/pull/123`
435/// - `https://github.enterprise.com/org/project/pull/456`
436fn parse_pr_number_from_url(url: &str) -> Option<u64> {
437    url.lines().find_map(|line| {
438        let line = line.trim();
439        if line.contains("/pull/") {
440            line.rsplit('/').next().and_then(|s| s.parse().ok())
441        } else {
442            None
443        }
444    })
445}
446
447#[cfg(test)]
448mod tests {
449    use super::*;
450    use crate::runner::MockCommandRunner;
451
452    #[test]
453    fn test_should_construct_github_pr_provider() {
454        let provider = GitHubPrProvider::new("octocat/hello-world");
455        assert_eq!(provider.repo, "octocat/hello-world");
456    }
457
458    #[test]
459    fn test_should_construct_github_pr_provider_from_string() {
460        let repo = String::from("octocat/hello-world");
461        let provider = GitHubPrProvider::new(repo);
462        assert_eq!(provider.repo, "octocat/hello-world");
463    }
464
465    #[test]
466    fn test_should_deserialize_pr_data_from_gh_output() {
467        // 模拟 `gh pr view --json ...` 的实际输出
468        let gh_json = br#"{
469            "number": 123,
470            "title": "Add new feature",
471            "body": "This PR adds a new feature",
472            "state": "open",
473            "draft": false,
474            "author": {"login": "alice", "id": "2"},
475            "baseBranch": "main",
476            "headBranch": "feature/new-thing",
477            "createdAt": "2026-02-20T14:00:00Z",
478            "updatedAt": "2026-02-21T10:30:00Z",
479            "url": "https://github.com/octocat/hello-world/pull/123"
480        }"#;
481
482        let pr: PrData = serde_json::from_slice(gh_json).expect("valid PrData JSON");
483        assert_eq!(pr.number, 123);
484        assert_eq!(pr.title, "Add new feature");
485        assert_eq!(pr.state, State::Open);
486        assert!(!pr.draft);
487        assert_eq!(pr.author.login, "alice");
488        assert_eq!(pr.base_branch, "main");
489        assert_eq!(pr.head_branch, "feature/new-thing");
490        assert_eq!(pr.url, "https://github.com/octocat/hello-world/pull/123");
491    }
492
493    #[test]
494    fn test_should_deserialize_empty_pr_list_from_gh_output() {
495        let gh_json = b"[]";
496        let prs: Vec<PrData> = serde_json::from_slice(gh_json).expect("valid PrData list");
497        assert!(prs.is_empty());
498    }
499
500    #[test]
501    fn test_should_deserialize_draft_pr_from_gh_output() {
502        let gh_json = br#"{
503            "number": 456,
504            "title": "WIP: experiment",
505            "body": null,
506            "state": "open",
507            "draft": true,
508            "author": {"login": "bob", "id": "3"},
509            "baseBranch": "main",
510            "headBranch": "wip/experiment",
511            "createdAt": "2026-03-10T09:00:00Z",
512            "updatedAt": "2026-03-10T09:00:00Z",
513            "url": "https://github.com/octocat/hello-world/pull/456"
514        }"#;
515
516        let pr: PrData = serde_json::from_slice(gh_json).expect("valid PrData JSON");
517        assert!(pr.draft);
518        assert!(pr.body.is_none());
519        assert_eq!(pr.title, "WIP: experiment");
520    }
521
522    #[test]
523    fn test_should_debug_format_provider() {
524        let provider = GitHubPrProvider::new("octocat/hello-world");
525        let debug = format!("{provider:?}");
526        assert!(debug.contains("GitHubPrProvider"));
527        assert!(debug.contains("octocat/hello-world"));
528    }
529
530    // --- close/reopen: deserialized PrData tests ---
531
532    #[test]
533    fn test_should_deserialize_closed_pr_from_gh_close_output() {
534        // 模拟 `gh pr close --json ...` 的返回数据
535        let gh_json = br#"{
536            "number": 50,
537            "title": "Obsolete change",
538            "body": "Superseded by #55",
539            "state": "closed",
540            "draft": false,
541            "author": {"login": "dev", "id": "10"},
542            "baseBranch": "main",
543            "headBranch": "feature/obsolete",
544            "createdAt": "2026-05-01T08:00:00Z",
545            "updatedAt": "2026-05-02T12:00:00Z",
546            "url": "https://github.com/octocat/hello-world/pull/50"
547        }"#;
548
549        let pr: PrData = serde_json::from_slice(gh_json).expect("valid closed PrData");
550        assert_eq!(pr.number, 50);
551        assert_eq!(pr.state, State::Closed);
552    }
553
554    #[test]
555    fn test_should_deserialize_reopened_pr_from_gh_reopen_output() {
556        let gh_json = br#"{
557            "number": 50,
558            "title": "Obsolete change",
559            "body": "Actually still needed",
560            "state": "open",
561            "draft": false,
562            "author": {"login": "dev", "id": "10"},
563            "baseBranch": "main",
564            "headBranch": "feature/obsolete",
565            "createdAt": "2026-05-01T08:00:00Z",
566            "updatedAt": "2026-05-03T09:00:00Z",
567            "url": "https://github.com/octocat/hello-world/pull/50"
568        }"#;
569
570        let pr: PrData = serde_json::from_slice(gh_json).expect("valid reopened PrData");
571        assert_eq!(pr.number, 50);
572        assert_eq!(pr.state, State::Open);
573    }
574
575    // --- comment: CommentData deserialization tests ---
576
577    #[test]
578    fn test_should_deserialize_comment_data_from_gh_pr_comment_output() {
579        // 模拟 `gh pr comment --json id,body,author,createdAt` 的输出
580        let gh_json = br#"{
581            "id": 2002,
582            "body": "Approved, merging now.",
583            "author": {"login": "reviewer", "id": "88"},
584            "createdAt": "2026-06-20T16:00:00Z"
585        }"#;
586
587        let comment: CommentData = serde_json::from_slice(gh_json).expect("valid CommentData");
588        assert_eq!(comment.id, 2002);
589        assert_eq!(comment.body, "Approved, merging now.");
590        assert_eq!(comment.author.login, "reviewer");
591        assert_eq!(comment.author.id, "88");
592    }
593
594    #[tokio::test]
595    async fn test_should_return_newly_created_pr_comment_not_stale() {
596        use crate::runner::MockCommandRunner;
597
598        // Mock `gh api POST` response — the comment just created
599        let post_response_json = r#"{
600            "id": 8888888888,
601            "body": "NEW PR comment",
602            "user": {"login": "reviewer", "id": 99},
603            "created_at": "2026-08-04T13:00:00Z"
604        }"#;
605
606        let runner = MockCommandRunner::success(post_response_json);
607        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
608
609        let result = provider.comment(7, "NEW PR comment").await.unwrap();
610
611        // The returned id must be the NEW comment's id, not a stale one
612        assert_eq!(result.id, 8_888_888_888);
613        assert_eq!(result.body, "NEW PR comment");
614        assert_eq!(result.author.login, "reviewer");
615    }
616
617    #[tokio::test]
618    async fn test_should_return_error_when_pr_comment_api_fails() {
619        use crate::runner::MockCommandRunner;
620
621        let runner = MockCommandRunner::failure(
622            r#"{"message": "Not Found", "documentation_url": "https://docs.github.com"}"#,
623            1,
624        );
625        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
626
627        let result = provider.comment(999, "test").await;
628
629        assert!(result.is_err());
630        let err = result.unwrap_err();
631        // `parse_gh_error` returns `PlatformCliError`, which converts to
632        // `CoreError::Cli` (matching the existing comment error-path test).
633        assert!(
634            matches!(err, CoreError::Cli(_)),
635            "expected Cli error, got: {err:?}"
636        );
637    }
638
639    // --- merge: MergeResult deserialization tests ---
640
641    #[test]
642    fn test_should_deserialize_merge_result_from_gh_merge_output() {
643        // `gh pr merge` 返回人类可读文本,不是 JSON。
644        // MergeResult 由代码构造,但需确保序列化/反序列化正确。
645        let gh_text = b"Pull request #123 was successfully merged.\n";
646        let message = String::from_utf8_lossy(gh_text).trim().to_string();
647        let result = MergeResult {
648            merged: true,
649            sha: None,
650            message: Some(message),
651        };
652
653        assert!(result.merged);
654        assert!(result.message.as_deref().is_some());
655        assert_eq!(
656            result.message.as_deref(),
657            Some("Pull request #123 was successfully merged.")
658        );
659    }
660
661    #[test]
662    fn test_should_roundtrip_merge_result_via_serde() {
663        let result = MergeResult {
664            merged: true,
665            sha: Some("deadbeef1234".into()),
666            message: Some("Squash merged".into()),
667        };
668        let json = serde_json::to_string(&result).expect("serialize");
669        let round_tripped: MergeResult = serde_json::from_str(&json).expect("deserialize");
670        assert!(round_tripped.merged);
671        assert_eq!(round_tripped.sha, result.sha);
672        assert_eq!(round_tripped.message, result.message);
673    }
674
675    #[test]
676    fn test_should_serialize_merge_result_skips_null_fields() {
677        let result = MergeResult {
678            merged: false,
679            sha: None,
680            message: None,
681        };
682        let json = serde_json::to_string(&result).expect("serialize");
683        assert!(!json.contains("null"));
684        assert_eq!(json, r#"{"merged":false}"#);
685    }
686
687    // --- provider construction / clone tests ---
688
689    #[test]
690    fn test_should_create_provider_with_different_repos() {
691        let r1 = GitHubPrProvider::new("org/repo-a");
692        let r2 = GitHubPrProvider::new("org/repo-b");
693        assert_eq!(r1.repo, "org/repo-a");
694        assert_eq!(r2.repo, "org/repo-b");
695    }
696
697    #[test]
698    fn test_should_clone_github_pr_provider() {
699        let original = GitHubPrProvider::new("owner/repo");
700        let cloned = original.clone();
701        assert_eq!(original.repo, cloned.repo);
702    }
703
704    #[test]
705    fn test_should_parse_pr_number_from_url() {
706        assert_eq!(
707            parse_pr_number_from_url("https://github.com/owner/repo/pull/123"),
708            Some(123)
709        );
710        assert_eq!(
711            parse_pr_number_from_url("https://github.enterprise.com/org/project/pull/456"),
712            Some(456)
713        );
714    }
715
716    #[test]
717    fn test_should_parse_pr_number_from_multiline_output() {
718        let output = "some header\nhttps://github.com/owner/repo/pull/789\nsome footer";
719        assert_eq!(parse_pr_number_from_url(output), Some(789));
720    }
721
722    #[test]
723    fn test_should_return_none_when_no_pr_url() {
724        assert_eq!(parse_pr_number_from_url("no pull url here"), None);
725        assert_eq!(parse_pr_number_from_url(""), None);
726        assert_eq!(
727            parse_pr_number_from_url("https://github.com/owner/repo/issues/123"),
728            None
729        );
730    }
731
732    // --- Failure-path tests using an injected MockCommandRunner ---
733
734    fn sample_create_args() -> CreatePrArgs {
735        CreatePrArgs {
736            title: "Add feature".to_string(),
737            body: Some("Detailed description".to_string()),
738            head: "feature/new".to_string(),
739            base: "main".to_string(),
740            draft: false,
741            repo: None,
742        }
743    }
744
745    #[tokio::test]
746    async fn test_should_return_platform_error_when_gh_fails_for_create() {
747        let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
748        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
749
750        let result = provider.create(sample_create_args()).await;
751
752        assert!(result.is_err());
753        assert!(matches!(
754            result.unwrap_err(),
755            gitflow_core::CoreError::Cli(_)
756        ));
757    }
758
759    #[tokio::test]
760    async fn test_should_return_platform_error_on_url_parse_failure_for_create() {
761        // `create` succeeds but stdout has no parseable PR URL, so URL parsing fails.
762        let runner = MockCommandRunner::success("no pull url here");
763        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
764
765        let result = provider.create(sample_create_args()).await;
766
767        assert!(result.is_err());
768        assert!(matches!(
769            result.unwrap_err(),
770            gitflow_core::CoreError::Platform(_)
771        ));
772    }
773
774    #[tokio::test]
775    async fn test_should_return_platform_error_when_gh_fails_for_list() {
776        let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
777        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
778
779        let result = provider.list(ListPrArgs::default()).await;
780
781        assert!(result.is_err());
782        assert!(matches!(
783            result.unwrap_err(),
784            gitflow_core::CoreError::Cli(_)
785        ));
786    }
787
788    #[tokio::test]
789    async fn test_should_return_serialization_error_on_invalid_json_for_list() {
790        let runner = MockCommandRunner::success("invalid json");
791        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
792
793        let result = provider.list(ListPrArgs::default()).await;
794
795        assert!(result.is_err());
796        assert!(matches!(
797            result.unwrap_err(),
798            gitflow_core::CoreError::Serialization(_)
799        ));
800    }
801
802    #[tokio::test]
803    async fn test_should_return_platform_error_when_gh_fails_for_view() {
804        let runner = MockCommandRunner::failure(r#"{"message": "PR not found"}"#, 256);
805        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
806
807        let result = provider.view(999).await;
808
809        assert!(result.is_err());
810        assert!(matches!(
811            result.unwrap_err(),
812            gitflow_core::CoreError::Cli(_)
813        ));
814    }
815
816    #[tokio::test]
817    async fn test_should_return_serialization_error_on_invalid_json_for_view() {
818        let runner = MockCommandRunner::success("invalid json");
819        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
820
821        let result = provider.view(1).await;
822
823        assert!(result.is_err());
824        assert!(matches!(
825            result.unwrap_err(),
826            gitflow_core::CoreError::Serialization(_)
827        ));
828    }
829
830    #[tokio::test]
831    async fn test_should_return_platform_error_when_gh_fails_for_close() {
832        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
833        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
834
835        let result = provider.close(42).await;
836
837        assert!(result.is_err());
838        assert!(matches!(
839            result.unwrap_err(),
840            gitflow_core::CoreError::Cli(_)
841        ));
842    }
843
844    #[tokio::test]
845    async fn test_should_return_platform_error_when_gh_fails_for_reopen() {
846        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
847        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
848
849        let result = provider.reopen(42).await;
850
851        assert!(result.is_err());
852        assert!(matches!(
853            result.unwrap_err(),
854            gitflow_core::CoreError::Cli(_)
855        ));
856    }
857
858    #[tokio::test]
859    async fn test_should_return_platform_error_when_gh_fails_for_merge() {
860        let runner = MockCommandRunner::failure(r#"{"message": "Merge conflict"}"#, 256);
861        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
862
863        let result = provider.merge(42, None).await;
864
865        assert!(result.is_err());
866        assert!(matches!(
867            result.unwrap_err(),
868            gitflow_core::CoreError::Cli(_)
869        ));
870    }
871
872    #[tokio::test]
873    async fn test_should_return_platform_error_on_invalid_json_for_merge() {
874        // `gh pr merge` returns human-readable text, so any successful output is a
875        // valid message. A failing exit status is the merge failure path instead.
876        let runner = MockCommandRunner::failure("invalid json", 256);
877        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
878
879        let result = provider.merge(42, Some(MergeStrategy::Squash)).await;
880
881        assert!(result.is_err());
882        assert!(matches!(
883            result.unwrap_err(),
884            gitflow_core::CoreError::Cli(_)
885        ));
886    }
887
888    #[tokio::test]
889    async fn test_should_return_platform_error_when_gh_fails_for_checkout() {
890        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
891        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
892
893        let result = provider.checkout(42).await;
894
895        assert!(result.is_err());
896        assert!(matches!(
897            result.unwrap_err(),
898            gitflow_core::CoreError::Cli(_)
899        ));
900    }
901
902    #[tokio::test]
903    async fn test_should_return_platform_error_when_gh_fails_for_sync_branch() {
904        let runner = MockCommandRunner::failure(r#"{"message": "Conflict"}"#, 256);
905        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
906
907        let result = provider.sync_branch(42).await;
908
909        assert!(result.is_err());
910        assert!(matches!(
911            result.unwrap_err(),
912            gitflow_core::CoreError::Cli(_)
913        ));
914    }
915
916    #[tokio::test]
917    async fn test_should_return_platform_error_when_gh_fails_for_mark_ready() {
918        let runner = MockCommandRunner::failure(r#"{"message": "Not a draft"}"#, 256);
919        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
920
921        let result = provider.mark_ready(42).await;
922
923        assert!(result.is_err());
924        assert!(matches!(
925            result.unwrap_err(),
926            gitflow_core::CoreError::Cli(_)
927        ));
928    }
929
930    #[tokio::test]
931    async fn test_should_return_platform_error_when_gh_fails_for_mark_wip() {
932        let runner = MockCommandRunner::failure(r#"{"message": "Already a draft"}"#, 256);
933        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
934
935        let result = provider.mark_wip(42).await;
936
937        assert!(result.is_err());
938        assert!(matches!(
939            result.unwrap_err(),
940            gitflow_core::CoreError::Cli(_)
941        ));
942    }
943
944    #[tokio::test]
945    async fn test_should_return_platform_error_when_gh_fails_for_comment() {
946        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
947        let provider = GitHubPrProvider::with_runner("owner/repo", runner);
948
949        let result = provider.comment(42, "a comment").await;
950
951        assert!(result.is_err());
952        assert!(matches!(
953            result.unwrap_err(),
954            gitflow_core::CoreError::Cli(_)
955        ));
956    }
957}