Skip to main content

gitflow_gitlab/
mr.rs

1//! GitLab Merge Request 提供者实现。
2//!
3//! 通过 `glab mr` CLI 实现 [`PrProvider`] trait,支持 MR 的创建、列表、查看、
4//! 关闭、合并、检出、草稿状态切换和分支同步。
5//! 所有方法通过 [`CommandRunner`] 抽象调用 `glab`,捕获 stdout 并解析 JSON。
6//!
7//! `glab` 的 `JSON` 输出使用 `snake_case` 字段名和 `GitLab` 特有的字段名(如 `iid`、
8//! `source_branch`、`target_branch`、`web_url`),因此使用中间类型 [`MrApiResponse`]
9//! 进行反序列化,然后转换为核心类型 [`PrData`]。
10
11use 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/// GitLab Merge Request 提供者,通过 `glab` CLI 操作。
27///
28/// 命令执行通过 [`CommandRunner`] 抽象,生产环境默认使用
29/// [`RealCommandRunner`],测试可注入自定义 runner 以模拟成功或失败场景。
30///
31/// # Examples
32///
33/// ```no_run
34/// use gitflow_gitlab::GitLabMrProvider;
35///
36/// let provider = GitLabMrProvider::new("gitlab-org/gitlab");
37/// ```
38#[derive(Debug, Clone)]
39pub struct GitLabMrProvider<R: CommandRunner = RealCommandRunner> {
40    /// GitLab `namespace/project`。
41    repo: String,
42    /// 用于执行 `glab` CLI 命令的 runner。
43    runner: R,
44}
45
46impl GitLabMrProvider<RealCommandRunner> {
47    /// 创建新的 GitLab MR 提供者,使用真实的进程执行器。
48    ///
49    /// `repo` 格式为 `namespace/project`。
50    #[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    /// 使用自定义 [`CommandRunner`] 创建提供者。
61    ///
62    /// 主要用于测试,可注入模拟 runner 以控制 `glab` CLI 的输出。
63    /// `repo` 格式为 `namespace/project`。
64    #[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// ── 中间 API 响应类型 ──────────────────────────────────────────────
74
75/// `glab mr` JSON 输出中的用户信息。
76#[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/// `glab mr --output json` 返回的 JSON 结构。
93#[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/// `glab mr note --output json` 返回的 JSON 结构。
149#[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// ── trait 实现 ──────────────────────────────────────────────────────
179
180#[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        // glab uses --closed for closed MRs
236        // Default (no flag) shows open MRs
237        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    // --- Failure-path tests using an injected MockCommandRunner ---
662
663    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}