1use async_trait::async_trait;
10use chrono::{DateTime, Utc};
11use gitflow_core::{
12 CoreError, Result,
13 pr::{CreatePrArgs, ListPrArgs, PrData, PrProvider},
14 types::{CommentData, MergeResult, MergeStrategy, State, UserSummary},
15};
16use serde::Deserialize;
17use tracing::debug;
18
19use crate::{
20 error::parse_gitcode_error,
21 runner::{CommandRunner, RealCommandRunner},
22};
23
24#[derive(Debug, Clone, Deserialize)]
30struct PrApiResponse {
31 number: u64,
32 title: String,
33 #[serde(default)]
34 body: Option<String>,
35 #[serde(default)]
36 state: Option<String>,
37 #[serde(default)]
38 draft: bool,
39 #[serde(default)]
40 user: Option<PrUserApi>,
41 #[serde(default)]
42 head: Option<PrBranchApi>,
43 #[serde(default)]
44 base: Option<PrBranchApi>,
45 #[serde(default)]
46 created_at: Option<String>,
47 #[serde(default)]
48 updated_at: Option<String>,
49 #[serde(default)]
50 html_url: Option<String>,
51}
52
53#[derive(Debug, Clone, Deserialize)]
55struct PrUserApi {
56 #[serde(default)]
57 login: String,
58 #[serde(default)]
59 id: Option<String>,
60}
61
62#[derive(Debug, Clone, Deserialize)]
64struct PrBranchApi {
65 #[serde(default, rename = "ref")]
66 branch_ref: String,
67}
68
69#[derive(Debug, Clone, Deserialize)]
73struct PrCommentApiResponse {
74 #[serde(deserialize_with = "gitflow_core::types::deserialize_u64_or_string")]
75 id: u64,
76 #[serde(default)]
77 body: String,
78 #[serde(default)]
79 author: Option<String>,
80 #[serde(default)]
81 user: Option<PrUserApi>,
82 #[serde(default)]
83 created_at: Option<String>,
84}
85
86impl From<PrCommentApiResponse> for CommentData {
87 fn from(api: PrCommentApiResponse) -> Self {
88 let author = api.user.map_or_else(
89 || UserSummary {
90 login: api.author.unwrap_or_else(|| "unknown".into()),
91 id: String::new(),
92 },
93 |u| UserSummary {
94 login: u.login,
95 id: u.id.unwrap_or_default(),
96 },
97 );
98 let created_at = api.created_at.as_deref().map_or_else(Utc::now, |s| {
99 DateTime::parse_from_rfc3339(s)
100 .map(|dt| dt.with_timezone(&Utc))
101 .or_else(|_| {
102 chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S")
103 .map(|ndt| ndt.and_utc())
104 })
105 .unwrap_or_else(|_| Utc::now())
106 });
107 Self {
108 id: api.id,
109 body: api.body,
110 author,
111 created_at,
112 }
113 }
114}
115
116impl From<PrApiResponse> for PrData {
117 fn from(api: PrApiResponse) -> Self {
118 let parse_time = |s: Option<String>| {
119 s.and_then(|v| DateTime::parse_from_rfc3339(&v).ok())
120 .map_or_else(Utc::now, |dt| dt.with_timezone(&Utc))
121 };
122 Self {
123 number: api.number,
124 title: api.title,
125 body: api.body,
126 state: match api.state.as_deref() {
127 Some("closed" | "merged") => State::Closed,
128 _ => State::Open,
129 },
130 draft: api.draft,
131 author: api.user.map_or(
132 UserSummary {
133 login: "unknown".into(),
134 id: String::new(),
135 },
136 |u| UserSummary {
137 login: u.login,
138 id: u.id.unwrap_or_default(),
139 },
140 ),
141 base_branch: api.base.map_or_else(String::new, |b| b.branch_ref),
142 head_branch: api.head.map_or_else(String::new, |h| h.branch_ref),
143 created_at: parse_time(api.created_at),
144 updated_at: parse_time(api.updated_at),
145 url: api.html_url.unwrap_or_default(),
146 }
147 }
148}
149
150#[derive(Debug, Clone)]
166pub struct GitCodePrProvider<R: CommandRunner = RealCommandRunner> {
167 repo: String,
169 runner: R,
171}
172
173impl GitCodePrProvider<RealCommandRunner> {
174 #[must_use]
178 pub fn new(repo: impl Into<String>) -> Self {
179 Self {
180 repo: repo.into(),
181 runner: RealCommandRunner,
182 }
183 }
184}
185
186impl<R: CommandRunner> GitCodePrProvider<R> {
187 #[must_use]
192 pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
193 Self {
194 repo: repo.into(),
195 runner,
196 }
197 }
198}
199
200#[async_trait]
201impl<R: CommandRunner + 'static> PrProvider for GitCodePrProvider<R> {
202 async fn create(&self, args: CreatePrArgs) -> Result<PrData> {
203 let binary = crate::gitcode_binary();
204 let mut cmd_args: Vec<&str> = vec![
205 "pr",
206 "create",
207 "--repo",
208 args.repo.as_deref().unwrap_or(&self.repo),
209 "--title",
210 &args.title,
211 "--head",
212 &args.head,
213 "--base",
214 &args.base,
215 "--json",
216 ];
217
218 if let Some(body) = &args.body {
219 cmd_args.push("--body");
220 cmd_args.push(body);
221 }
222
223 if args.draft {
224 cmd_args.push("--draft");
225 }
226
227 debug!(
228 repo = %self.repo,
229 title = %args.title,
230 head = %args.head,
231 base = %args.base,
232 "spawning `gitcode pr create`"
233 );
234
235 let output = self
236 .runner
237 .run(&binary, &cmd_args)
238 .await
239 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
240
241 if !output.status.success() {
242 return Err(parse_gitcode_error(&output.stderr).into());
243 }
244
245 let api: PrApiResponse =
246 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
247
248 Ok(api.into())
249 }
250
251 async fn list(&self, args: ListPrArgs) -> Result<Vec<PrData>> {
252 let binary = crate::gitcode_binary();
253 let mut cmd_args: Vec<&str> = vec!["pr", "list", "--repo", &self.repo, "--json"];
254
255 if let Some(state) = &args.state {
256 cmd_args.push("--state");
257 cmd_args.push(match state {
258 State::Open => "open",
259 State::Closed => "closed",
260 });
261 }
262
263 let limit_str = args.limit.map(|limit| limit.to_string());
264 if let Some(ref limit) = limit_str {
265 cmd_args.push("--limit");
266 cmd_args.push(limit);
267 }
268
269 debug!(repo = %self.repo, "spawning `gitcode pr list`");
270
271 let output = self
272 .runner
273 .run(&binary, &cmd_args)
274 .await
275 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
276
277 if !output.status.success() {
278 return Err(parse_gitcode_error(&output.stderr).into());
279 }
280
281 let apis: Vec<PrApiResponse> =
282 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
283
284 Ok(apis.into_iter().map(PrData::from).collect())
285 }
286
287 async fn view(&self, number: u64) -> Result<PrData> {
288 let binary = crate::gitcode_binary();
289 let number_str = number.to_string();
290 debug!(repo = %self.repo, number, "spawning `gitcode pr view`");
291
292 let output = self
293 .runner
294 .run(
295 &binary,
296 &["pr", "view", &number_str, "--repo", &self.repo, "--json"],
297 )
298 .await
299 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
300
301 if !output.status.success() {
302 return Err(parse_gitcode_error(&output.stderr).into());
303 }
304
305 let api: PrApiResponse =
306 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
307
308 Ok(api.into())
309 }
310
311 async fn close(&self, number: u64) -> Result<PrData> {
320 let binary = crate::gitcode_binary();
321 let number_str = number.to_string();
322 debug!(repo = %self.repo, number, "spawning `gitcode pr close`");
323
324 let output = self
325 .runner
326 .run(
327 &binary,
328 &[
329 "pr",
330 "close",
331 &number_str,
332 "--repo",
333 &self.repo,
334 "--yes",
335 "--json",
336 ],
337 )
338 .await
339 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
340
341 if !output.status.success() {
342 return Err(parse_gitcode_error(&output.stderr).into());
343 }
344
345 let api: PrApiResponse =
346 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
347
348 Ok(api.into())
349 }
350
351 async fn reopen(&self, number: u64) -> Result<PrData> {
360 let binary = crate::gitcode_binary();
361 let number_str = number.to_string();
362 debug!(repo = %self.repo, number, "spawning `gitcode pr reopen`");
363
364 let output = self
365 .runner
366 .run(
367 &binary,
368 &[
369 "pr",
370 "reopen",
371 &number_str,
372 "--repo",
373 &self.repo,
374 "--yes",
375 "--json",
376 ],
377 )
378 .await
379 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
380
381 if !output.status.success() {
382 return Err(parse_gitcode_error(&output.stderr).into());
383 }
384
385 let api: PrApiResponse =
386 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
387
388 Ok(api.into())
389 }
390
391 async fn comment(&self, number: u64, body: &str) -> Result<CommentData> {
400 let binary = crate::gitcode_binary();
401 let number_str = number.to_string();
402 debug!(repo = %self.repo, number, "spawning `gitcode pr comment`");
403
404 let output = self
405 .runner
406 .run(
407 &binary,
408 &[
409 "pr",
410 "comment",
411 &number_str,
412 "--repo",
413 &self.repo,
414 "--body",
415 body,
416 "--json",
417 ],
418 )
419 .await
420 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
421
422 if !output.status.success() {
423 return Err(parse_gitcode_error(&output.stderr).into());
424 }
425
426 let api: PrCommentApiResponse =
427 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
428
429 Ok(api.into())
430 }
431
432 async fn merge(&self, number: u64, strategy: Option<MergeStrategy>) -> Result<MergeResult> {
442 let binary = crate::gitcode_binary();
443 let number_str = number.to_string();
444 let mut cmd_args: Vec<&str> =
445 vec!["pr", "merge", &number_str, "--repo", &self.repo, "--yes"];
446
447 let strategy_value;
448 if let Some(strategy) = strategy {
449 strategy_value = match strategy {
450 MergeStrategy::Merge => "merge",
451 MergeStrategy::Squash => "squash",
452 MergeStrategy::Rebase => "rebase",
453 };
454 cmd_args.push("--method");
455 cmd_args.push(strategy_value);
456 }
457
458 debug!(repo = %self.repo, number, ?strategy, "spawning `gitcode pr merge`");
459
460 let output = self
461 .runner
462 .run(&binary, &cmd_args)
463 .await
464 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
465
466 if !output.status.success() {
467 return Err(parse_gitcode_error(&output.stderr).into());
468 }
469
470 let message = String::from_utf8_lossy(&output.stdout).trim().to_string();
472 Ok(MergeResult {
473 merged: true,
474 sha: None,
475 message: Some(message),
476 })
477 }
478
479 async fn checkout(&self, number: u64) -> Result<()> {
488 let binary = crate::gitcode_binary();
489 let number_str = number.to_string();
490 debug!(repo = %self.repo, number, "spawning `gc pr checkout`");
491
492 let output = self
493 .runner
494 .run(
495 &binary,
496 &["pr", "checkout", &number_str, "--repo", &self.repo],
497 )
498 .await
499 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
500
501 if !output.status.success() {
502 return Err(parse_gitcode_error(&output.stderr).into());
503 }
504
505 Ok(())
506 }
507
508 async fn mark_ready(&self, number: u64) -> Result<PrData> {
517 let binary = crate::gitcode_binary();
518 let number_str = number.to_string();
519 debug!(repo = %self.repo, number, "spawning `gc pr ready`");
520
521 let output = self
522 .runner
523 .run(&binary, &["pr", "ready", &number_str, "--repo", &self.repo])
524 .await
525 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
526
527 if !output.status.success() {
528 return Err(parse_gitcode_error(&output.stderr).into());
529 }
530
531 self.view(number).await
533 }
534
535 async fn mark_wip(&self, number: u64) -> Result<PrData> {
544 let binary = crate::gitcode_binary();
545 let number_str = number.to_string();
546 debug!(repo = %self.repo, number, "spawning `gc pr convert-to-draft`");
547
548 let output = self
549 .runner
550 .run(
551 &binary,
552 &["pr", "convert-to-draft", &number_str, "--repo", &self.repo],
553 )
554 .await
555 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
556
557 if !output.status.success() {
558 return Err(parse_gitcode_error(&output.stderr).into());
559 }
560
561 self.view(number).await
563 }
564
565 async fn sync_branch(&self, number: u64) -> Result<()> {
574 let binary = crate::gitcode_binary();
575 let number_str = number.to_string();
576 debug!(repo = %self.repo, number, "spawning `gc pr update-branch`");
577
578 let output = self
579 .runner
580 .run(
581 &binary,
582 &["pr", "update-branch", &number_str, "--repo", &self.repo],
583 )
584 .await
585 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
586
587 if !output.status.success() {
588 return Err(parse_gitcode_error(&output.stderr).into());
589 }
590
591 Ok(())
592 }
593
594 async fn diff(&self, number: u64) -> Result<String> {
603 let binary = crate::gitcode_binary();
604 let number_str = number.to_string();
605 debug!(repo = %self.repo, number, "spawning `gc mr diff`");
606
607 let output = self
608 .runner
609 .run(&binary, &["mr", "diff", &number_str, "-R", &self.repo])
610 .await
611 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode mr diff: {e}")))?;
612
613 if !output.status.success() {
614 return Err(parse_gitcode_error(&output.stderr).into());
615 }
616
617 Ok(String::from_utf8_lossy(&output.stdout).into_owned())
618 }
619
620 async fn patch(&self, number: u64) -> Result<String> {
629 let binary = crate::gitcode_binary();
630 let number_str = number.to_string();
631 debug!(repo = %self.repo, number, "spawning `gc mr patch`");
632
633 let output = self
634 .runner
635 .run(&binary, &["mr", "patch", &number_str, "-R", &self.repo])
636 .await
637 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode mr patch: {e}")))?;
638
639 if !output.status.success() {
640 return Err(parse_gitcode_error(&output.stderr).into());
641 }
642
643 Ok(String::from_utf8_lossy(&output.stdout).into_owned())
644 }
645}
646
647#[cfg(test)]
648mod tests {
649 use super::*;
650 use crate::runner::MockCommandRunner;
651
652 fn real_gitcode_pr_json() -> &'static str {
654 r###"{
655 "id": 8957463,
656 "number": 52,
657 "title": "test(badge): 引擎规则函数测试覆盖",
658 "body": "## Summary\n\nCloses #88",
659 "description": "## Summary\n\nCloses #88",
660 "state": "merged",
661 "html_url": "https://gitcode.com/byx-darwin/go-beniofit/merge_requests/52",
662 "diff_url": "",
663 "patch_url": "",
664 "draft": false,
665 "merged": true,
666 "merged_at": "2026-07-30T13:23:13+08:00",
667 "created_at": "2026-07-30T12:40:46+08:00",
668 "updated_at": "2026-07-30T13:23:13+08:00",
669 "user": {
670 "id": "66767cd4096c81780c61bf07",
671 "login": "byx-darwin",
672 "name": "baoyx",
673 "email": "",
674 "avatar_url": "https://cdn-img.gitcode.com/avatar.png",
675 "html_url": "https://gitcode.com/byx-darwin",
676 "created_at": ""
677 },
678 "head": {
679 "label": "test/88-engine-rule-coverage",
680 "ref": "test/88-engine-rule-coverage",
681 "sha": "8f1d3f31d7ee598a16f40fcac55b86154122c93c"
682 },
683 "base": {
684 "label": "master",
685 "ref": "master",
686 "sha": "bba7d724c8c73531acf1dca5f639b2a273c26eae"
687 },
688 "labels": [],
689 "assignees": [],
690 "additions": 120,
691 "deletions": 3,
692 "changed_files": 1,
693 "commits": 2,
694 "comments": 0,
695 "mergeable": true,
696 "mergeable_state": "can_be_merged",
697 "milestone": null,
698 "closed_at": "2026-07-30T13:23:13+08:00",
699 "requested_reviewers": []
700 }"###
701 }
702
703 #[test]
704 fn test_should_map_real_gitcode_pr_response_to_pr_data() {
705 let api: PrApiResponse =
706 serde_json::from_str(real_gitcode_pr_json()).expect(r"valid gitcode v0.6.1 PR JSON");
707 let pr: PrData = api.into();
708
709 assert_eq!(pr.number, 52);
710 assert_eq!(pr.title, r"test(badge): 引擎规则函数测试覆盖");
711 assert_eq!(pr.state, State::Closed, r"merged 必须映射为 Closed");
712 assert!(!pr.draft);
713 assert_eq!(pr.author.login, "byx-darwin");
714 assert_eq!(pr.author.id, "66767cd4096c81780c61bf07");
715 assert_eq!(pr.base_branch, "master");
716 assert_eq!(pr.head_branch, "test/88-engine-rule-coverage");
717 assert_eq!(
718 pr.url,
719 "https://gitcode.com/byx-darwin/go-beniofit/merge_requests/52"
720 );
721 assert_eq!(pr.created_at.to_rfc3339(), "2026-07-30T04:40:46+00:00");
722 }
723
724 #[test]
725 fn test_should_map_open_pr_with_minimal_gitcode_fields() {
726 let json = r#"{
727 "id": 1,
728 "number": 7,
729 "title": "New work",
730 "state": "open",
731 "html_url": "https://gitcode.com/o/r/merge_requests/7",
732 "draft": true,
733 "user": {"id": "u1", "login": "dev"},
734 "head": {"ref": "feature/x"},
735 "base": {"ref": "main"}
736 }"#;
737 let api: PrApiResponse = serde_json::from_str(json).expect(r"minimal gitcode PR JSON");
738 let pr: PrData = api.into();
739
740 assert_eq!(pr.state, State::Open);
741 assert!(pr.draft);
742 assert_eq!(pr.body, None);
743 assert_eq!(pr.head_branch, "feature/x");
744 assert_eq!(pr.base_branch, "main");
745 assert_eq!(pr.author.login, "dev");
746 }
747
748 #[test]
749 fn test_should_construct_gitcode_pr_provider() {
750 let provider = GitCodePrProvider::new("octocat/hello-world");
751 assert_eq!(provider.repo, "octocat/hello-world");
752 }
753
754 #[test]
755 fn test_should_construct_gitcode_pr_provider_from_string() {
756 let repo = String::from("octocat/hello-world");
757 let provider = GitCodePrProvider::new(repo);
758 assert_eq!(provider.repo, "octocat/hello-world");
759 }
760
761 #[test]
762 fn test_should_deserialize_empty_pr_list_from_gc_output() {
763 let gc_json = b"[]";
764 let prs: Vec<PrData> = serde_json::from_slice(gc_json).expect("valid PrData list");
765 assert!(prs.is_empty());
766 }
767
768 #[test]
769 fn test_should_debug_format_provider() {
770 let provider = GitCodePrProvider::new("octocat/hello-world");
771 let debug = format!("{provider:?}");
772 assert!(debug.contains("GitCodePrProvider"));
773 assert!(debug.contains("octocat/hello-world"));
774 }
775
776 #[test]
777 fn test_should_deserialize_comment_data_from_gc_pr_comment_output() {
778 let gc_json = br#"{
779 "id": 2002,
780 "body": "Approved, merging now.",
781 "author": {"login": "reviewer", "id": "88"},
782 "createdAt": "2026-06-20T16:00:00Z"
783 }"#;
784
785 let comment: CommentData = serde_json::from_slice(gc_json).expect("valid CommentData");
786 assert_eq!(comment.id, 2002);
787 assert_eq!(comment.body, "Approved, merging now.");
788 assert_eq!(comment.author.login, "reviewer");
789 assert_eq!(comment.author.id, "88");
790 }
791
792 #[test]
793 fn test_should_deserialize_merge_result_from_gc_merge_output() {
794 let gc_text = b"Pull request #123 was successfully merged.\n";
795 let message = String::from_utf8_lossy(gc_text).trim().to_string();
796 let result = MergeResult {
797 merged: true,
798 sha: None,
799 message: Some(message),
800 };
801
802 assert!(result.merged);
803 assert!(result.message.as_deref().is_some());
804 assert_eq!(
805 result.message.as_deref(),
806 Some("Pull request #123 was successfully merged.")
807 );
808 }
809
810 #[test]
811 fn test_should_roundtrip_merge_result_via_serde() {
812 let result = MergeResult {
813 merged: true,
814 sha: Some("deadbeef1234".into()),
815 message: Some("Squash merged".into()),
816 };
817 let json = serde_json::to_string(&result).expect("serialize");
818 let round_tripped: MergeResult = serde_json::from_str(&json).expect("deserialize");
819 assert!(round_tripped.merged);
820 assert_eq!(round_tripped.sha, result.sha);
821 assert_eq!(round_tripped.message, result.message);
822 }
823
824 #[test]
825 fn test_should_serialize_merge_result_skips_null_fields() {
826 let result = MergeResult {
827 merged: false,
828 sha: None,
829 message: None,
830 };
831 let json = serde_json::to_string(&result).expect("serialize");
832 assert!(!json.contains("null"));
833 assert_eq!(json, r#"{"merged":false}"#);
834 }
835
836 #[test]
837 fn test_should_create_provider_with_different_repos() {
838 let r1 = GitCodePrProvider::new("org/repo-a");
839 let r2 = GitCodePrProvider::new("org/repo-b");
840 assert_eq!(r1.repo, "org/repo-a");
841 assert_eq!(r2.repo, "org/repo-b");
842 }
843
844 #[test]
845 fn test_should_clone_gitcode_pr_provider() {
846 let original = GitCodePrProvider::new("owner/repo");
847 let cloned = original.clone();
848 assert_eq!(original.repo, cloned.repo);
849 }
850
851 fn sample_create_args() -> CreatePrArgs {
854 CreatePrArgs {
855 title: "New feature".to_string(),
856 body: Some("Adds a feature".to_string()),
857 head: "feature/x".to_string(),
858 base: "main".to_string(),
859 draft: false,
860 repo: None,
861 }
862 }
863
864 #[tokio::test]
865 async fn test_should_return_platform_error_when_gc_fails_for_create() {
866 let runner = MockCommandRunner::failure("validation failed", 256);
867 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
868
869 let result = provider.create(sample_create_args()).await;
870
871 assert!(matches!(
872 result.unwrap_err(),
873 gitflow_core::CoreError::Cli(_)
874 ));
875 }
876
877 #[tokio::test]
878 async fn test_should_return_serialization_error_on_invalid_json_for_create() {
879 let runner = MockCommandRunner::success("not valid json");
880 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
881
882 let result = provider.create(sample_create_args()).await;
883
884 assert!(matches!(
885 result.unwrap_err(),
886 gitflow_core::CoreError::Serialization(_)
887 ));
888 }
889
890 #[tokio::test]
891 async fn test_should_return_platform_error_when_gc_fails_for_list() {
892 let runner = MockCommandRunner::failure("forbidden", 256);
893 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
894
895 let result = provider.list(ListPrArgs::default()).await;
896
897 assert!(matches!(
898 result.unwrap_err(),
899 gitflow_core::CoreError::Cli(_)
900 ));
901 }
902
903 #[tokio::test]
904 async fn test_should_return_serialization_error_on_invalid_json_for_list() {
905 let runner = MockCommandRunner::success("invalid");
906 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
907
908 let result = provider.list(ListPrArgs::default()).await;
909
910 assert!(matches!(
911 result.unwrap_err(),
912 gitflow_core::CoreError::Serialization(_)
913 ));
914 }
915
916 #[tokio::test]
917 async fn test_should_return_platform_error_when_gc_fails_for_view() {
918 let runner = MockCommandRunner::failure("pr not found", 256);
919 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
920
921 let result = provider.view(999).await;
922
923 assert!(matches!(
924 result.unwrap_err(),
925 gitflow_core::CoreError::Cli(_)
926 ));
927 }
928
929 #[tokio::test]
930 async fn test_should_return_serialization_error_on_invalid_json_for_view() {
931 let runner = MockCommandRunner::success("not valid json");
932 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
933
934 let result = provider.view(1).await;
935
936 assert!(matches!(
937 result.unwrap_err(),
938 gitflow_core::CoreError::Serialization(_)
939 ));
940 }
941
942 #[tokio::test]
943 async fn test_should_return_platform_error_when_gc_fails_for_close() {
944 let runner = MockCommandRunner::failure("not found", 256);
945 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
946
947 let result = provider.close(42).await;
948
949 assert!(matches!(
950 result.unwrap_err(),
951 gitflow_core::CoreError::Cli(_)
952 ));
953 }
954
955 #[tokio::test]
956 async fn test_should_return_platform_error_when_gc_fails_for_reopen() {
957 let runner = MockCommandRunner::failure("not found", 256);
958 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
959
960 let result = provider.reopen(42).await;
961
962 assert!(matches!(
963 result.unwrap_err(),
964 gitflow_core::CoreError::Cli(_)
965 ));
966 }
967
968 #[tokio::test]
969 async fn test_should_return_platform_error_when_gc_fails_for_merge() {
970 let runner = MockCommandRunner::failure("merge conflict", 256);
971 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
972
973 let result = provider.merge(42, None).await;
974
975 assert!(matches!(
976 result.unwrap_err(),
977 gitflow_core::CoreError::Cli(_)
978 ));
979 }
980
981 #[tokio::test]
982 async fn test_should_return_platform_error_when_gc_fails_for_comment() {
983 let runner = MockCommandRunner::failure("not found", 256);
984 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
985
986 let result = provider.comment(42, "a comment").await;
987
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_gc_fails_for_checkout() {
996 let runner = MockCommandRunner::failure("git error", 256);
997 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
998
999 let result = provider.checkout(42).await;
1000
1001 assert!(matches!(
1002 result.unwrap_err(),
1003 gitflow_core::CoreError::Cli(_)
1004 ));
1005 }
1006
1007 #[tokio::test]
1008 async fn test_should_return_platform_error_when_gc_fails_for_sync_branch() {
1009 let runner = MockCommandRunner::failure("sync conflict", 256);
1010 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
1011
1012 let result = provider.sync_branch(42).await;
1013
1014 assert!(matches!(
1015 result.unwrap_err(),
1016 gitflow_core::CoreError::Cli(_)
1017 ));
1018 }
1019
1020 #[tokio::test]
1021 async fn test_should_return_platform_error_when_gc_fails_for_mark_ready() {
1022 let runner = MockCommandRunner::failure("not a draft", 256);
1023 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
1024
1025 let result = provider.mark_ready(42).await;
1026
1027 assert!(matches!(
1028 result.unwrap_err(),
1029 gitflow_core::CoreError::Cli(_)
1030 ));
1031 }
1032
1033 #[tokio::test]
1034 async fn test_should_return_platform_error_when_gc_fails_for_mark_wip() {
1035 let runner = MockCommandRunner::failure("already a draft", 256);
1036 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
1037
1038 let result = provider.mark_wip(42).await;
1039
1040 assert!(matches!(
1041 result.unwrap_err(),
1042 gitflow_core::CoreError::Cli(_)
1043 ));
1044 }
1045
1046 #[tokio::test]
1049 async fn test_should_fetch_mr_diff() {
1050 use gitflow_core::pr::PrProvider;
1051
1052 let diff_output = "diff --git a/src/main.rs b/src/main.rs\nindex 1234567..abcdefg \
1053 100644\n--- a/src/main.rs\n+++ b/src/main.rs\n@@ -1 +1 @@\n-old\n+new\n";
1054 let runner = MockCommandRunner::success(diff_output);
1055 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
1056
1057 let result = provider.diff(42).await.expect("diff should succeed");
1058 assert_eq!(result, diff_output);
1059 }
1060
1061 #[tokio::test]
1062 async fn test_should_return_error_when_mr_diff_fails() {
1063 use gitflow_core::pr::PrProvider;
1064
1065 let runner = MockCommandRunner::failure("404 not found", 256);
1066 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
1067
1068 let result = provider.diff(999).await;
1069 assert!(matches!(
1070 result.unwrap_err(),
1071 gitflow_core::CoreError::Cli(_)
1072 ));
1073 }
1074
1075 #[tokio::test]
1078 async fn test_should_fetch_mr_patch() {
1079 use gitflow_core::pr::PrProvider;
1080
1081 let patch_output =
1082 "From abc123\nSubject: [PATCH] Update file\n\ndiff --git a/src/main.rs b/src/main.rs\n";
1083 let runner = MockCommandRunner::success(patch_output);
1084 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
1085
1086 let result = provider.patch(42).await.expect("patch should succeed");
1087 assert_eq!(result, patch_output);
1088 }
1089
1090 #[tokio::test]
1091 async fn test_should_return_error_when_mr_patch_fails() {
1092 use gitflow_core::pr::PrProvider;
1093
1094 let runner = MockCommandRunner::failure("404 not found", 256);
1095 let provider = GitCodePrProvider::with_runner("owner/repo", runner);
1096
1097 let result = provider.patch(999).await;
1098 assert!(matches!(
1099 result.unwrap_err(),
1100 gitflow_core::CoreError::Cli(_)
1101 ));
1102 }
1103
1104 use crate::runner::RecordingMockRunner;
1107
1108 #[tokio::test]
1109 async fn test_should_not_pass_field_list_to_pr_view() {
1110 let runner = RecordingMockRunner::success(real_gitcode_pr_json());
1111 let provider = GitCodePrProvider::with_runner("octocat/hello-world", runner.clone());
1112
1113 let pr = provider
1114 .view(20)
1115 .await
1116 .expect("view should parse real schema");
1117
1118 assert_eq!(pr.number, 52);
1119 let calls = runner.calls();
1120 assert_eq!(calls.len(), 1);
1121 assert_eq!(
1122 calls[0],
1123 vec![
1124 "pr",
1125 "view",
1126 "20",
1127 "--repo",
1128 "octocat/hello-world",
1129 "--json"
1130 ],
1131 "gitcode --json 是布尔标志,不得携带字段列表位置参数"
1132 );
1133 }
1134
1135 #[tokio::test]
1136 async fn test_should_pass_yes_flag_to_pr_close() {
1137 let runner = RecordingMockRunner::success(real_gitcode_pr_json());
1138 let provider = GitCodePrProvider::with_runner("o/r", runner.clone());
1139
1140 provider.close(9).await.expect("close should succeed");
1141
1142 let args = &runner.calls()[0];
1143 assert!(
1144 args.contains(&"--yes".to_string()),
1145 "close 必须跳过确认提示"
1146 );
1147 assert!(
1148 !args
1149 .windows(2)
1150 .any(|w| { w[0] == "--json" && w[1] != "--yes" && !w[1].starts_with('-') }),
1151 "--json 后不得跟随字段列表"
1152 );
1153 }
1154
1155 #[tokio::test]
1156 async fn test_should_pass_limit_flag_to_pr_list() {
1157 let runner = RecordingMockRunner::success(&format!("[{}]", real_gitcode_pr_json()));
1158 let provider = GitCodePrProvider::with_runner("o/r", runner.clone());
1159
1160 let prs = provider
1161 .list(ListPrArgs {
1162 state: Some(State::Open),
1163 limit: Some(5),
1164 })
1165 .await
1166 .expect("list should succeed");
1167
1168 assert_eq!(prs.len(), 1);
1169 let args = &runner.calls()[0];
1170 assert!(args.contains(&"--limit".to_string()));
1171 assert!(args.contains(&"5".to_string()));
1172 assert!(args.contains(&"--state".to_string()));
1173 assert!(args.contains(&"open".to_string()));
1174 }
1175
1176 #[tokio::test]
1177 async fn test_should_map_squash_strategy_to_method_flag() {
1178 let runner = RecordingMockRunner::success("Merged pull request !52");
1179 let provider = GitCodePrProvider::with_runner("o/r", runner.clone());
1180
1181 let result = provider
1182 .merge(52, Some(MergeStrategy::Squash))
1183 .await
1184 .expect("merge");
1185
1186 assert!(result.merged);
1187 let args = &runner.calls()[0];
1188 let method_pos = args
1189 .iter()
1190 .position(|a| a == "--method")
1191 .expect("--method must be passed");
1192 assert_eq!(args[method_pos + 1], "squash");
1193 }
1194
1195 #[tokio::test]
1196 async fn test_should_map_all_merge_strategies() {
1197 for (strategy, expected) in [
1198 (MergeStrategy::Merge, "merge"),
1199 (MergeStrategy::Squash, "squash"),
1200 (MergeStrategy::Rebase, "rebase"),
1201 ] {
1202 let runner = RecordingMockRunner::success("done");
1203 let provider = GitCodePrProvider::with_runner("o/r", runner.clone());
1204 provider.merge(1, Some(strategy)).await.expect("merge");
1205 let args = &runner.calls()[0];
1206 let pos = args.iter().position(|a| a == "--method").expect("--method");
1207 assert_eq!(args[pos + 1], expected);
1208 }
1209 }
1210
1211 #[tokio::test]
1212 async fn test_should_omit_method_flag_when_no_strategy() {
1213 let runner = RecordingMockRunner::success("done");
1214 let provider = GitCodePrProvider::with_runner("o/r", runner.clone());
1215
1216 provider.merge(1, None).await.expect("merge");
1217
1218 assert!(!runner.calls()[0].contains(&"--method".to_string()));
1219 }
1220
1221 #[tokio::test]
1222 async fn test_should_not_pass_field_list_to_pr_comment() {
1223 let comment_json = r#"{"id": "9001", "body": "LGTM", "user": {"login": "rev", "id": "u9"}, "created_at": "2026-07-30T12:00:00+08:00"}"#;
1224 let runner = RecordingMockRunner::success(comment_json);
1225 let provider = GitCodePrProvider::with_runner("o/r", runner.clone());
1226
1227 let comment = provider
1228 .comment(52, "LGTM")
1229 .await
1230 .expect("comment should parse");
1231
1232 assert_eq!(comment.id, 9001);
1233 assert_eq!(comment.author.login, "rev");
1234 assert_eq!(
1235 runner.calls()[0],
1236 vec![
1237 "pr", "comment", "52", "--repo", "o/r", "--body", "LGTM", "--json"
1238 ]
1239 );
1240 }
1241
1242 #[test]
1243 fn test_should_parse_comment_with_legacy_string_author() {
1244 let json = r#"{"id": "7", "body": "old format", "author": "alice", "created_at": "2026-07-07 10:40:20"}"#;
1245 let api: PrCommentApiResponse = serde_json::from_str(json).expect("legacy shape");
1246 let comment: CommentData = api.into();
1247 assert_eq!(comment.author.login, "alice");
1248 assert_eq!(comment.created_at.to_rfc3339(), "2026-07-07T10:40:20+00:00");
1249 }
1250}
1251
1252#[cfg(test)]
1253mod contract_tests {
1254 use gitflow_core::pr::ListPrArgs;
1263
1264 use super::*;
1265 use crate::runner::MockCommandRunner;
1266
1267 const PR_LIST_FIXTURE: &str = include_str!("../tests/fixtures/pr_list_gitcode_v0.6.json");
1268
1269 #[tokio::test]
1270 async fn test_should_parse_real_gitcode_v061_pr_list_output() {
1271 let provider = GitCodePrProvider::with_runner(
1272 "byx-darwin/go-beniofit",
1273 MockCommandRunner::success(PR_LIST_FIXTURE),
1274 );
1275
1276 let prs = provider
1277 .list(ListPrArgs::default())
1278 .await
1279 .expect("contract fixture must parse");
1280
1281 assert_eq!(prs.len(), 1);
1282 let pr = &prs[0];
1283 assert_eq!(pr.number, 52);
1284 assert_eq!(pr.state, State::Closed);
1285 assert_eq!(pr.author.login, "byx-darwin");
1286 assert_eq!(pr.head_branch, "test/88-engine-rule-coverage");
1287 assert_eq!(pr.base_branch, "master");
1288 assert!(pr.url.starts_with("https://gitcode.com/"));
1289 }
1290}