1use 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
20const PR_FIELDS: &str =
22 "number,title,body,state,isDraft,author,baseRefName,headRefName,createdAt,updatedAt,url";
23
24#[derive(Debug, Clone)]
40pub struct GitHubPrProvider<R: CommandRunner = RealCommandRunner> {
41 repo: String,
43 runner: R,
45}
46
47impl GitHubPrProvider<RealCommandRunner> {
48 #[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 #[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 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 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 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 self.view(number).await
219 }
220
221 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 self.view(number).await
245 }
246
247 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 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 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 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 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 self.view(number).await
371 }
372
373 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 self.view(number).await
400 }
401
402 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 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 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
495fn 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 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 #[test]
597 fn test_should_deserialize_closed_pr_from_gh_close_output() {
598 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 #[test]
642 fn test_should_deserialize_comment_data_from_gh_pr_comment_output() {
643 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 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 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 assert!(
698 matches!(err, CoreError::Cli(_)),
699 "expected Cli error, got: {err:?}"
700 );
701 }
702
703 #[test]
706 fn test_should_deserialize_merge_result_from_gh_merge_output() {
707 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 #[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 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 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 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 #[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 #[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}