1use async_trait::async_trait;
12use chrono::{DateTime, Utc};
13use gitflow_core::{
14 CoreError, Result,
15 pr::{CreatePrArgs, ListPrArgs, PrData, PrProvider},
16 types::{CommentData, MergeResult, MergeStrategy, State, UserSummary},
17};
18use serde::Deserialize;
19use tracing::debug;
20
21use crate::{
22 commit::encode_project_path,
23 error::parse_glab_error,
24 runner::{CommandRunner, RealCommandRunner},
25};
26
27#[derive(Debug, Clone)]
40pub struct GitLabMrProvider<R: CommandRunner = RealCommandRunner> {
41 repo: String,
43 runner: R,
45}
46
47impl GitLabMrProvider<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> GitLabMrProvider<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#[derive(Debug, Clone, Deserialize)]
78struct ApiUser {
79 username: String,
80 #[serde(default)]
81 id: u64,
82}
83
84impl From<&ApiUser> for UserSummary {
85 fn from(u: &ApiUser) -> Self {
86 Self {
87 login: u.username.clone(),
88 id: u.id.to_string(),
89 }
90 }
91}
92
93#[derive(Debug, Clone, Deserialize)]
95struct MrApiResponse {
96 iid: u64,
97 title: String,
98 #[serde(default)]
99 description: Option<String>,
100 state: String,
101 #[serde(default)]
102 draft: bool,
103 #[serde(default)]
104 author: Option<ApiUser>,
105 #[serde(default)]
106 source_branch: String,
107 #[serde(default)]
108 target_branch: String,
109 #[serde(default)]
110 created_at: Option<DateTime<Utc>>,
111 #[serde(default)]
112 updated_at: Option<DateTime<Utc>>,
113 #[serde(default)]
114 web_url: Option<String>,
115}
116
117impl From<MrApiResponse> for PrData {
118 fn from(api: MrApiResponse) -> Self {
119 let now = Utc::now();
120 let state = if api.state == "closed" || api.state == "merged" {
121 State::Closed
122 } else {
123 State::Open
124 };
125 let author = api.author.as_ref().map_or_else(
126 || UserSummary {
127 login: "unknown".into(),
128 id: "0".to_string(),
129 },
130 UserSummary::from,
131 );
132
133 Self {
134 number: api.iid,
135 title: api.title,
136 body: api.description,
137 state,
138 draft: api.draft,
139 author,
140 base_branch: api.target_branch,
141 head_branch: api.source_branch,
142 created_at: api.created_at.unwrap_or(now),
143 updated_at: api.updated_at.unwrap_or(now),
144 url: api.web_url.unwrap_or_default(),
145 }
146 }
147}
148
149#[derive(Debug, Clone, Deserialize)]
151struct CommentApiResponse {
152 id: u64,
153 #[serde(default)]
154 body: String,
155 #[serde(default)]
156 author: Option<ApiUser>,
157 #[serde(default)]
158 created_at: Option<DateTime<Utc>>,
159}
160
161impl From<CommentApiResponse> for CommentData {
162 fn from(api: CommentApiResponse) -> Self {
163 let author = api.author.as_ref().map_or_else(
164 || UserSummary {
165 login: "unknown".into(),
166 id: "0".to_string(),
167 },
168 UserSummary::from,
169 );
170 Self {
171 id: api.id,
172 body: api.body,
173 author,
174 created_at: api.created_at.unwrap_or_else(Utc::now),
175 }
176 }
177}
178
179#[async_trait]
182impl<R: CommandRunner + 'static> PrProvider for GitLabMrProvider<R> {
183 async fn create(&self, args: CreatePrArgs) -> Result<PrData> {
184 let repo = args.repo.as_deref().unwrap_or(&self.repo);
185 let mut cmd_args: Vec<&str> = vec![
186 "mr",
187 "create",
188 "--repo",
189 repo,
190 "--title",
191 &args.title,
192 "--source-branch",
193 &args.head,
194 "--target-branch",
195 &args.base,
196 "--output",
197 "json",
198 ];
199
200 if let Some(body) = &args.body {
201 cmd_args.push("--description");
202 cmd_args.push(body);
203 }
204
205 if args.draft {
206 cmd_args.push("--draft");
207 }
208
209 debug!(
210 repo = %self.repo,
211 title = %args.title,
212 head = %args.head,
213 base = %args.base,
214 "spawning `glab mr create`"
215 );
216
217 let output = self
218 .runner
219 .run("glab", &cmd_args)
220 .await
221 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
222
223 if !output.status.success() {
224 return Err(parse_glab_error(&output.stderr).into());
225 }
226
227 let api_response: MrApiResponse =
228 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
229
230 Ok(api_response.into())
231 }
232
233 async fn list(&self, args: ListPrArgs) -> Result<Vec<PrData>> {
234 let mut cmd_args: Vec<&str> = vec!["mr", "list", "--repo", &self.repo, "--output", "json"];
235
236 if let Some(state) = &args.state
239 && matches!(state, State::Closed)
240 {
241 cmd_args.push("--closed");
242 }
243
244 let limit_str = args.limit.map(|limit| limit.to_string());
245 if let Some(ref limit) = limit_str {
246 cmd_args.push("--per-page");
247 cmd_args.push(limit);
248 }
249
250 debug!(repo = %self.repo, "spawning `glab mr list`");
251
252 let output = self
253 .runner
254 .run("glab", &cmd_args)
255 .await
256 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
257
258 if !output.status.success() {
259 return Err(parse_glab_error(&output.stderr).into());
260 }
261
262 let api_responses: Vec<MrApiResponse> =
263 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
264
265 Ok(api_responses.into_iter().map(PrData::from).collect())
266 }
267
268 async fn view(&self, number: u64) -> Result<PrData> {
269 debug!(repo = %self.repo, number, "spawning `glab mr view`");
270
271 let number_str = number.to_string();
272 let output = self
273 .runner
274 .run(
275 "glab",
276 &[
277 "mr",
278 "view",
279 &number_str,
280 "--repo",
281 &self.repo,
282 "--output",
283 "json",
284 ],
285 )
286 .await
287 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
288
289 if !output.status.success() {
290 return Err(parse_glab_error(&output.stderr).into());
291 }
292
293 let api_response: MrApiResponse =
294 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
295
296 Ok(api_response.into())
297 }
298
299 async fn close(&self, number: u64) -> Result<PrData> {
300 debug!(repo = %self.repo, number, "spawning `glab mr close`");
301
302 let number_str = number.to_string();
303 let output = self
304 .runner
305 .run(
306 "glab",
307 &[
308 "mr",
309 "close",
310 &number_str,
311 "--repo",
312 &self.repo,
313 "--output",
314 "json",
315 ],
316 )
317 .await
318 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
319
320 if !output.status.success() {
321 return Err(parse_glab_error(&output.stderr).into());
322 }
323
324 let api_response: MrApiResponse =
325 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
326
327 Ok(api_response.into())
328 }
329
330 async fn reopen(&self, number: u64) -> Result<PrData> {
331 debug!(repo = %self.repo, number, "spawning `glab mr reopen`");
332
333 let number_str = number.to_string();
334 let output = self
335 .runner
336 .run(
337 "glab",
338 &[
339 "mr",
340 "reopen",
341 &number_str,
342 "--repo",
343 &self.repo,
344 "--output",
345 "json",
346 ],
347 )
348 .await
349 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
350
351 if !output.status.success() {
352 return Err(parse_glab_error(&output.stderr).into());
353 }
354
355 let api_response: MrApiResponse =
356 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
357
358 Ok(api_response.into())
359 }
360
361 async fn comment(&self, number: u64, body: &str) -> Result<CommentData> {
362 debug!(repo = %self.repo, number, "spawning `glab mr note`");
363
364 let number_str = number.to_string();
365 let output = self
366 .runner
367 .run(
368 "glab",
369 &[
370 "mr",
371 "note",
372 &number_str,
373 "--repo",
374 &self.repo,
375 "--body",
376 body,
377 "--output",
378 "json",
379 ],
380 )
381 .await
382 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
383
384 if !output.status.success() {
385 return Err(parse_glab_error(&output.stderr).into());
386 }
387
388 let api_response: CommentApiResponse =
389 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
390
391 Ok(api_response.into())
392 }
393
394 async fn merge(&self, number: u64, strategy: Option<MergeStrategy>) -> Result<MergeResult> {
395 debug!(repo = %self.repo, number, ?strategy, "spawning `glab mr merge`");
396
397 let number_str = number.to_string();
398 let mut cmd_args: Vec<&str> = vec!["mr", "merge", &number_str, "--repo", &self.repo];
399
400 match strategy {
401 Some(MergeStrategy::Squash) => cmd_args.push("--squash"),
402 Some(MergeStrategy::Rebase) => cmd_args.push("--rebase"),
403 Some(MergeStrategy::Merge) | None => cmd_args.push("--merge"),
404 }
405
406 let output = self
407 .runner
408 .run("glab", &cmd_args)
409 .await
410 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
411
412 if !output.status.success() {
413 return Err(parse_glab_error(&output.stderr).into());
414 }
415
416 let message = String::from_utf8_lossy(&output.stdout).trim().to_string();
417 Ok(MergeResult {
418 merged: true,
419 sha: None,
420 message: Some(message),
421 })
422 }
423
424 async fn checkout(&self, number: u64) -> Result<()> {
425 debug!(repo = %self.repo, number, "spawning `glab mr checkout`");
426
427 let number_str = number.to_string();
428 let output = self
429 .runner
430 .run(
431 "glab",
432 &["mr", "checkout", &number_str, "--repo", &self.repo],
433 )
434 .await
435 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
436
437 if !output.status.success() {
438 return Err(parse_glab_error(&output.stderr).into());
439 }
440
441 Ok(())
442 }
443
444 async fn mark_ready(&self, number: u64) -> Result<PrData> {
445 debug!(repo = %self.repo, number, "spawning `glab mr ready`");
446
447 let number_str = number.to_string();
448 let output = self
449 .runner
450 .run("glab", &["mr", "ready", &number_str, "--repo", &self.repo])
451 .await
452 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
453
454 if !output.status.success() {
455 return Err(parse_glab_error(&output.stderr).into());
456 }
457
458 self.view(number).await
459 }
460
461 async fn mark_wip(&self, number: u64) -> Result<PrData> {
462 debug!(repo = %self.repo, number, "spawning `glab mr draft`");
463
464 let number_str = number.to_string();
465 let output = self
466 .runner
467 .run("glab", &["mr", "draft", &number_str, "--repo", &self.repo])
468 .await
469 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
470
471 if !output.status.success() {
472 return Err(parse_glab_error(&output.stderr).into());
473 }
474
475 self.view(number).await
476 }
477
478 async fn sync_branch(&self, number: u64) -> Result<()> {
479 debug!(repo = %self.repo, number, "spawning `glab mr rebase`");
480
481 let number_str = number.to_string();
482 let output = self
483 .runner
484 .run("glab", &["mr", "rebase", &number_str, "--repo", &self.repo])
485 .await
486 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
487
488 if !output.status.success() {
489 return Err(parse_glab_error(&output.stderr).into());
490 }
491
492 Ok(())
493 }
494
495 async fn diff(&self, number: u64) -> Result<String> {
503 debug!(repo = %self.repo, number, "spawning `glab mr diff`");
504
505 let number_str = number.to_string();
506 let output = self
507 .runner
508 .run("glab", &["mr", "diff", &number_str])
509 .await
510 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab mr diff: {e}")))?;
511
512 if !output.status.success() {
513 return Err(parse_glab_error(&output.stderr).into());
514 }
515
516 Ok(String::from_utf8_lossy(&output.stdout).into_owned())
517 }
518
519 async fn patch(&self, number: u64) -> Result<String> {
528 debug!(repo = %self.repo, number, "spawning `glab api mr patch`");
529
530 let encoded_path = encode_project_path(&self.repo);
531 let api_path = format!("projects/{encoded_path}/merge_requests/{number}.patch");
532
533 let output = self
534 .runner
535 .run("glab", &["api", &api_path])
536 .await
537 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab api mr patch: {e}")))?;
538
539 if !output.status.success() {
540 return Err(parse_glab_error(&output.stderr).into());
541 }
542
543 Ok(String::from_utf8_lossy(&output.stdout).into_owned())
544 }
545}
546
547#[cfg(test)]
548mod tests {
549 use super::*;
550 use crate::runner::MockCommandRunner;
551
552 #[test]
553 fn test_should_construct_gitlab_mr_provider() {
554 let provider = GitLabMrProvider::new("gitlab-org/gitlab");
555 assert_eq!(provider.repo, "gitlab-org/gitlab");
556 }
557
558 #[test]
559 fn test_should_construct_gitlab_mr_provider_from_string() {
560 let repo = String::from("gitlab-org/gitlab");
561 let provider = GitLabMrProvider::new(repo);
562 assert_eq!(provider.repo, "gitlab-org/gitlab");
563 }
564
565 #[test]
566 fn test_should_deserialize_mr_api_response() {
567 let json = br#"{
568 "iid": 123,
569 "title": "Add new feature",
570 "description": "This MR adds a new feature",
571 "state": "opened",
572 "draft": false,
573 "author": {"username": "alice", "id": 2},
574 "source_branch": "feature/new-thing",
575 "target_branch": "main",
576 "created_at": "2026-02-20T14:00:00Z",
577 "updated_at": "2026-02-21T10:30:00Z",
578 "web_url": "https://gitlab.com/gitlab-org/gitlab/-/merge_requests/123"
579 }"#;
580
581 let api: MrApiResponse = serde_json::from_slice(json).expect("valid MrApiResponse");
582 let pr: PrData = api.into();
583
584 assert_eq!(pr.number, 123);
585 assert_eq!(pr.title, "Add new feature");
586 assert_eq!(pr.state, State::Open);
587 assert!(!pr.draft);
588 assert_eq!(pr.author.login, "alice");
589 assert_eq!(pr.base_branch, "main");
590 assert_eq!(pr.head_branch, "feature/new-thing");
591 assert_eq!(
592 pr.url,
593 "https://gitlab.com/gitlab-org/gitlab/-/merge_requests/123"
594 );
595 }
596
597 #[test]
598 fn test_should_deserialize_draft_mr() {
599 let json = br#"{
600 "iid": 456,
601 "title": "WIP: experiment",
602 "description": null,
603 "state": "opened",
604 "draft": true,
605 "author": {"username": "bob", "id": 3},
606 "source_branch": "wip/experiment",
607 "target_branch": "main",
608 "created_at": "2026-03-10T09:00:00Z",
609 "updated_at": "2026-03-10T09:00:00Z",
610 "web_url": "https://gitlab.com/org/project/-/merge_requests/456"
611 }"#;
612
613 let api: MrApiResponse = serde_json::from_slice(json).expect("valid MrApiResponse");
614 let pr: PrData = api.into();
615 assert!(pr.draft);
616 assert!(pr.body.is_none());
617 }
618
619 #[test]
620 fn test_should_deserialize_merged_mr_as_closed() {
621 let json = br#"{
622 "iid": 789,
623 "title": "Merged feature",
624 "description": null,
625 "state": "merged",
626 "draft": false,
627 "author": {"username": "dev", "id": 1},
628 "source_branch": "feature/done",
629 "target_branch": "main",
630 "created_at": "2026-01-01T00:00:00Z",
631 "updated_at": "2026-01-02T00:00:00Z",
632 "web_url": "https://gitlab.com/org/project/-/merge_requests/789"
633 }"#;
634
635 let api: MrApiResponse = serde_json::from_slice(json).expect("valid MrApiResponse");
636 let pr: PrData = api.into();
637 assert_eq!(pr.state, State::Closed);
638 }
639
640 #[test]
641 fn test_should_deserialize_empty_mr_list() {
642 let json = b"[]";
643 let list: Vec<MrApiResponse> = serde_json::from_slice(json).expect("valid empty list");
644 assert!(list.is_empty());
645 }
646
647 #[test]
648 fn test_should_deserialize_comment_api_response() {
649 let json = br#"{
650 "id": 2002,
651 "body": "Approved, merging now.",
652 "author": {"username": "reviewer", "id": 88},
653 "created_at": "2026-06-20T16:00:00Z"
654 }"#;
655
656 let api: CommentApiResponse =
657 serde_json::from_slice(json).expect("valid CommentApiResponse");
658 let comment: CommentData = api.into();
659 assert_eq!(comment.id, 2002);
660 assert_eq!(comment.body, "Approved, merging now.");
661 assert_eq!(comment.author.login, "reviewer");
662 }
663
664 #[test]
665 fn test_should_roundtrip_merge_result_via_serde() {
666 let result = MergeResult {
667 merged: true,
668 sha: Some("deadbeef1234".into()),
669 message: Some("Squash merged".into()),
670 };
671 let json = serde_json::to_string(&result).expect("serialize");
672 let round_tripped: MergeResult = serde_json::from_str(&json).expect("deserialize");
673 assert!(round_tripped.merged);
674 assert_eq!(round_tripped.sha, result.sha);
675 }
676
677 #[test]
678 fn test_should_debug_format_provider() {
679 let provider = GitLabMrProvider::new("gitlab-org/gitlab");
680 let debug = format!("{provider:?}");
681 assert!(debug.contains("GitLabMrProvider"));
682 assert!(debug.contains("gitlab-org/gitlab"));
683 }
684
685 #[test]
686 fn test_should_clone_gitlab_mr_provider() {
687 let original = GitLabMrProvider::new("owner/repo");
688 let cloned = original.clone();
689 assert_eq!(original.repo, cloned.repo);
690 }
691
692 #[test]
693 fn test_should_handle_missing_author_with_fallback() {
694 let json = br#"{
695 "iid": 1,
696 "title": "No author",
697 "description": null,
698 "state": "opened",
699 "draft": false,
700 "author": null,
701 "source_branch": "dev",
702 "target_branch": "main",
703 "created_at": null,
704 "updated_at": null,
705 "web_url": null
706 }"#;
707
708 let api: MrApiResponse = serde_json::from_slice(json).expect("valid MrApiResponse");
709 let pr: PrData = api.into();
710 assert_eq!(pr.author.login, "unknown");
711 }
712
713 fn sample_create_args() -> CreatePrArgs {
716 CreatePrArgs {
717 title: "Add feature".to_string(),
718 body: Some("Description".to_string()),
719 head: "feature/x".to_string(),
720 base: "main".to_string(),
721 draft: false,
722 repo: None,
723 }
724 }
725
726 #[tokio::test]
727 async fn test_should_return_platform_error_when_glab_fails_for_create() {
728 let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
729 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
730
731 let result = provider.create(sample_create_args()).await;
732
733 assert!(matches!(
734 result.unwrap_err(),
735 gitflow_core::CoreError::Cli(_)
736 ));
737 }
738
739 #[tokio::test]
740 async fn test_should_return_serialization_error_on_invalid_json_for_create() {
741 let runner = MockCommandRunner::success("not valid json");
742 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
743
744 let result = provider.create(sample_create_args()).await;
745
746 assert!(matches!(
747 result.unwrap_err(),
748 gitflow_core::CoreError::Serialization(_)
749 ));
750 }
751
752 #[tokio::test]
753 async fn test_should_return_platform_error_when_glab_fails_for_list() {
754 let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
755 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
756
757 let result = provider.list(ListPrArgs::default()).await;
758
759 assert!(matches!(
760 result.unwrap_err(),
761 gitflow_core::CoreError::Cli(_)
762 ));
763 }
764
765 #[tokio::test]
766 async fn test_should_return_serialization_error_on_invalid_json_for_list() {
767 let runner = MockCommandRunner::success("invalid");
768 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
769
770 let result = provider.list(ListPrArgs::default()).await;
771
772 assert!(matches!(
773 result.unwrap_err(),
774 gitflow_core::CoreError::Serialization(_)
775 ));
776 }
777
778 #[tokio::test]
779 async fn test_should_return_platform_error_when_glab_fails_for_view() {
780 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
781 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
782
783 let result = provider.view(999).await;
784
785 assert!(matches!(
786 result.unwrap_err(),
787 gitflow_core::CoreError::Cli(_)
788 ));
789 }
790
791 #[tokio::test]
792 async fn test_should_return_serialization_error_on_invalid_json_for_view() {
793 let runner = MockCommandRunner::success("not valid json");
794 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
795
796 let result = provider.view(1).await;
797
798 assert!(matches!(
799 result.unwrap_err(),
800 gitflow_core::CoreError::Serialization(_)
801 ));
802 }
803
804 #[tokio::test]
805 async fn test_should_return_platform_error_when_glab_fails_for_close() {
806 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
807 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
808
809 let result = provider.close(42).await;
810
811 assert!(matches!(
812 result.unwrap_err(),
813 gitflow_core::CoreError::Cli(_)
814 ));
815 }
816
817 #[tokio::test]
818 async fn test_should_return_platform_error_when_glab_fails_for_reopen() {
819 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
820 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
821
822 let result = provider.reopen(42).await;
823
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_glab_fails_for_comment() {
832 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
833 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
834
835 let result = provider.comment(42, "a comment").await;
836
837 assert!(matches!(
838 result.unwrap_err(),
839 gitflow_core::CoreError::Cli(_)
840 ));
841 }
842
843 #[tokio::test]
844 async fn test_should_return_platform_error_when_glab_fails_for_merge() {
845 let runner = MockCommandRunner::failure(r#"{"message": "Not mergeable"}"#, 256);
846 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
847
848 let result = provider.merge(42, None).await;
849
850 assert!(matches!(
851 result.unwrap_err(),
852 gitflow_core::CoreError::Cli(_)
853 ));
854 }
855
856 #[tokio::test]
857 async fn test_should_return_platform_error_when_glab_fails_for_checkout() {
858 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
859 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
860
861 let result = provider.checkout(42).await;
862
863 assert!(matches!(
864 result.unwrap_err(),
865 gitflow_core::CoreError::Cli(_)
866 ));
867 }
868
869 #[tokio::test]
870 async fn test_should_return_platform_error_when_glab_fails_for_sync_branch() {
871 let runner = MockCommandRunner::failure(r#"{"message": "Rebase failed"}"#, 256);
872 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
873
874 let result = provider.sync_branch(42).await;
875
876 assert!(matches!(
877 result.unwrap_err(),
878 gitflow_core::CoreError::Cli(_)
879 ));
880 }
881
882 #[tokio::test]
883 async fn test_should_return_platform_error_when_glab_fails_for_mark_ready() {
884 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
885 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
886
887 let result = provider.mark_ready(42).await;
888
889 assert!(matches!(
890 result.unwrap_err(),
891 gitflow_core::CoreError::Cli(_)
892 ));
893 }
894
895 #[tokio::test]
896 async fn test_should_return_platform_error_when_glab_fails_for_mark_wip() {
897 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
898 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
899
900 let result = provider.mark_wip(42).await;
901
902 assert!(matches!(
903 result.unwrap_err(),
904 gitflow_core::CoreError::Cli(_)
905 ));
906 }
907
908 #[tokio::test]
911 async fn test_should_fetch_mr_diff() {
912 use gitflow_core::pr::PrProvider;
913
914 let diff_output = "diff --git a/src/lib.rs b/src/lib.rs\nindex 1234567..abcdefg \
915 100644\n--- a/src/lib.rs\n+++ b/src/lib.rs\n@@ -1 +1 @@\n-old\n+new\n";
916 let runner = MockCommandRunner::success(diff_output);
917 let provider = GitLabMrProvider::with_runner("group/project", runner);
918
919 let result = provider.diff(42).await.expect("diff should succeed");
920 assert_eq!(result, diff_output);
921 }
922
923 #[tokio::test]
924 async fn test_should_return_error_when_mr_diff_fails() {
925 use gitflow_core::pr::PrProvider;
926
927 let runner = MockCommandRunner::failure(r#"{"message": "404 Not Found"}"#, 256);
928 let provider = GitLabMrProvider::with_runner("group/project", runner);
929
930 let result = provider.diff(999).await;
931 assert!(matches!(
932 result.unwrap_err(),
933 gitflow_core::CoreError::Cli(_)
934 ));
935 }
936
937 #[tokio::test]
940 async fn test_should_fetch_mr_patch() {
941 use gitflow_core::pr::PrProvider;
942
943 let patch_output =
944 "From abc123\nSubject: [PATCH] Update file\n\ndiff --git a/src/lib.rs b/src/lib.rs\n";
945 let runner = MockCommandRunner::success(patch_output);
946 let provider = GitLabMrProvider::with_runner("group/project", runner);
947
948 let result = provider.patch(42).await.expect("patch should succeed");
949 assert_eq!(result, patch_output);
950 }
951
952 #[tokio::test]
953 async fn test_should_return_error_when_mr_patch_fails() {
954 use gitflow_core::pr::PrProvider;
955
956 let runner = MockCommandRunner::failure(r#"{"message": "404 Not Found"}"#, 256);
957 let provider = GitLabMrProvider::with_runner("group/project", runner);
958
959 let result = provider.patch(999).await;
960 assert!(matches!(
961 result.unwrap_err(),
962 gitflow_core::CoreError::Cli(_)
963 ));
964 }
965}