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 error::parse_glab_error,
23 runner::{CommandRunner, RealCommandRunner},
24};
25
26#[derive(Debug, Clone)]
39pub struct GitLabMrProvider<R: CommandRunner = RealCommandRunner> {
40 repo: String,
42 runner: R,
44}
45
46impl GitLabMrProvider<RealCommandRunner> {
47 #[must_use]
51 pub fn new(repo: impl Into<String>) -> Self {
52 Self {
53 repo: repo.into(),
54 runner: RealCommandRunner,
55 }
56 }
57}
58
59impl<R: CommandRunner> GitLabMrProvider<R> {
60 #[must_use]
65 pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
66 Self {
67 repo: repo.into(),
68 runner,
69 }
70 }
71}
72
73#[derive(Debug, Clone, Deserialize)]
77struct ApiUser {
78 username: String,
79 #[serde(default)]
80 id: u64,
81}
82
83impl From<&ApiUser> for UserSummary {
84 fn from(u: &ApiUser) -> Self {
85 Self {
86 login: u.username.clone(),
87 id: u.id.to_string(),
88 }
89 }
90}
91
92#[derive(Debug, Clone, Deserialize)]
94struct MrApiResponse {
95 iid: u64,
96 title: String,
97 #[serde(default)]
98 description: Option<String>,
99 state: String,
100 #[serde(default)]
101 draft: bool,
102 #[serde(default)]
103 author: Option<ApiUser>,
104 #[serde(default)]
105 source_branch: String,
106 #[serde(default)]
107 target_branch: String,
108 #[serde(default)]
109 created_at: Option<DateTime<Utc>>,
110 #[serde(default)]
111 updated_at: Option<DateTime<Utc>>,
112 #[serde(default)]
113 web_url: Option<String>,
114}
115
116impl From<MrApiResponse> for PrData {
117 fn from(api: MrApiResponse) -> Self {
118 let now = Utc::now();
119 let state = if api.state == "closed" || api.state == "merged" {
120 State::Closed
121 } else {
122 State::Open
123 };
124 let author = api.author.as_ref().map_or_else(
125 || UserSummary {
126 login: "unknown".into(),
127 id: "0".to_string(),
128 },
129 UserSummary::from,
130 );
131
132 Self {
133 number: api.iid,
134 title: api.title,
135 body: api.description,
136 state,
137 draft: api.draft,
138 author,
139 base_branch: api.target_branch,
140 head_branch: api.source_branch,
141 created_at: api.created_at.unwrap_or(now),
142 updated_at: api.updated_at.unwrap_or(now),
143 url: api.web_url.unwrap_or_default(),
144 }
145 }
146}
147
148#[derive(Debug, Clone, Deserialize)]
150struct CommentApiResponse {
151 id: u64,
152 #[serde(default)]
153 body: String,
154 #[serde(default)]
155 author: Option<ApiUser>,
156 #[serde(default)]
157 created_at: Option<DateTime<Utc>>,
158}
159
160impl From<CommentApiResponse> for CommentData {
161 fn from(api: CommentApiResponse) -> Self {
162 let author = api.author.as_ref().map_or_else(
163 || UserSummary {
164 login: "unknown".into(),
165 id: "0".to_string(),
166 },
167 UserSummary::from,
168 );
169 Self {
170 id: api.id,
171 body: api.body,
172 author,
173 created_at: api.created_at.unwrap_or_else(Utc::now),
174 }
175 }
176}
177
178#[async_trait]
181impl<R: CommandRunner + 'static> PrProvider for GitLabMrProvider<R> {
182 async fn create(&self, args: CreatePrArgs) -> Result<PrData> {
183 let repo = args.repo.as_deref().unwrap_or(&self.repo);
184 let mut cmd_args: Vec<&str> = vec![
185 "mr",
186 "create",
187 "--repo",
188 repo,
189 "--title",
190 &args.title,
191 "--source-branch",
192 &args.head,
193 "--target-branch",
194 &args.base,
195 "--output",
196 "json",
197 ];
198
199 if let Some(body) = &args.body {
200 cmd_args.push("--description");
201 cmd_args.push(body);
202 }
203
204 if args.draft {
205 cmd_args.push("--draft");
206 }
207
208 debug!(
209 repo = %self.repo,
210 title = %args.title,
211 head = %args.head,
212 base = %args.base,
213 "spawning `glab mr create`"
214 );
215
216 let output = self
217 .runner
218 .run("glab", &cmd_args)
219 .await
220 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
221
222 if !output.status.success() {
223 return Err(parse_glab_error(&output.stderr).into());
224 }
225
226 let api_response: MrApiResponse =
227 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
228
229 Ok(api_response.into())
230 }
231
232 async fn list(&self, args: ListPrArgs) -> Result<Vec<PrData>> {
233 let mut cmd_args: Vec<&str> = vec!["mr", "list", "--repo", &self.repo, "--output", "json"];
234
235 if let Some(state) = &args.state
238 && matches!(state, State::Closed)
239 {
240 cmd_args.push("--closed");
241 }
242
243 let limit_str = args.limit.map(|limit| limit.to_string());
244 if let Some(ref limit) = limit_str {
245 cmd_args.push("--per-page");
246 cmd_args.push(limit);
247 }
248
249 debug!(repo = %self.repo, "spawning `glab mr list`");
250
251 let output = self
252 .runner
253 .run("glab", &cmd_args)
254 .await
255 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
256
257 if !output.status.success() {
258 return Err(parse_glab_error(&output.stderr).into());
259 }
260
261 let api_responses: Vec<MrApiResponse> =
262 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
263
264 Ok(api_responses.into_iter().map(PrData::from).collect())
265 }
266
267 async fn view(&self, number: u64) -> Result<PrData> {
268 debug!(repo = %self.repo, number, "spawning `glab mr view`");
269
270 let number_str = number.to_string();
271 let output = self
272 .runner
273 .run(
274 "glab",
275 &[
276 "mr",
277 "view",
278 &number_str,
279 "--repo",
280 &self.repo,
281 "--output",
282 "json",
283 ],
284 )
285 .await
286 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
287
288 if !output.status.success() {
289 return Err(parse_glab_error(&output.stderr).into());
290 }
291
292 let api_response: MrApiResponse =
293 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
294
295 Ok(api_response.into())
296 }
297
298 async fn close(&self, number: u64) -> Result<PrData> {
299 debug!(repo = %self.repo, number, "spawning `glab mr close`");
300
301 let number_str = number.to_string();
302 let output = self
303 .runner
304 .run(
305 "glab",
306 &[
307 "mr",
308 "close",
309 &number_str,
310 "--repo",
311 &self.repo,
312 "--output",
313 "json",
314 ],
315 )
316 .await
317 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
318
319 if !output.status.success() {
320 return Err(parse_glab_error(&output.stderr).into());
321 }
322
323 let api_response: MrApiResponse =
324 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
325
326 Ok(api_response.into())
327 }
328
329 async fn reopen(&self, number: u64) -> Result<PrData> {
330 debug!(repo = %self.repo, number, "spawning `glab mr reopen`");
331
332 let number_str = number.to_string();
333 let output = self
334 .runner
335 .run(
336 "glab",
337 &[
338 "mr",
339 "reopen",
340 &number_str,
341 "--repo",
342 &self.repo,
343 "--output",
344 "json",
345 ],
346 )
347 .await
348 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
349
350 if !output.status.success() {
351 return Err(parse_glab_error(&output.stderr).into());
352 }
353
354 let api_response: MrApiResponse =
355 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
356
357 Ok(api_response.into())
358 }
359
360 async fn comment(&self, number: u64, body: &str) -> Result<CommentData> {
361 debug!(repo = %self.repo, number, "spawning `glab mr note`");
362
363 let number_str = number.to_string();
364 let output = self
365 .runner
366 .run(
367 "glab",
368 &[
369 "mr",
370 "note",
371 &number_str,
372 "--repo",
373 &self.repo,
374 "--body",
375 body,
376 "--output",
377 "json",
378 ],
379 )
380 .await
381 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
382
383 if !output.status.success() {
384 return Err(parse_glab_error(&output.stderr).into());
385 }
386
387 let api_response: CommentApiResponse =
388 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
389
390 Ok(api_response.into())
391 }
392
393 async fn merge(&self, number: u64, strategy: Option<MergeStrategy>) -> Result<MergeResult> {
394 debug!(repo = %self.repo, number, ?strategy, "spawning `glab mr merge`");
395
396 let number_str = number.to_string();
397 let mut cmd_args: Vec<&str> = vec!["mr", "merge", &number_str, "--repo", &self.repo];
398
399 match strategy {
400 Some(MergeStrategy::Squash) => cmd_args.push("--squash"),
401 Some(MergeStrategy::Rebase) => cmd_args.push("--rebase"),
402 Some(MergeStrategy::Merge) | None => cmd_args.push("--merge"),
403 }
404
405 let output = self
406 .runner
407 .run("glab", &cmd_args)
408 .await
409 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
410
411 if !output.status.success() {
412 return Err(parse_glab_error(&output.stderr).into());
413 }
414
415 let message = String::from_utf8_lossy(&output.stdout).trim().to_string();
416 Ok(MergeResult {
417 merged: true,
418 sha: None,
419 message: Some(message),
420 })
421 }
422
423 async fn checkout(&self, number: u64) -> Result<()> {
424 debug!(repo = %self.repo, number, "spawning `glab mr checkout`");
425
426 let number_str = number.to_string();
427 let output = self
428 .runner
429 .run(
430 "glab",
431 &["mr", "checkout", &number_str, "--repo", &self.repo],
432 )
433 .await
434 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
435
436 if !output.status.success() {
437 return Err(parse_glab_error(&output.stderr).into());
438 }
439
440 Ok(())
441 }
442
443 async fn mark_ready(&self, number: u64) -> Result<PrData> {
444 debug!(repo = %self.repo, number, "spawning `glab mr ready`");
445
446 let number_str = number.to_string();
447 let output = self
448 .runner
449 .run("glab", &["mr", "ready", &number_str, "--repo", &self.repo])
450 .await
451 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
452
453 if !output.status.success() {
454 return Err(parse_glab_error(&output.stderr).into());
455 }
456
457 self.view(number).await
458 }
459
460 async fn mark_wip(&self, number: u64) -> Result<PrData> {
461 debug!(repo = %self.repo, number, "spawning `glab mr draft`");
462
463 let number_str = number.to_string();
464 let output = self
465 .runner
466 .run("glab", &["mr", "draft", &number_str, "--repo", &self.repo])
467 .await
468 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
469
470 if !output.status.success() {
471 return Err(parse_glab_error(&output.stderr).into());
472 }
473
474 self.view(number).await
475 }
476
477 async fn sync_branch(&self, number: u64) -> Result<()> {
478 debug!(repo = %self.repo, number, "spawning `glab mr rebase`");
479
480 let number_str = number.to_string();
481 let output = self
482 .runner
483 .run("glab", &["mr", "rebase", &number_str, "--repo", &self.repo])
484 .await
485 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
486
487 if !output.status.success() {
488 return Err(parse_glab_error(&output.stderr).into());
489 }
490
491 Ok(())
492 }
493}
494
495#[cfg(test)]
496mod tests {
497 use super::*;
498 use crate::runner::MockCommandRunner;
499
500 #[test]
501 fn test_should_construct_gitlab_mr_provider() {
502 let provider = GitLabMrProvider::new("gitlab-org/gitlab");
503 assert_eq!(provider.repo, "gitlab-org/gitlab");
504 }
505
506 #[test]
507 fn test_should_construct_gitlab_mr_provider_from_string() {
508 let repo = String::from("gitlab-org/gitlab");
509 let provider = GitLabMrProvider::new(repo);
510 assert_eq!(provider.repo, "gitlab-org/gitlab");
511 }
512
513 #[test]
514 fn test_should_deserialize_mr_api_response() {
515 let json = br#"{
516 "iid": 123,
517 "title": "Add new feature",
518 "description": "This MR adds a new feature",
519 "state": "opened",
520 "draft": false,
521 "author": {"username": "alice", "id": 2},
522 "source_branch": "feature/new-thing",
523 "target_branch": "main",
524 "created_at": "2026-02-20T14:00:00Z",
525 "updated_at": "2026-02-21T10:30:00Z",
526 "web_url": "https://gitlab.com/gitlab-org/gitlab/-/merge_requests/123"
527 }"#;
528
529 let api: MrApiResponse = serde_json::from_slice(json).expect("valid MrApiResponse");
530 let pr: PrData = api.into();
531
532 assert_eq!(pr.number, 123);
533 assert_eq!(pr.title, "Add new feature");
534 assert_eq!(pr.state, State::Open);
535 assert!(!pr.draft);
536 assert_eq!(pr.author.login, "alice");
537 assert_eq!(pr.base_branch, "main");
538 assert_eq!(pr.head_branch, "feature/new-thing");
539 assert_eq!(
540 pr.url,
541 "https://gitlab.com/gitlab-org/gitlab/-/merge_requests/123"
542 );
543 }
544
545 #[test]
546 fn test_should_deserialize_draft_mr() {
547 let json = br#"{
548 "iid": 456,
549 "title": "WIP: experiment",
550 "description": null,
551 "state": "opened",
552 "draft": true,
553 "author": {"username": "bob", "id": 3},
554 "source_branch": "wip/experiment",
555 "target_branch": "main",
556 "created_at": "2026-03-10T09:00:00Z",
557 "updated_at": "2026-03-10T09:00:00Z",
558 "web_url": "https://gitlab.com/org/project/-/merge_requests/456"
559 }"#;
560
561 let api: MrApiResponse = serde_json::from_slice(json).expect("valid MrApiResponse");
562 let pr: PrData = api.into();
563 assert!(pr.draft);
564 assert!(pr.body.is_none());
565 }
566
567 #[test]
568 fn test_should_deserialize_merged_mr_as_closed() {
569 let json = br#"{
570 "iid": 789,
571 "title": "Merged feature",
572 "description": null,
573 "state": "merged",
574 "draft": false,
575 "author": {"username": "dev", "id": 1},
576 "source_branch": "feature/done",
577 "target_branch": "main",
578 "created_at": "2026-01-01T00:00:00Z",
579 "updated_at": "2026-01-02T00:00:00Z",
580 "web_url": "https://gitlab.com/org/project/-/merge_requests/789"
581 }"#;
582
583 let api: MrApiResponse = serde_json::from_slice(json).expect("valid MrApiResponse");
584 let pr: PrData = api.into();
585 assert_eq!(pr.state, State::Closed);
586 }
587
588 #[test]
589 fn test_should_deserialize_empty_mr_list() {
590 let json = b"[]";
591 let list: Vec<MrApiResponse> = serde_json::from_slice(json).expect("valid empty list");
592 assert!(list.is_empty());
593 }
594
595 #[test]
596 fn test_should_deserialize_comment_api_response() {
597 let json = br#"{
598 "id": 2002,
599 "body": "Approved, merging now.",
600 "author": {"username": "reviewer", "id": 88},
601 "created_at": "2026-06-20T16:00:00Z"
602 }"#;
603
604 let api: CommentApiResponse =
605 serde_json::from_slice(json).expect("valid CommentApiResponse");
606 let comment: CommentData = api.into();
607 assert_eq!(comment.id, 2002);
608 assert_eq!(comment.body, "Approved, merging now.");
609 assert_eq!(comment.author.login, "reviewer");
610 }
611
612 #[test]
613 fn test_should_roundtrip_merge_result_via_serde() {
614 let result = MergeResult {
615 merged: true,
616 sha: Some("deadbeef1234".into()),
617 message: Some("Squash merged".into()),
618 };
619 let json = serde_json::to_string(&result).expect("serialize");
620 let round_tripped: MergeResult = serde_json::from_str(&json).expect("deserialize");
621 assert!(round_tripped.merged);
622 assert_eq!(round_tripped.sha, result.sha);
623 }
624
625 #[test]
626 fn test_should_debug_format_provider() {
627 let provider = GitLabMrProvider::new("gitlab-org/gitlab");
628 let debug = format!("{provider:?}");
629 assert!(debug.contains("GitLabMrProvider"));
630 assert!(debug.contains("gitlab-org/gitlab"));
631 }
632
633 #[test]
634 fn test_should_clone_gitlab_mr_provider() {
635 let original = GitLabMrProvider::new("owner/repo");
636 let cloned = original.clone();
637 assert_eq!(original.repo, cloned.repo);
638 }
639
640 #[test]
641 fn test_should_handle_missing_author_with_fallback() {
642 let json = br#"{
643 "iid": 1,
644 "title": "No author",
645 "description": null,
646 "state": "opened",
647 "draft": false,
648 "author": null,
649 "source_branch": "dev",
650 "target_branch": "main",
651 "created_at": null,
652 "updated_at": null,
653 "web_url": null
654 }"#;
655
656 let api: MrApiResponse = serde_json::from_slice(json).expect("valid MrApiResponse");
657 let pr: PrData = api.into();
658 assert_eq!(pr.author.login, "unknown");
659 }
660
661 fn sample_create_args() -> CreatePrArgs {
664 CreatePrArgs {
665 title: "Add feature".to_string(),
666 body: Some("Description".to_string()),
667 head: "feature/x".to_string(),
668 base: "main".to_string(),
669 draft: false,
670 repo: None,
671 }
672 }
673
674 #[tokio::test]
675 async fn test_should_return_platform_error_when_glab_fails_for_create() {
676 let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
677 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
678
679 let result = provider.create(sample_create_args()).await;
680
681 assert!(matches!(
682 result.unwrap_err(),
683 gitflow_core::CoreError::Cli(_)
684 ));
685 }
686
687 #[tokio::test]
688 async fn test_should_return_serialization_error_on_invalid_json_for_create() {
689 let runner = MockCommandRunner::success("not valid json");
690 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
691
692 let result = provider.create(sample_create_args()).await;
693
694 assert!(matches!(
695 result.unwrap_err(),
696 gitflow_core::CoreError::Serialization(_)
697 ));
698 }
699
700 #[tokio::test]
701 async fn test_should_return_platform_error_when_glab_fails_for_list() {
702 let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
703 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
704
705 let result = provider.list(ListPrArgs::default()).await;
706
707 assert!(matches!(
708 result.unwrap_err(),
709 gitflow_core::CoreError::Cli(_)
710 ));
711 }
712
713 #[tokio::test]
714 async fn test_should_return_serialization_error_on_invalid_json_for_list() {
715 let runner = MockCommandRunner::success("invalid");
716 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
717
718 let result = provider.list(ListPrArgs::default()).await;
719
720 assert!(matches!(
721 result.unwrap_err(),
722 gitflow_core::CoreError::Serialization(_)
723 ));
724 }
725
726 #[tokio::test]
727 async fn test_should_return_platform_error_when_glab_fails_for_view() {
728 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
729 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
730
731 let result = provider.view(999).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_view() {
741 let runner = MockCommandRunner::success("not valid json");
742 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
743
744 let result = provider.view(1).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_close() {
754 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
755 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
756
757 let result = provider.close(42).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_platform_error_when_glab_fails_for_reopen() {
767 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
768 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
769
770 let result = provider.reopen(42).await;
771
772 assert!(matches!(
773 result.unwrap_err(),
774 gitflow_core::CoreError::Cli(_)
775 ));
776 }
777
778 #[tokio::test]
779 async fn test_should_return_platform_error_when_glab_fails_for_comment() {
780 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
781 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
782
783 let result = provider.comment(42, "a comment").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_platform_error_when_glab_fails_for_merge() {
793 let runner = MockCommandRunner::failure(r#"{"message": "Not mergeable"}"#, 256);
794 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
795
796 let result = provider.merge(42, None).await;
797
798 assert!(matches!(
799 result.unwrap_err(),
800 gitflow_core::CoreError::Cli(_)
801 ));
802 }
803
804 #[tokio::test]
805 async fn test_should_return_platform_error_when_glab_fails_for_checkout() {
806 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
807 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
808
809 let result = provider.checkout(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_sync_branch() {
819 let runner = MockCommandRunner::failure(r#"{"message": "Rebase failed"}"#, 256);
820 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
821
822 let result = provider.sync_branch(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_mark_ready() {
832 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
833 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
834
835 let result = provider.mark_ready(42).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_mark_wip() {
845 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
846 let provider = GitLabMrProvider::with_runner("owner/repo", runner);
847
848 let result = provider.mark_wip(42).await;
849
850 assert!(matches!(
851 result.unwrap_err(),
852 gitflow_core::CoreError::Cli(_)
853 ));
854 }
855}