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
431fn 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 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 #[test]
533 fn test_should_deserialize_closed_pr_from_gh_close_output() {
534 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 #[test]
578 fn test_should_deserialize_comment_data_from_gh_pr_comment_output() {
579 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 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 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 assert!(
634 matches!(err, CoreError::Cli(_)),
635 "expected Cli error, got: {err:?}"
636 );
637 }
638
639 #[test]
642 fn test_should_deserialize_merge_result_from_gh_merge_output() {
643 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 #[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 fn sample_create_args() -> CreatePrArgs {
707 CreatePrArgs {
708 title: "Add feature".to_string(),
709 body: Some("Detailed description".to_string()),
710 head: "feature/new".to_string(),
711 base: "main".to_string(),
712 draft: false,
713 repo: None,
714 }
715 }
716
717 #[tokio::test]
718 async fn test_should_return_platform_error_when_gh_fails_for_create() {
719 let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
720 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
721
722 let result = provider.create(sample_create_args()).await;
723
724 assert!(result.is_err());
725 assert!(matches!(
726 result.unwrap_err(),
727 gitflow_core::CoreError::Cli(_)
728 ));
729 }
730
731 #[tokio::test]
732 async fn test_should_return_platform_error_on_url_parse_failure_for_create() {
733 let runner = MockCommandRunner::success("no pull url here");
735 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
736
737 let result = provider.create(sample_create_args()).await;
738
739 assert!(result.is_err());
740 assert!(matches!(
741 result.unwrap_err(),
742 gitflow_core::CoreError::Platform(_)
743 ));
744 }
745
746 #[tokio::test]
747 async fn test_should_return_platform_error_when_gh_fails_for_list() {
748 let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
749 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
750
751 let result = provider.list(ListPrArgs::default()).await;
752
753 assert!(result.is_err());
754 assert!(matches!(
755 result.unwrap_err(),
756 gitflow_core::CoreError::Cli(_)
757 ));
758 }
759
760 #[tokio::test]
761 async fn test_should_return_serialization_error_on_invalid_json_for_list() {
762 let runner = MockCommandRunner::success("invalid json");
763 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
764
765 let result = provider.list(ListPrArgs::default()).await;
766
767 assert!(result.is_err());
768 assert!(matches!(
769 result.unwrap_err(),
770 gitflow_core::CoreError::Serialization(_)
771 ));
772 }
773
774 #[tokio::test]
775 async fn test_should_return_platform_error_when_gh_fails_for_view() {
776 let runner = MockCommandRunner::failure(r#"{"message": "PR not found"}"#, 256);
777 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
778
779 let result = provider.view(999).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_view() {
790 let runner = MockCommandRunner::success("invalid json");
791 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
792
793 let result = provider.view(1).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_close() {
804 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
805 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
806
807 let result = provider.close(42).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_platform_error_when_gh_fails_for_reopen() {
818 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
819 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
820
821 let result = provider.reopen(42).await;
822
823 assert!(result.is_err());
824 assert!(matches!(
825 result.unwrap_err(),
826 gitflow_core::CoreError::Cli(_)
827 ));
828 }
829
830 #[tokio::test]
831 async fn test_should_return_platform_error_when_gh_fails_for_merge() {
832 let runner = MockCommandRunner::failure(r#"{"message": "Merge conflict"}"#, 256);
833 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
834
835 let result = provider.merge(42, None).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_on_invalid_json_for_merge() {
846 let runner = MockCommandRunner::failure("invalid json", 256);
849 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
850
851 let result = provider.merge(42, Some(MergeStrategy::Squash)).await;
852
853 assert!(result.is_err());
854 assert!(matches!(
855 result.unwrap_err(),
856 gitflow_core::CoreError::Cli(_)
857 ));
858 }
859
860 #[tokio::test]
861 async fn test_should_return_platform_error_when_gh_fails_for_checkout() {
862 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
863 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
864
865 let result = provider.checkout(42).await;
866
867 assert!(result.is_err());
868 assert!(matches!(
869 result.unwrap_err(),
870 gitflow_core::CoreError::Cli(_)
871 ));
872 }
873
874 #[tokio::test]
875 async fn test_should_return_platform_error_when_gh_fails_for_sync_branch() {
876 let runner = MockCommandRunner::failure(r#"{"message": "Conflict"}"#, 256);
877 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
878
879 let result = provider.sync_branch(42).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_mark_ready() {
890 let runner = MockCommandRunner::failure(r#"{"message": "Not a draft"}"#, 256);
891 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
892
893 let result = provider.mark_ready(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_mark_wip() {
904 let runner = MockCommandRunner::failure(r#"{"message": "Already a draft"}"#, 256);
905 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
906
907 let result = provider.mark_wip(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_comment() {
918 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
919 let provider = GitHubPrProvider::with_runner("owner/repo", runner);
920
921 let result = provider.comment(42, "a comment").await;
922
923 assert!(result.is_err());
924 assert!(matches!(
925 result.unwrap_err(),
926 gitflow_core::CoreError::Cli(_)
927 ));
928 }
929}