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    commit::encode_project_path,
23    error::parse_glab_error,
24    runner::{CommandRunner, RealCommandRunner},
25};
26
27/// GitLab Merge Request 提供者,通过 `glab` CLI 操作。
28///
29/// 命令执行通过 [`CommandRunner`] 抽象,生产环境默认使用
30/// [`RealCommandRunner`],测试可注入自定义 runner 以模拟成功或失败场景。
31///
32/// # Examples
33///
34/// ```no_run
35/// use gitflow_gitlab::GitLabMrProvider;
36///
37/// let provider = GitLabMrProvider::new("gitlab-org/gitlab");
38/// ```
39#[derive(Debug, Clone)]
40pub struct GitLabMrProvider<R: CommandRunner = RealCommandRunner> {
41    /// GitLab `namespace/project`。
42    repo: String,
43    /// 用于执行 `glab` CLI 命令的 runner。
44    runner: R,
45}
46
47impl GitLabMrProvider<RealCommandRunner> {
48    /// 创建新的 GitLab MR 提供者,使用真实的进程执行器。
49    ///
50    /// `repo` 格式为 `namespace/project`。
51    #[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    /// 使用自定义 [`CommandRunner`] 创建提供者。
62    ///
63    /// 主要用于测试,可注入模拟 runner 以控制 `glab` CLI 的输出。
64    /// `repo` 格式为 `namespace/project`。
65    #[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// ── 中间 API 响应类型 ──────────────────────────────────────────────
75
76/// `glab mr` JSON 输出中的用户信息。
77#[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/// `glab mr --output json` 返回的 JSON 结构。
94#[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/// `glab mr note --output json` 返回的 JSON 结构。
150#[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// ── trait 实现 ──────────────────────────────────────────────────────
180
181#[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        // glab uses --closed for closed MRs
237        // Default (no flag) shows open MRs
238        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    /// 获取指定 MR 的统一差异格式(unified diff)文本。
496    ///
497    /// 调用 `glab mr diff <iid>` 获取平台原生的 formatted diff 输出。
498    ///
499    /// # Errors
500    ///
501    /// 当 MR 不存在或 `glab` CLI 调用失败时返回错误。
502    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    /// 获取指定 MR 的 patch 格式文本(含邮件头信息)。
520    ///
521    /// 调用 `glab api projects/{encoded}/merge_requests/{iid}.patch` 获取
522    /// 包含 commit 元数据的 patch 格式输出,可用于 `git am`。
523    ///
524    /// # Errors
525    ///
526    /// 当 MR 不存在或 `glab` CLI 调用失败时返回错误。
527    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    // --- Failure-path tests using an injected MockCommandRunner ---
714
715    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    // --- diff() tests ---
909
910    #[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    // --- patch() tests ---
938
939    #[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}