1use async_trait::async_trait;
12use chrono::{DateTime, Utc};
13use gitflow_core::{
14 CoreError, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, fetch_capped,
15 pr::{CreatePrArgs, ListPrArgs, PrData, PrProvider},
16 types::{CommentData, MergeResult, MergeStrategy, State, UserSummary},
17};
18use serde::Deserialize;
19use tracing::debug;
20
21use crate::{
22 GITLAB_MAX_PER_PAGE,
23 commit::encode_project_path,
24 error::parse_glab_error,
25 runner::{CommandRunner, RealCommandRunner},
26};
27
28#[derive(Debug, Clone)]
41pub struct GitLabMrProvider<R: CommandRunner = RealCommandRunner> {
42 repo: String,
45 repo_target: String,
49 runner: R,
51}
52
53impl GitLabMrProvider<RealCommandRunner> {
54 #[must_use]
58 pub fn new(repo: impl Into<String>) -> Self {
59 let repo = repo.into();
60 Self {
61 repo_target: repo.clone(),
62 repo,
63 runner: RealCommandRunner,
64 }
65 }
66
67 #[must_use]
71 pub fn with_session(session: &gitflow_core::Session) -> Self {
72 let repo = session.repo.clone();
73 Self {
74 repo_target: repo.clone(),
75 repo,
76 runner: RealCommandRunner,
77 }
78 }
79
80 #[must_use]
85 pub fn with_remote_url(repo: impl Into<String>, remote_url: impl Into<String>) -> Self {
86 Self {
87 repo: repo.into(),
88 repo_target: remote_url.into(),
89 runner: RealCommandRunner,
90 }
91 }
92}
93
94impl<R: CommandRunner> GitLabMrProvider<R> {
95 #[must_use]
100 pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
101 let repo = repo.into();
102 Self {
103 repo_target: repo.clone(),
104 repo,
105 runner,
106 }
107 }
108
109 #[must_use]
113 pub fn with_runner_and_repo_target(
114 repo: impl Into<String>,
115 repo_target: impl Into<String>,
116 runner: R,
117 ) -> Self {
118 Self {
119 repo: repo.into(),
120 repo_target: repo_target.into(),
121 runner,
122 }
123 }
124
125 async fn run_mr_update(&self, number: u64, draft: bool) -> Result<()> {
133 let number_str = number.to_string();
134 let draft_flag = if draft {
135 "--draft=true"
136 } else {
137 "--draft=false"
138 };
139 let output = self
140 .runner
141 .run(
142 "glab",
143 &[
144 "mr",
145 "update",
146 &number_str,
147 "--repo",
148 &self.repo_target,
149 draft_flag,
150 ],
151 )
152 .await
153 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab mr update: {e}")))?;
154 if !output.status.success() {
155 return Err(parse_glab_error(&output.stderr).into());
156 }
157 Ok(())
158 }
159
160 async fn list_impl(&self, args: ListPrArgs) -> Result<Paged<PrData>> {
165 let cap = args.limit.unwrap_or(DEFAULT_LIST_LIMIT);
166 let repo_target = &self.repo_target;
167 let runner = &self.runner;
168 let state = args.state;
169 let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
172
173 debug!(repo = %self.repo, cap, "spawning `glab mr list`");
174
175 fetch_capped(
176 FetchStrategy::Paged { per_page },
177 cap,
178 |page, per_page| async move {
179 let page_str = page.to_string();
180 let per_page_str = per_page.to_string();
181 let mut cmd_args: Vec<&str> =
182 vec!["mr", "list", "--repo", repo_target, "--output", "json"];
183
184 if let Some(state) = &state {
186 match state {
187 State::Closed => cmd_args.push("--closed"),
188 State::All => cmd_args.push("--all"),
189 State::Open => {}
190 }
191 }
192
193 cmd_args.push("--per-page");
194 cmd_args.push(&per_page_str);
195 cmd_args.push("--page");
196 cmd_args.push(&page_str);
197
198 let output = runner
199 .run("glab", &cmd_args)
200 .await
201 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
202
203 if !output.status.success() {
204 return Err(parse_glab_error(&output.stderr).into());
205 }
206
207 let api_responses: Vec<MrApiResponse> =
208 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
209
210 Ok(api_responses.into_iter().map(PrData::from).collect())
211 },
212 )
213 .await
214 }
215}
216
217#[derive(Debug, Clone, Deserialize)]
221struct ApiUser {
222 username: String,
223 #[serde(default)]
224 id: u64,
225}
226
227impl From<&ApiUser> for UserSummary {
228 fn from(u: &ApiUser) -> Self {
229 Self {
230 login: u.username.clone(),
231 id: u.id.to_string(),
232 }
233 }
234}
235
236#[derive(Debug, Clone, Deserialize)]
242struct MilestoneRefApi {
243 #[serde(default)]
244 id: u64,
245 #[serde(default)]
246 iid: Option<u64>,
247 title: String,
248}
249
250impl From<MilestoneRefApi> for gitflow_core::types::MilestoneRef {
251 fn from(api: MilestoneRefApi) -> Self {
252 Self {
253 number: api.iid.unwrap_or(api.id),
254 title: api.title,
255 }
256 }
257}
258
259#[derive(Debug, Deserialize)]
261struct RepoViewResponse {
262 default_branch: String,
263}
264
265#[derive(Debug, Clone, Deserialize)]
267struct MrApiResponse {
268 iid: u64,
269 title: String,
270 #[serde(default)]
271 description: Option<String>,
272 state: String,
273 #[serde(default)]
274 draft: bool,
275 #[serde(default)]
276 author: Option<ApiUser>,
277 #[serde(default)]
278 source_branch: String,
279 #[serde(default)]
280 target_branch: String,
281 #[serde(default)]
282 created_at: Option<DateTime<Utc>>,
283 #[serde(default)]
284 updated_at: Option<DateTime<Utc>>,
285 #[serde(default)]
288 merged_at: Option<DateTime<Utc>>,
289 #[serde(default)]
290 web_url: Option<String>,
291 #[serde(default)]
292 milestone: Option<MilestoneRefApi>,
293}
294
295impl From<MrApiResponse> for PrData {
296 fn from(api: MrApiResponse) -> Self {
297 let state = if api.state == "closed" || api.state == "merged" {
298 State::Closed
299 } else {
300 State::Open
301 };
302 let author = api.author.as_ref().map_or_else(
303 || UserSummary {
304 login: "unknown".into(),
305 id: "0".to_string(),
306 },
307 UserSummary::from,
308 );
309
310 Self {
311 number: api.iid,
312 title: api.title,
313 body: api.description,
314 state,
315 draft: api.draft,
316 author,
317 base_branch: api.target_branch,
318 head_branch: api.source_branch,
319 created_at: api.created_at,
320 updated_at: api.updated_at,
321 merged_at: api.merged_at,
322 url: api.web_url.unwrap_or_default(),
323 milestone: api.milestone.map(Into::into),
324 }
325 }
326}
327
328#[derive(Debug, Clone, Deserialize)]
330struct CommentApiResponse {
331 id: u64,
332 #[serde(default)]
333 body: String,
334 #[serde(default)]
335 author: Option<ApiUser>,
336 #[serde(default)]
337 created_at: Option<DateTime<Utc>>,
338}
339
340impl From<CommentApiResponse> for CommentData {
341 fn from(api: CommentApiResponse) -> Self {
342 let author = api.author.as_ref().map_or_else(
343 || UserSummary {
344 login: "unknown".into(),
345 id: "0".to_string(),
346 },
347 UserSummary::from,
348 );
349 Self {
350 id: api.id,
351 body: api.body,
352 author,
353 created_at: api.created_at,
354 }
355 }
356}
357
358#[async_trait]
361impl<R: CommandRunner + Clone + 'static> PrProvider for GitLabMrProvider<R> {
362 async fn create(&self, args: CreatePrArgs) -> Result<PrData> {
363 let repo = args.repo.as_deref().unwrap_or(&self.repo_target);
364 let mut cmd_args: Vec<&str> = vec![
365 "mr",
366 "create",
367 "--repo",
368 repo,
369 "--title",
370 &args.title,
371 "--source-branch",
372 &args.head,
373 "--target-branch",
374 &args.base,
375 ];
376
377 let final_body =
378 gitflow_core::pr::format_closing_body(&args.body, &args.closes_issues, "Closes");
379
380 if let Some(body) = &final_body {
381 cmd_args.push("--description");
382 cmd_args.push(body);
383 }
384
385 if args.draft {
386 cmd_args.push("--draft");
387 }
388
389 let resolved_milestone_title;
390 if let Some(identifier) = &args.milestone {
391 let milestone_repo = args.repo.as_deref().unwrap_or(&self.repo);
397 let milestone_provider =
398 crate::GitLabMilestoneProvider::with_runner(milestone_repo, self.runner.clone());
399 let resolved =
400 gitflow_core::label::resolve_milestone_identifier(&milestone_provider, identifier)
401 .await?;
402 resolved_milestone_title = resolved.title;
403 cmd_args.push("--milestone");
404 cmd_args.push(&resolved_milestone_title);
405 }
406
407 debug!(
408 repo = %self.repo,
409 title = %args.title,
410 head = %args.head,
411 base = %args.base,
412 "spawning `glab mr create`"
413 );
414
415 let output = self
416 .runner
417 .run("glab", &cmd_args)
418 .await
419 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
420
421 if !output.status.success() {
422 return Err(parse_glab_error(&output.stderr).into());
423 }
424
425 let stdout = String::from_utf8_lossy(&output.stdout);
427 let mr_iid = parse_mr_iid_from_url(&stdout).ok_or_else(|| {
428 CoreError::Platform(format!("Failed to parse MR URL from output: {stdout}"))
429 })?;
430
431 self.view(mr_iid).await
433 }
434
435 async fn list(&self, args: ListPrArgs) -> Result<Paged<PrData>> {
436 self.list_impl(args).await
437 }
438
439 async fn view(&self, number: u64) -> Result<PrData> {
440 debug!(repo = %self.repo, number, "spawning `glab mr view`");
441
442 let number_str = number.to_string();
443 let output = self
444 .runner
445 .run(
446 "glab",
447 &[
448 "mr",
449 "view",
450 &number_str,
451 "--repo",
452 &self.repo_target,
453 "--output",
454 "json",
455 ],
456 )
457 .await
458 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
459
460 if !output.status.success() {
461 return Err(parse_glab_error(&output.stderr).into());
462 }
463
464 let api_response: MrApiResponse =
465 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
466
467 Ok(api_response.into())
468 }
469
470 async fn close(&self, number: u64) -> Result<PrData> {
471 debug!(repo = %self.repo, number, "spawning `glab mr close`");
472
473 let number_str = number.to_string();
474 let output = self
475 .runner
476 .run(
477 "glab",
478 &["mr", "close", &number_str, "--repo", &self.repo_target],
479 )
480 .await
481 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
482
483 if !output.status.success() {
484 return Err(parse_glab_error(&output.stderr).into());
485 }
486
487 self.view(number).await
488 }
489
490 async fn reopen(&self, number: u64) -> Result<PrData> {
491 debug!(repo = %self.repo, number, "spawning `glab mr reopen`");
492
493 let number_str = number.to_string();
494 let output = self
495 .runner
496 .run(
497 "glab",
498 &["mr", "reopen", &number_str, "--repo", &self.repo_target],
499 )
500 .await
501 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
502
503 if !output.status.success() {
504 return Err(parse_glab_error(&output.stderr).into());
505 }
506
507 self.view(number).await
508 }
509
510 async fn comment(&self, number: u64, body: &str) -> Result<CommentData> {
511 debug!(repo = %self.repo, number, "spawning `glab api` POST mr note");
512
513 let encoded_path = encode_project_path(&self.repo);
514 let api_path = format!("/projects/{encoded_path}/merge_requests/{number}/notes");
515 let body_arg = format!("body={body}");
516
517 let output = self
518 .runner
519 .run(
520 "glab",
521 &["api", "--method", "POST", &api_path, "-f", &body_arg],
522 )
523 .await
524 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab api: {e}")))?;
525
526 if !output.status.success() {
527 return Err(parse_glab_error(&output.stderr).into());
528 }
529
530 let api_response: CommentApiResponse =
531 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
532
533 Ok(api_response.into())
534 }
535
536 async fn merge(
540 &self,
541 number: u64,
542 strategy: Option<MergeStrategy>,
543 auto: bool,
544 ) -> Result<MergeResult> {
545 debug!(repo = %self.repo, number, ?strategy, auto, "spawning `glab mr merge`");
546
547 let number_str = number.to_string();
548 let mut cmd_args: Vec<&str> = vec!["mr", "merge", &number_str, "--repo", &self.repo_target];
549
550 match strategy {
551 Some(MergeStrategy::Squash) => cmd_args.push("--squash"),
552 Some(MergeStrategy::Rebase) => cmd_args.push("--rebase"),
553 Some(MergeStrategy::Merge) | None => {}
554 }
555
556 if auto {
557 cmd_args.push("--auto-merge");
558 }
559
560 let output = self
561 .runner
562 .run("glab", &cmd_args)
563 .await
564 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
565
566 if !output.status.success() {
567 return Err(parse_glab_error(&output.stderr).into());
568 }
569
570 let message = String::from_utf8_lossy(&output.stdout).trim().to_string();
571 let message = if message.is_empty() && auto {
574 "已排队合并:GitLab 将在 pipeline 通过后自动合并".to_string()
575 } else {
576 message
577 };
578 Ok(MergeResult {
579 merged: !auto,
580 sha: None,
581 message: Some(message),
582 })
583 }
584
585 async fn checkout(&self, number: u64) -> Result<()> {
586 debug!(repo = %self.repo, number, "spawning `glab mr checkout`");
587
588 let number_str = number.to_string();
589 let output = self
590 .runner
591 .run(
592 "glab",
593 &["mr", "checkout", &number_str, "--repo", &self.repo_target],
594 )
595 .await
596 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
597
598 if !output.status.success() {
599 return Err(parse_glab_error(&output.stderr).into());
600 }
601
602 Ok(())
603 }
604
605 async fn mark_ready(&self, number: u64) -> Result<PrData> {
606 debug!(repo = %self.repo, number, "spawning `glab mr update --draft=false`");
607 self.run_mr_update(number, false).await?;
608 self.view(number).await
609 }
610
611 async fn mark_wip(&self, number: u64) -> Result<PrData> {
612 debug!(repo = %self.repo, number, "spawning `glab mr update --draft=true`");
613 self.run_mr_update(number, true).await?;
614 self.view(number).await
615 }
616
617 async fn sync_branch(&self, number: u64) -> Result<()> {
618 debug!(repo = %self.repo, number, "spawning `glab mr rebase`");
619
620 let number_str = number.to_string();
621 let output = self
622 .runner
623 .run(
624 "glab",
625 &["mr", "rebase", &number_str, "--repo", &self.repo_target],
626 )
627 .await
628 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
629
630 if !output.status.success() {
631 return Err(parse_glab_error(&output.stderr).into());
632 }
633
634 Ok(())
635 }
636
637 async fn diff(&self, number: u64) -> Result<String> {
645 debug!(repo = %self.repo, number, "spawning `glab mr diff`");
646
647 let number_str = number.to_string();
648 let output = self
649 .runner
650 .run("glab", &["mr", "diff", &number_str])
651 .await
652 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab mr diff: {e}")))?;
653
654 if !output.status.success() {
655 return Err(parse_glab_error(&output.stderr).into());
656 }
657
658 Ok(String::from_utf8_lossy(&output.stdout).into_owned())
659 }
660
661 async fn patch(&self, number: u64) -> Result<String> {
670 debug!(repo = %self.repo, number, "spawning `glab api mr patch`");
671
672 let encoded_path = encode_project_path(&self.repo);
673 let api_path = format!("projects/{encoded_path}/merge_requests/{number}.patch");
674
675 let output = self
676 .runner
677 .run("glab", &["api", &api_path])
678 .await
679 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab api mr patch: {e}")))?;
680
681 if !output.status.success() {
682 return Err(parse_glab_error(&output.stderr).into());
683 }
684
685 Ok(String::from_utf8_lossy(&output.stdout).into_owned())
686 }
687
688 async fn default_branch(&self) -> Result<String> {
696 debug!(repo = %self.repo, "spawning `glab repo view`");
697
698 let output = self
699 .runner
700 .run(
701 "glab",
702 &[
703 "repo",
704 "view",
705 "--repo",
706 &self.repo_target,
707 "--output",
708 "json",
709 ],
710 )
711 .await
712 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
713
714 if !output.status.success() {
715 return Err(parse_glab_error(&output.stderr).into());
716 }
717
718 let resp: RepoViewResponse =
719 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
720
721 Ok(resp.default_branch)
722 }
723}
724
725fn parse_mr_iid_from_url(url: &str) -> Option<u64> {
731 url.lines().find_map(|line| {
732 let line = line.trim();
733 if line.contains("/-/merge_requests/") {
734 line.rsplit("/-/merge_requests/")
735 .next()
736 .and_then(|s| s.split('/').next())
737 .and_then(|s| s.parse().ok())
738 } else {
739 None
740 }
741 })
742}
743
744#[cfg(test)]
745mod tests {
746 use super::*;
747 use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
748
749 #[test]
750 fn test_should_construct_gitlab_mr_provider() {
751 let provider = GitLabMrProvider::new("gitlab-org/gitlab");
752 assert_eq!(provider.repo, "gitlab-org/gitlab");
753 }
754
755 #[test]
756 fn test_should_construct_gitlab_mr_provider_from_string() {
757 let repo = String::from("gitlab-org/gitlab");
758 let provider = GitLabMrProvider::new(repo);
759 assert_eq!(provider.repo, "gitlab-org/gitlab");
760 }
761
762 #[test]
763 fn test_should_deserialize_mr_api_response() {
764 let json = br#"{
765 "iid": 123,
766 "title": "Add new feature",
767 "description": "This MR adds a new feature",
768 "state": "opened",
769 "draft": false,
770 "author": {"username": "alice", "id": 2},
771 "source_branch": "feature/new-thing",
772 "target_branch": "main",
773 "created_at": "2026-02-20T14:00:00Z",
774 "updated_at": "2026-02-21T10:30:00Z",
775 "web_url": "https://gitlab.com/gitlab-org/gitlab/-/merge_requests/123"
776 }"#;
777
778 let api: MrApiResponse = serde_json::from_slice(json).expect("valid MrApiResponse");
779 let pr: PrData = api.into();
780
781 assert_eq!(pr.number, 123);
782 assert_eq!(pr.title, "Add new feature");
783 assert_eq!(pr.state, State::Open);
784 assert!(!pr.draft);
785 assert_eq!(pr.author.login, "alice");
786 assert_eq!(pr.base_branch, "main");
787 assert_eq!(pr.head_branch, "feature/new-thing");
788 assert_eq!(
789 pr.url,
790 "https://gitlab.com/gitlab-org/gitlab/-/merge_requests/123"
791 );
792 }
793
794 #[test]
795 fn test_should_deserialize_draft_mr() {
796 let json = br#"{
797 "iid": 456,
798 "title": "WIP: experiment",
799 "description": null,
800 "state": "opened",
801 "draft": true,
802 "author": {"username": "bob", "id": 3},
803 "source_branch": "wip/experiment",
804 "target_branch": "main",
805 "created_at": "2026-03-10T09:00:00Z",
806 "updated_at": "2026-03-10T09:00:00Z",
807 "web_url": "https://gitlab.com/org/project/-/merge_requests/456"
808 }"#;
809
810 let api: MrApiResponse = serde_json::from_slice(json).expect("valid MrApiResponse");
811 let pr: PrData = api.into();
812 assert!(pr.draft);
813 assert!(pr.body.is_none());
814 }
815
816 #[test]
817 fn test_should_deserialize_merged_mr_as_closed() {
818 let json = br#"{
819 "iid": 789,
820 "title": "Merged feature",
821 "description": null,
822 "state": "merged",
823 "draft": false,
824 "author": {"username": "dev", "id": 1},
825 "source_branch": "feature/done",
826 "target_branch": "main",
827 "created_at": "2026-01-01T00:00:00Z",
828 "updated_at": "2026-01-02T00:00:00Z",
829 "web_url": "https://gitlab.com/org/project/-/merge_requests/789"
830 }"#;
831
832 let api: MrApiResponse = serde_json::from_slice(json).expect("valid MrApiResponse");
833 let pr: PrData = api.into();
834 assert_eq!(pr.state, State::Closed);
835 }
836
837 #[test]
838 fn test_should_deserialize_empty_mr_list() {
839 let json = b"[]";
840 let list: Vec<MrApiResponse> = serde_json::from_slice(json).expect("valid empty list");
841 assert!(list.is_empty());
842 }
843
844 #[test]
845 fn test_should_deserialize_comment_api_response() {
846 let json = br#"{
847 "id": 2002,
848 "body": "Approved, merging now.",
849 "author": {"username": "reviewer", "id": 88},
850 "created_at": "2026-06-20T16:00:00Z"
851 }"#;
852
853 let api: CommentApiResponse =
854 serde_json::from_slice(json).expect("valid CommentApiResponse");
855 let comment: CommentData = api.into();
856 assert_eq!(comment.id, 2002);
857 assert_eq!(comment.body, "Approved, merging now.");
858 assert_eq!(comment.author.login, "reviewer");
859 }
860
861 #[test]
862 fn test_should_roundtrip_merge_result_via_serde() {
863 let result = MergeResult {
864 merged: true,
865 sha: Some("deadbeef1234".into()),
866 message: Some("Squash merged".into()),
867 };
868 let json = serde_json::to_string(&result).expect("serialize");
869 let round_tripped: MergeResult = serde_json::from_str(&json).expect("deserialize");
870 assert!(round_tripped.merged);
871 assert_eq!(round_tripped.sha, result.sha);
872 }
873
874 #[test]
875 fn test_should_debug_format_provider() {
876 let provider = GitLabMrProvider::new("gitlab-org/gitlab");
877 let debug = format!("{provider:?}");
878 assert!(debug.contains("GitLabMrProvider"));
879 assert!(debug.contains("gitlab-org/gitlab"));
880 }
881
882 #[test]
883 fn test_should_clone_gitlab_mr_provider() {
884 let original = GitLabMrProvider::new("owner/repo");
885 let cloned = original.clone();
886 assert_eq!(original.repo, cloned.repo);
887 }
888
889 #[test]
890 fn test_should_handle_missing_author_with_fallback() {
891 let json = br#"{
892 "iid": 1,
893 "title": "No author",
894 "description": null,
895 "state": "opened",
896 "draft": false,
897 "author": null,
898 "source_branch": "dev",
899 "target_branch": "main",
900 "created_at": null,
901 "updated_at": null,
902 "web_url": null
903 }"#;
904
905 let api: MrApiResponse = serde_json::from_slice(json).expect("valid MrApiResponse");
906 let pr: PrData = api.into();
907 assert_eq!(pr.author.login, "unknown");
908 assert!(
909 pr.created_at.is_none(),
910 "missing created_at must stay None, not fall back to Utc::now()"
911 );
912 assert!(
913 pr.updated_at.is_none(),
914 "missing updated_at must stay None, not fall back to Utc::now()"
915 );
916 }
917
918 #[test]
919 fn test_should_keep_mr_comment_created_at_none_when_api_omits_it() {
920 let json = br#"{
921 "id": 1003,
922 "body": "No timestamp provided.",
923 "author": {"username": "maintainer", "id": 42}
924 }"#;
925
926 let api: CommentApiResponse =
927 serde_json::from_slice(json).expect("valid CommentApiResponse");
928 let comment: CommentData = api.into();
929 assert!(
930 comment.created_at.is_none(),
931 "missing created_at must stay None, not fall back to Utc::now()"
932 );
933 }
934
935 #[test]
936 fn test_should_deserialize_mr_with_milestone() {
937 let json = br#"{
942 "iid": 12,
943 "title": "Add feature",
944 "description": null,
945 "state": "opened",
946 "draft": false,
947 "author": {"username": "alice", "id": 2},
948 "source_branch": "feature/x",
949 "target_branch": "main",
950 "milestone": {
951 "id": 30,
952 "iid": 3,
953 "title": "v2.0",
954 "state": "active"
955 },
956 "web_url": "http://192.168.230.23/owner/repo/-/merge_requests/12"
957 }"#;
958
959 let api: MrApiResponse = serde_json::from_slice(json).expect("valid MrApiResponse");
960 let pr: PrData = api.into();
961 assert_eq!(
962 pr.milestone,
963 Some(gitflow_core::types::MilestoneRef {
964 number: 3,
965 title: "v2.0".into(),
966 })
967 );
968 }
969
970 fn sample_create_args() -> CreatePrArgs {
973 CreatePrArgs {
974 title: "Add feature".to_string(),
975 body: Some("Description".to_string()),
976 head: "feature/x".to_string(),
977 base: "main".to_string(),
978 draft: false,
979 repo: None,
980 closes_issues: vec![],
981 milestone: None,
982 }
983 }
984
985 #[test]
986 fn test_should_format_gitlab_body_with_closing_issues() {
987 use gitflow_core::pr::format_closing_body;
988
989 let body = Some("MR description".to_string());
990 let issues = vec![42u64];
991 let result = format_closing_body(&body, &issues, "Closes");
992 assert_eq!(result, Some("MR description\n\nCloses #42".to_string()));
993 }
994
995 #[tokio::test]
996 async fn test_should_return_platform_error_when_glab_fails_for_create() {
997 let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
998 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
999
1000 let result = provider.create(sample_create_args()).await;
1001
1002 assert!(matches!(
1003 result.unwrap_err(),
1004 gitflow_core::CoreError::Cli(_)
1005 ));
1006 }
1007
1008 #[tokio::test]
1009 async fn test_should_return_serialization_error_on_invalid_json_for_create() {
1010 let runner = SequencedMockCommandRunner::from_results(&[
1011 (true, "https://gitlab.com/owner/repo/-/merge_requests/7"),
1012 (true, "not valid json"),
1013 ]);
1014 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1015
1016 let result = provider.create(sample_create_args()).await;
1017
1018 assert!(matches!(
1019 result.unwrap_err(),
1020 gitflow_core::CoreError::Serialization(_)
1021 ));
1022 }
1023
1024 #[tokio::test]
1025 async fn test_should_create_mr_without_output_json_and_refetch_via_view() {
1026 let runner = SequencedMockCommandRunner::from_results(&[
1027 (true, "https://gitlab.com/owner/repo/-/merge_requests/12"),
1028 (
1029 true,
1030 r#"{"iid":12,"title":"Feat","state":"opened","source_branch":"feat/x","target_branch":"main"}"#,
1031 ),
1032 ]);
1033 let provider = GitLabMrProvider::with_runner("owner/repo", runner.clone());
1034
1035 let pr = provider
1036 .create(sample_create_args())
1037 .await
1038 .expect("should create");
1039 assert_eq!(pr.number, 12);
1040 let calls = runner.recorded_calls();
1041 assert!(!calls[0].1.contains(&"--output".to_string()));
1042 assert!(calls[1].1.contains(&"--output".to_string()));
1044 }
1045
1046 #[tokio::test]
1047 async fn test_should_close_mr_without_output_json_and_refetch_via_view() {
1048 let runner = MockCommandRunner::success(
1049 r#"{"iid":12,"title":"Feat","state":"closed","source_branch":"feat/x","target_branch":"main"}"#,
1050 );
1051 let provider = GitLabMrProvider::with_runner("owner/repo", runner.clone());
1052
1053 let pr = provider.close(12).await.expect("should close");
1054
1055 assert_eq!(pr.number, 12);
1056 assert_eq!(pr.state, State::Closed);
1057 let calls = runner.recorded_calls();
1058 assert_eq!(
1059 calls[0].1,
1060 vec!["mr", "close", "12", "--repo", "owner/repo"]
1061 .into_iter()
1062 .map(String::from)
1063 .collect::<Vec<_>>()
1064 );
1065 assert!(calls[1].1.contains(&"--output".to_string()));
1066 }
1067
1068 #[tokio::test]
1069 async fn test_should_use_explicit_repo_target_for_close() {
1070 let runner = MockCommandRunner::success(
1071 r#"{"iid":42,"title":"Fix","state":"closed","source_branch":"a","target_branch":"main"}"#,
1072 );
1073 let provider = GitLabMrProvider::with_runner_and_repo_target(
1074 "owner/repo",
1075 "https://192.168.230.23/iproost/proxy/api-src.git",
1076 runner.clone(),
1077 );
1078
1079 let pr = provider.close(42).await.expect("close should succeed");
1080
1081 assert_eq!(pr.number, 42);
1082 assert_eq!(
1083 runner.recorded_calls()[0].1,
1084 vec![
1085 "mr",
1086 "close",
1087 "42",
1088 "--repo",
1089 "https://192.168.230.23/iproost/proxy/api-src.git",
1090 ]
1091 .into_iter()
1092 .map(String::from)
1093 .collect::<Vec<_>>()
1094 );
1095 }
1096
1097 #[tokio::test]
1098 async fn test_should_reopen_mr_without_output_json_and_refetch_via_view() {
1099 let runner = MockCommandRunner::success(
1100 r#"{"iid":12,"title":"Feat","state":"opened","source_branch":"feat/x","target_branch":"main"}"#,
1101 );
1102 let provider = GitLabMrProvider::with_runner("owner/repo", runner.clone());
1103
1104 let pr = provider.reopen(12).await.expect("should reopen");
1105
1106 assert_eq!(pr.number, 12);
1107 assert_eq!(pr.state, State::Open);
1108 let calls = runner.recorded_calls();
1109 assert_eq!(
1110 calls[0].1,
1111 vec!["mr", "reopen", "12", "--repo", "owner/repo"]
1112 .into_iter()
1113 .map(String::from)
1114 .collect::<Vec<_>>()
1115 );
1116 assert!(calls[1].1.contains(&"--output".to_string()));
1117 }
1118
1119 #[tokio::test]
1120 async fn test_should_return_platform_error_when_glab_fails_for_list() {
1121 let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
1122 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1123
1124 let result = provider.list(ListPrArgs::default()).await;
1125
1126 assert!(matches!(
1127 result.unwrap_err(),
1128 gitflow_core::CoreError::Cli(_)
1129 ));
1130 }
1131
1132 #[tokio::test]
1133 async fn test_should_return_serialization_error_on_invalid_json_for_list() {
1134 let runner = MockCommandRunner::success("invalid");
1135 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1136
1137 let result = provider.list(ListPrArgs::default()).await;
1138
1139 assert!(matches!(
1140 result.unwrap_err(),
1141 gitflow_core::CoreError::Serialization(_)
1142 ));
1143 }
1144
1145 #[tokio::test]
1146 async fn test_should_list_all_mrs_with_all_flag() {
1147 let runner = MockCommandRunner::success("[]");
1148 let provider = GitLabMrProvider::with_runner("owner/repo", runner.clone());
1149
1150 let _ = provider
1151 .list(ListPrArgs {
1152 state: Some(State::All),
1153 ..Default::default()
1154 })
1155 .await;
1156
1157 assert_eq!(
1158 runner.recorded_calls()[0].1,
1159 vec![
1160 "mr",
1161 "list",
1162 "--repo",
1163 "owner/repo",
1164 "--output",
1165 "json",
1166 "--all",
1167 "--per-page",
1168 "100",
1169 "--page",
1170 "1",
1171 ]
1172 .into_iter()
1173 .map(String::from)
1174 .collect::<Vec<_>>()
1175 );
1176 }
1177
1178 #[tokio::test]
1179 async fn test_should_return_platform_error_when_glab_fails_for_view() {
1180 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1181 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1182
1183 let result = provider.view(999).await;
1184
1185 assert!(matches!(
1186 result.unwrap_err(),
1187 gitflow_core::CoreError::Cli(_)
1188 ));
1189 }
1190
1191 #[tokio::test]
1192 async fn test_should_return_serialization_error_on_invalid_json_for_view() {
1193 let runner = MockCommandRunner::success("not valid json");
1194 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1195
1196 let result = provider.view(1).await;
1197
1198 assert!(matches!(
1199 result.unwrap_err(),
1200 gitflow_core::CoreError::Serialization(_)
1201 ));
1202 }
1203
1204 #[tokio::test]
1205 async fn test_should_return_platform_error_when_glab_fails_for_close() {
1206 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1207 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1208
1209 let result = provider.close(42).await;
1210
1211 assert!(matches!(
1212 result.unwrap_err(),
1213 gitflow_core::CoreError::Cli(_)
1214 ));
1215 }
1216
1217 #[tokio::test]
1218 async fn test_should_return_platform_error_when_glab_fails_for_reopen() {
1219 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1220 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1221
1222 let result = provider.reopen(42).await;
1223
1224 assert!(matches!(
1225 result.unwrap_err(),
1226 gitflow_core::CoreError::Cli(_)
1227 ));
1228 }
1229
1230 #[tokio::test]
1231 async fn test_should_return_platform_error_when_glab_fails_for_comment() {
1232 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1233 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1234
1235 let result = provider.comment(42, "a comment").await;
1236
1237 assert!(matches!(
1238 result.unwrap_err(),
1239 gitflow_core::CoreError::Cli(_)
1240 ));
1241 }
1242
1243 #[tokio::test]
1244 async fn test_should_post_mr_note_via_glab_api() {
1245 let runner = MockCommandRunner::success(
1246 r#"{"id":88,"body":"lgtm","author":{"username":"bob","id":2},"created_at":"2026-08-18T00:00:00Z"}"#,
1247 );
1248 let provider = GitLabMrProvider::with_runner("owner/repo", runner.clone());
1249
1250 let comment = provider.comment(7, "lgtm").await.expect("should post");
1251
1252 assert_eq!(comment.id, 88);
1253 assert_eq!(
1254 runner.recorded_calls()[0].1,
1255 vec![
1256 "api",
1257 "--method",
1258 "POST",
1259 "/projects/owner%2Frepo/merge_requests/7/notes",
1260 "-f",
1261 "body=lgtm",
1262 ]
1263 .into_iter()
1264 .map(String::from)
1265 .collect::<Vec<_>>()
1266 );
1267 }
1268
1269 #[tokio::test]
1270 async fn test_should_encode_nested_group_repo_path_for_mr_note() {
1271 let runner = MockCommandRunner::success(
1272 r#"{"id":88,"body":"lgtm","author":{"username":"bob","id":2},"created_at":"2026-08-18T00:00:00Z"}"#,
1273 );
1274 let provider = GitLabMrProvider::with_runner("group/subgroup/project", runner.clone());
1275
1276 let comment = provider.comment(7, "lgtm").await.expect("should post");
1277
1278 assert_eq!(comment.id, 88);
1279 assert_eq!(
1280 runner.recorded_calls()[0].1,
1281 vec![
1282 "api",
1283 "--method",
1284 "POST",
1285 "/projects/group%2Fsubgroup%2Fproject/merge_requests/7/notes",
1286 "-f",
1287 "body=lgtm",
1288 ]
1289 .into_iter()
1290 .map(String::from)
1291 .collect::<Vec<_>>()
1292 );
1293 }
1294
1295 #[tokio::test]
1296 async fn test_should_return_platform_error_when_glab_fails_for_merge() {
1297 let runner = MockCommandRunner::failure(r#"{"message": "Not mergeable"}"#, 256);
1298 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1299
1300 let result = provider.merge(42, None, false).await;
1301
1302 assert!(matches!(
1303 result.unwrap_err(),
1304 gitflow_core::CoreError::Cli(_)
1305 ));
1306 }
1307
1308 #[tokio::test]
1309 async fn test_should_merge_without_merge_flag() {
1310 let runner = MockCommandRunner::success("Merged!");
1311 let provider = GitLabMrProvider::with_runner("owner/repo", runner.clone());
1312
1313 let _ = provider
1314 .merge(9, Some(MergeStrategy::Merge), false)
1315 .await
1316 .expect("should merge");
1317
1318 assert_eq!(
1319 runner.recorded_calls()[0].1,
1320 vec!["mr", "merge", "9", "--repo", "owner/repo"]
1321 .into_iter()
1322 .map(String::from)
1323 .collect::<Vec<_>>()
1324 );
1325 }
1326
1327 #[tokio::test]
1328 async fn test_should_forward_auto_merge_and_report_not_merged() {
1329 let runner = MockCommandRunner::success("");
1330 let provider = GitLabMrProvider::with_runner("owner/repo", runner.clone());
1331
1332 let result = provider
1333 .merge(9, None, true)
1334 .await
1335 .expect("should schedule merge");
1336
1337 assert_eq!(
1338 runner.recorded_calls()[0].1,
1339 vec!["mr", "merge", "9", "--repo", "owner/repo", "--auto-merge"]
1340 .into_iter()
1341 .map(String::from)
1342 .collect::<Vec<_>>()
1343 );
1344 assert!(
1345 !result.merged,
1346 "a scheduled merge has not landed, so merged must be false"
1347 );
1348 let message = result.message.unwrap_or_default();
1349 assert!(
1350 message.contains("排队"),
1351 "empty glab stdout must be replaced by a scheduled-merge message, got {message:?}"
1352 );
1353 }
1354
1355 #[tokio::test]
1356 async fn test_should_merge_without_strategy_flag() {
1357 let runner = MockCommandRunner::success("Merged!");
1358 let provider = GitLabMrProvider::with_runner("owner/repo", runner.clone());
1359
1360 let _ = provider.merge(9, None, false).await.expect("should merge");
1361
1362 assert_eq!(
1363 runner.recorded_calls()[0].1,
1364 vec!["mr", "merge", "9", "--repo", "owner/repo"]
1365 .into_iter()
1366 .map(String::from)
1367 .collect::<Vec<_>>()
1368 );
1369 }
1370
1371 #[tokio::test]
1372 async fn test_should_return_platform_error_when_glab_fails_for_checkout() {
1373 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1374 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1375
1376 let result = provider.checkout(42).await;
1377
1378 assert!(matches!(
1379 result.unwrap_err(),
1380 gitflow_core::CoreError::Cli(_)
1381 ));
1382 }
1383
1384 #[tokio::test]
1385 async fn test_should_return_platform_error_when_glab_fails_for_sync_branch() {
1386 let runner = MockCommandRunner::failure(r#"{"message": "Rebase failed"}"#, 256);
1387 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1388
1389 let result = provider.sync_branch(42).await;
1390
1391 assert!(matches!(
1392 result.unwrap_err(),
1393 gitflow_core::CoreError::Cli(_)
1394 ));
1395 }
1396
1397 #[tokio::test]
1398 async fn test_should_return_platform_error_when_glab_fails_for_mark_ready() {
1399 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1400 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1401
1402 let result = provider.mark_ready(42).await;
1403
1404 assert!(matches!(
1405 result.unwrap_err(),
1406 gitflow_core::CoreError::Cli(_)
1407 ));
1408 }
1409
1410 #[tokio::test]
1411 async fn test_should_return_platform_error_when_glab_fails_for_mark_wip() {
1412 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1413 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1414
1415 let result = provider.mark_wip(42).await;
1416
1417 assert!(matches!(
1418 result.unwrap_err(),
1419 gitflow_core::CoreError::Cli(_)
1420 ));
1421 }
1422
1423 #[tokio::test]
1424 async fn test_should_mark_ready_with_mr_update_draft_false() {
1425 let runner = MockCommandRunner::success("");
1426 let provider = GitLabMrProvider::with_runner("owner/repo", runner.clone());
1427 provider
1428 .run_mr_update(5, false)
1429 .await
1430 .expect("should succeed");
1431 assert_eq!(
1432 runner.recorded_calls()[0].1,
1433 vec!["mr", "update", "5", "--repo", "owner/repo", "--draft=false"]
1434 .into_iter()
1435 .map(String::from)
1436 .collect::<Vec<_>>()
1437 );
1438 }
1439
1440 #[tokio::test]
1441 async fn test_should_mark_wip_with_mr_update_draft_true() {
1442 let runner = MockCommandRunner::success("");
1443 let provider = GitLabMrProvider::with_runner("owner/repo", runner.clone());
1444 provider
1445 .run_mr_update(5, true)
1446 .await
1447 .expect("should succeed");
1448 assert_eq!(
1449 runner.recorded_calls()[0].1,
1450 vec!["mr", "update", "5", "--repo", "owner/repo", "--draft=true"]
1451 .into_iter()
1452 .map(String::from)
1453 .collect::<Vec<_>>()
1454 );
1455 }
1456
1457 #[tokio::test]
1458 async fn test_should_fail_when_mr_update_glab_fails() {
1459 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1460 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1461 let result = provider.run_mr_update(5, false).await;
1462 assert!(matches!(
1463 result.unwrap_err(),
1464 gitflow_core::CoreError::Cli(_)
1465 ));
1466 }
1467
1468 #[tokio::test]
1471 async fn test_should_fetch_mr_diff() {
1472 use gitflow_core::pr::PrProvider;
1473
1474 let diff_output = "diff --git a/src/lib.rs b/src/lib.rs\nindex 1234567..abcdefg \
1475 100644\n--- a/src/lib.rs\n+++ b/src/lib.rs\n@@ -1 +1 @@\n-old\n+new\n";
1476 let runner = MockCommandRunner::success(diff_output);
1477 let provider = GitLabMrProvider::with_runner("group/project", runner);
1478
1479 let result = provider.diff(42).await.expect("diff should succeed");
1480 assert_eq!(result, diff_output);
1481 }
1482
1483 #[tokio::test]
1484 async fn test_should_return_error_when_mr_diff_fails() {
1485 use gitflow_core::pr::PrProvider;
1486
1487 let runner = MockCommandRunner::failure(r#"{"message": "404 Not Found"}"#, 256);
1488 let provider = GitLabMrProvider::with_runner("group/project", runner);
1489
1490 let result = provider.diff(999).await;
1491 assert!(matches!(
1492 result.unwrap_err(),
1493 gitflow_core::CoreError::Cli(_)
1494 ));
1495 }
1496
1497 #[tokio::test]
1500 async fn test_should_fetch_mr_patch() {
1501 use gitflow_core::pr::PrProvider;
1502
1503 let patch_output =
1504 "From abc123\nSubject: [PATCH] Update file\n\ndiff --git a/src/lib.rs b/src/lib.rs\n";
1505 let runner = MockCommandRunner::success(patch_output);
1506 let provider = GitLabMrProvider::with_runner("group/project", runner);
1507
1508 let result = provider.patch(42).await.expect("patch should succeed");
1509 assert_eq!(result, patch_output);
1510 }
1511
1512 #[tokio::test]
1513 async fn test_should_return_error_when_mr_patch_fails() {
1514 use gitflow_core::pr::PrProvider;
1515
1516 let runner = MockCommandRunner::failure(r#"{"message": "404 Not Found"}"#, 256);
1517 let provider = GitLabMrProvider::with_runner("group/project", runner);
1518
1519 let result = provider.patch(999).await;
1520 assert!(matches!(
1521 result.unwrap_err(),
1522 gitflow_core::CoreError::Cli(_)
1523 ));
1524 }
1525
1526 #[tokio::test]
1529 async fn test_should_return_default_branch_on_success() {
1530 let runner = MockCommandRunner::success(r#"{"default_branch":"dev"}"#);
1531 let provider = GitLabMrProvider::with_runner("group/project", runner);
1532
1533 let result = provider.default_branch().await;
1534
1535 assert!(result.is_ok());
1536 assert_eq!(result.expect("already checked"), "dev");
1537 }
1538
1539 #[tokio::test]
1540 async fn test_should_use_repo_target_for_default_branch() {
1541 let runner = MockCommandRunner::success(r#"{"default_branch":"dev"}"#);
1542 let provider = GitLabMrProvider::with_runner_and_repo_target(
1543 "group/project",
1544 "https://gitlab.example.com/group/project.git",
1545 runner.clone(),
1546 );
1547
1548 let _ = provider.default_branch().await;
1549
1550 let calls = runner.recorded_calls();
1551 assert_eq!(calls[0].0, "glab");
1552 assert_eq!(
1553 calls[0].1,
1554 vec![
1555 "repo",
1556 "view",
1557 "--repo",
1558 "https://gitlab.example.com/group/project.git",
1559 "--output",
1560 "json",
1561 ]
1562 );
1563 }
1564
1565 #[tokio::test]
1566 async fn test_should_return_error_when_repo_view_fails() {
1567 let runner = MockCommandRunner::failure("glab: 404 Not Found", 1);
1568 let provider = GitLabMrProvider::with_runner("group/nonexistent", runner);
1569
1570 let result = provider.default_branch().await;
1571
1572 assert!(result.is_err());
1573 }
1574
1575 #[tokio::test]
1576 async fn test_should_walk_pages_for_mr_list() {
1577 let runner = MockCommandRunner::success("[]");
1578 let provider = GitLabMrProvider::with_runner("owner/repo", runner.clone());
1579 provider
1580 .list(ListPrArgs::default())
1581 .await
1582 .expect("list should succeed");
1583 let recorded = &runner.recorded_calls()[0].1;
1584 assert!(
1585 recorded
1586 .windows(2)
1587 .any(|w| w[0] == "--per-page" && w[1] == "100")
1588 );
1589 assert!(recorded.windows(2).any(|w| w[0] == "--page" && w[1] == "1"));
1590 }
1591
1592 #[tokio::test]
1593 async fn test_should_produce_complete_argv_for_mr_list_with_state() {
1594 let runner = MockCommandRunner::success("[]");
1595 let provider = GitLabMrProvider::with_runner("owner/repo", runner.clone());
1596 let args = ListPrArgs {
1597 state: Some(State::Open),
1598 ..ListPrArgs::default()
1599 };
1600 provider.list(args).await.expect("list should succeed");
1601 let recorded = &runner.recorded_calls()[0];
1602 assert_eq!(recorded.0, "glab");
1603 assert_eq!(
1604 recorded.1,
1605 vec![
1606 "mr",
1607 "list",
1608 "--repo",
1609 "owner/repo",
1610 "--output",
1611 "json",
1612 "--per-page",
1613 "100",
1614 "--page",
1615 "1",
1616 ]
1617 );
1618 }
1619
1620 const MILESTONE_LIST_JSON: &str = r#"[
1625 {"id": 30, "iid": 3, "title": "v2.0", "state": "active"}
1626 ]"#;
1627
1628 #[tokio::test]
1629 async fn test_should_wire_resolved_milestone_title_into_mr_create() {
1630 let runner = SequencedMockCommandRunner::from_results(&[
1636 (true, MILESTONE_LIST_JSON),
1637 (true, "http://192.168.230.23/owner/repo/-/merge_requests/12"),
1638 (
1639 true,
1640 r#"{"iid":12,"title":"Add feature","state":"opened","source_branch":"feature/x","target_branch":"main","milestone":{"id":30,"iid":3,"title":"v2.0","state":"active"}}"#,
1641 ),
1642 ]);
1643 let provider = GitLabMrProvider::with_runner("owner/repo", runner.clone());
1644
1645 let mut args = sample_create_args();
1646 args.milestone = Some("3".to_string()); let pr = provider.create(args).await.expect("create should succeed");
1649 assert_eq!(
1650 pr.milestone,
1651 Some(gitflow_core::types::MilestoneRef {
1652 number: 3,
1653 title: "v2.0".into()
1654 })
1655 );
1656
1657 let calls = runner.recorded_calls();
1658 assert_eq!(calls.len(), 3, "expected exactly 3 glab invocations");
1659 assert!(
1660 calls[0].1.first().map(String::as_str) == Some("milestone"),
1661 "first call must resolve the milestone via `glab milestone list`, got: {:?}",
1662 calls[0].1
1663 );
1664 let create_call = &calls[1].1;
1665 assert!(
1666 create_call
1667 .windows(2)
1668 .any(|w| w[0] == "--milestone" && w[1] == "v2.0"),
1669 "mr create argv must carry the resolved milestone title, got: {create_call:?}"
1670 );
1671 }
1672
1673 #[tokio::test]
1674 async fn test_should_propagate_error_when_milestone_identifier_not_found_on_mr_create() {
1675 let runner = SequencedMockCommandRunner::from_results(&[(true, MILESTONE_LIST_JSON)]);
1678 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
1679
1680 let mut args = sample_create_args();
1681 args.milestone = Some("does-not-exist".to_string());
1682
1683 let result = provider.create(args).await;
1684 assert!(result.is_err());
1685 }
1686
1687 #[tokio::test]
1695 async fn test_should_resolve_milestone_against_bare_repo_not_repo_target_for_mr_create() {
1696 let runner = SequencedMockCommandRunner::from_results(&[
1697 (true, MILESTONE_LIST_JSON),
1698 (true, "http://192.168.230.23/owner/repo/-/merge_requests/12"),
1699 (
1700 true,
1701 r#"{"iid":12,"title":"Feat","state":"opened","source_branch":"feat/x","target_branch":"main"}"#,
1702 ),
1703 ]);
1704 let provider = GitLabMrProvider::with_runner_and_repo_target(
1705 "owner/repo",
1706 "https://192.168.230.23/iproost/proxy/api-src.git",
1707 runner.clone(),
1708 );
1709
1710 let mut args = sample_create_args();
1711 args.milestone = Some("3".to_string());
1712 provider.create(args).await.expect("create should succeed");
1713
1714 let resolve_call = &runner.recorded_calls()[0].1;
1715 assert!(
1716 resolve_call.iter().any(|a| a == "owner/repo"),
1717 "milestone resolution must target the bare repo, got: {resolve_call:?}"
1718 );
1719 assert!(
1720 !resolve_call
1721 .iter()
1722 .any(|a| a.contains("192.168.230.23/iproost/proxy")),
1723 "milestone resolution must NOT use repo_target's remote URL, got: {resolve_call:?}"
1724 );
1725 }
1726}