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