1use 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
21const PR_FIELDS: &str = "number,title,body,state,isDraft,author,baseRefName,headRefName,createdAt,\
23 updatedAt,mergedAt,milestone,url";
24
25#[derive(Debug, Deserialize)]
27struct RepoViewResponse {
28 #[serde(rename = "defaultBranchRef")]
29 default_branch_ref: DefaultBranchRef,
30}
31
32#[derive(Debug, Deserialize)]
34struct DefaultBranchRef {
35 name: String,
36}
37
38#[derive(Debug, Clone)]
54pub struct GitHubPrProvider<R: CommandRunner = RealCommandRunner> {
55 repo: String,
57 runner: R,
59}
60
61impl GitHubPrProvider<RealCommandRunner> {
62 #[must_use]
66 pub fn new(repo: impl Into<String>) -> Self {
67 Self {
68 repo: repo.into(),
69 runner: RealCommandRunner,
70 }
71 }
72
73 #[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 #[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 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 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 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 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 self.view(number).await
271 }
272
273 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 self.view(number).await
297 }
298
299 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 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 let message = String::from_utf8_lossy(&output.stdout).trim().to_string();
378 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 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 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 self.view(number).await
441 }
442
443 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 self.view(number).await
470 }
471
472 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 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 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 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
601fn 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 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 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 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 #[test]
767 fn test_should_deserialize_closed_pr_from_gh_close_output() {
768 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 #[test]
812 fn test_should_deserialize_comment_data_from_gh_pr_comment_output() {
813 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 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 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 assert!(
868 matches!(err, CoreError::Cli(_)),
869 "expected Cli error, got: {err:?}"
870 );
871 }
872
873 #[test]
876 fn test_should_deserialize_merge_result_from_gh_merge_output() {
877 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 #[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 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 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 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 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 #[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 #[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 #[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 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 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}