Skip to main content

gitflow_gitlab/
issue.rs

1//! GitLab Issue 提供者实现。
2//!
3//! 通过 `glab` CLI 实现 [`IssueProvider`] trait,支持 Issue 的创建、列表、查看、
4//! 关闭、重新打开、评论及标签管理。
5//! 所有方法通过 [`CommandRunner`] 抽象调用 `glab` CLI,捕获 stdout 并解析 JSON。
6//!
7//! `glab` 的 `JSON` 输出使用 `snake_case` 字段名和 `GitLab` 特有的字段名(如 `iid`、
8//! `description`、`web_url`),因此本模块使用中间类型 [`IssueApiResponse`] 进行
9//! 反序列化,然后通过 `From` 实现转换为核心类型 [`IssueData`]。
10
11use async_trait::async_trait;
12use chrono::{DateTime, Utc};
13use gitflow_core::{
14    CoreError, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, fetch_capped,
15    issue::{CreateIssueArgs, EditIssueArgs, IssueData, IssueProvider, ListIssueArgs},
16    types::{CommentData, Label, 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 Issue 提供者,通过 `glab` CLI 操作。
29///
30/// 该结构体通过调用 `glab` CLI 实现 [`IssueProvider`] trait 的所有方法,
31/// 使上层命令能够以统一的方式操作 GitLab Issue。
32///
33/// 命令执行通过 [`CommandRunner`] 抽象,生产环境默认使用
34/// [`RealCommandRunner`],测试可注入自定义 runner 以模拟成功或失败场景。
35///
36/// # Examples
37///
38/// ```no_run
39/// use gitflow_gitlab::GitLabIssueProvider;
40///
41/// let provider = GitLabIssueProvider::new("gitlab-org/gitlab");
42/// ```
43#[derive(Debug, Clone)]
44pub struct GitLabIssueProvider<R: CommandRunner = RealCommandRunner> {
45    /// GitLab `namespace/project`,如 `"gitlab-org/gitlab"`。
46    ///
47    /// 供 REST notes API 路径编码([`encode_project_path`])使用,始终是裸
48    /// `owner/repo` 形式,不受 [`repo_target`](Self::repo_target) 影响。
49    repo: String,
50    /// 传给 `glab issue ...` 子命令 `--repo` 参数的目标字符串。
51    ///
52    /// 默认等于 `repo`;通过 [`with_remote_url`](GitLabIssueProvider::with_remote_url)
53    /// 构造时为完整 git remote URL,用于在自建 GitLab 实例上显式锁定 host,
54    /// 避免仅传裸 `OWNER/REPO` 时 `glab` 的 host 探测歧义
55    /// (参见 <https://gitlab.com/gitlab-org/cli/-/issues/1370>)。
56    repo_target: String,
57    /// 用于执行 `glab` CLI 命令的 runner。
58    runner: R,
59}
60
61impl GitLabIssueProvider<RealCommandRunner> {
62    /// 创建新的 GitLab Issue 提供者,使用真实的进程执行器。
63    ///
64    /// `repo` 格式为 `namespace/project`。
65    #[must_use]
66    pub fn new(repo: impl Into<String>) -> Self {
67        let repo = repo.into();
68        Self {
69            repo_target: repo.clone(),
70            repo,
71            runner: RealCommandRunner,
72        }
73    }
74
75    /// Create a new provider from a shared [`Session`].
76    ///
77    /// This enables state reuse across multiple operations in workflow chains.
78    #[must_use]
79    pub fn with_session(session: &gitflow_core::Session) -> Self {
80        let repo = session.repo.clone();
81        Self {
82            repo_target: repo.clone(),
83            repo,
84            runner: RealCommandRunner,
85        }
86    }
87
88    /// 使用完整 git remote URL 作为 `glab issue ...` 的 `--repo` 目标创建提供者。
89    ///
90    /// `repo` 仍为裸 `namespace/project`(供 REST notes API 路径编码使用),
91    /// `remote_url` 为完整 git remote URL。`glab` 官方文档确认 `--repo` 接受
92    /// 完整 URL/Git URL 形式,借此在自建 GitLab 实例上显式锁定 host。
93    #[must_use]
94    pub fn with_remote_url(repo: impl Into<String>, remote_url: impl Into<String>) -> Self {
95        Self {
96            repo: repo.into(),
97            repo_target: remote_url.into(),
98            runner: RealCommandRunner,
99        }
100    }
101}
102
103impl<R: CommandRunner> GitLabIssueProvider<R> {
104    /// 使用自定义 [`CommandRunner`] 创建提供者。
105    ///
106    /// 主要用于测试,可注入模拟 runner 以控制 `glab` CLI 的输出。
107    /// `repo` 格式为 `namespace/project`。
108    #[must_use]
109    pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
110        let repo = repo.into();
111        Self {
112            repo_target: repo.clone(),
113            repo,
114            runner,
115        }
116    }
117
118    /// 使用自定义 [`CommandRunner`] 并显式指定 `--repo` 目标创建提供者。
119    ///
120    /// 主要用于测试,验证 `repo_target`(如完整 remote URL)被正确传给 `glab`,
121    /// 无需引入真实进程执行器。
122    #[must_use]
123    pub fn with_runner_and_repo_target(
124        repo: impl Into<String>,
125        repo_target: impl Into<String>,
126        runner: R,
127    ) -> Self {
128        Self {
129            repo: repo.into(),
130            repo_target: repo_target.into(),
131            runner,
132        }
133    }
134
135    /// 创建缺失的标签。
136    ///
137    /// 调用 `glab label create --name <name> --color <color> --repo <repo>`。
138    ///
139    /// # Errors
140    ///
141    /// 当 `glab label create` 调用失败时返回错误。
142    async fn ensure_label_exists(&self, name: &str) -> Result<()> {
143        debug!(repo = %self.repo, name, "auto-creating missing label via `glab label create`");
144
145        let output = self
146            .runner
147            .run(
148                "glab",
149                &[
150                    "label",
151                    "create",
152                    "--name",
153                    name,
154                    "--color",
155                    "ededed",
156                    "--repo",
157                    &self.repo_target,
158                ],
159            )
160            .await
161            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab label create: {e}")))?;
162
163        if !output.status.success() {
164            let glab_err = parse_glab_error(&output.stderr);
165            tracing::debug!(error = %glab_err, "Failed to auto-create label");
166            return Err(CoreError::Platform(format!(
167                "Failed to auto-create label '{name}': {}",
168                glab_err.user_message
169            )));
170        }
171
172        Ok(())
173    }
174}
175
176// ── 中间 API 响应类型 ──────────────────────────────────────────────
177
178/// `glab issue` JSON 输出中的用户信息。
179#[derive(Debug, Clone, Deserialize)]
180struct ApiUser {
181    username: String,
182    #[serde(default)]
183    id: u64,
184}
185
186impl From<&ApiUser> for UserSummary {
187    fn from(u: &ApiUser) -> Self {
188        Self {
189            login: u.username.clone(),
190            id: u.id.to_string(),
191        }
192    }
193}
194
195/// `glab issue`/`glab mr` JSON 输出中内嵌的里程碑对象。
196///
197/// GitLab 的里程碑对象同时带有全局 `id` 和项目内 `iid`;本代码库的
198/// `MilestoneRef::number` 语义上是 `iid`(与 `label.rs` 中
199/// `MilestoneData::number` 的约定一致),`iid` 缺失时才回退到 `id`。
200#[derive(Debug, Clone, Deserialize)]
201struct MilestoneRefApi {
202    #[serde(default)]
203    id: u64,
204    #[serde(default)]
205    iid: Option<u64>,
206    title: String,
207}
208
209impl From<MilestoneRefApi> for gitflow_core::types::MilestoneRef {
210    fn from(api: MilestoneRefApi) -> Self {
211        Self {
212            number: api.iid.unwrap_or(api.id),
213            title: api.title,
214        }
215    }
216}
217
218/// `glab issue --output json` 返回的 JSON 结构。
219#[derive(Debug, Clone, Deserialize)]
220struct IssueApiResponse {
221    iid: u64,
222    title: String,
223    #[serde(default)]
224    description: Option<String>,
225    state: String,
226    #[serde(default)]
227    labels: Vec<String>,
228    #[serde(default)]
229    author: Option<ApiUser>,
230    #[serde(default)]
231    assignees: Vec<ApiUser>,
232    #[serde(default)]
233    created_at: Option<DateTime<Utc>>,
234    #[serde(default)]
235    updated_at: Option<DateTime<Utc>>,
236    #[serde(default)]
237    web_url: Option<String>,
238    #[serde(default)]
239    milestone: Option<MilestoneRefApi>,
240}
241
242impl From<IssueApiResponse> for IssueData {
243    fn from(api: IssueApiResponse) -> Self {
244        let labels: Vec<Label> = api
245            .labels
246            .into_iter()
247            .map(|name| Label {
248                name,
249                color: None,
250                description: None,
251            })
252            .collect();
253        let author = api.author.as_ref().map_or_else(
254            || UserSummary {
255                login: "unknown".into(),
256                id: "0".to_string(),
257            },
258            UserSummary::from,
259        );
260
261        Self {
262            number: api.iid,
263            title: api.title,
264            body: api.description,
265            state: if api.state == "closed" {
266                State::Closed
267            } else {
268                State::Open
269            },
270            labels,
271            author,
272            assignees: api.assignees.iter().map(UserSummary::from).collect(),
273            created_at: api.created_at,
274            updated_at: api.updated_at,
275            url: api.web_url.unwrap_or_default(),
276            milestone: api.milestone.map(Into::into),
277        }
278    }
279}
280
281/// `glab issue comment --output json` 返回的 JSON 结构。
282#[derive(Debug, Clone, Deserialize)]
283struct CommentApiResponse {
284    id: u64,
285    #[serde(default)]
286    body: String,
287    #[serde(default)]
288    author: Option<ApiUser>,
289    #[serde(default)]
290    created_at: Option<DateTime<Utc>>,
291}
292
293impl From<CommentApiResponse> for CommentData {
294    fn from(api: CommentApiResponse) -> Self {
295        let author = api.author.as_ref().map_or_else(
296            || UserSummary {
297                login: "unknown".into(),
298                id: "0".to_string(),
299            },
300            UserSummary::from,
301        );
302        Self {
303            id: api.id,
304            body: api.body,
305            author,
306            created_at: api.created_at,
307        }
308    }
309}
310
311impl<R: CommandRunner + Clone + 'static> GitLabIssueProvider<R> {
312    /// [`IssueProvider::list`] 的实际实现。
313    ///
314    /// 抽成普通(非 `async_trait` 装箱)的关联函数,避开泛型异步闭包在
315    /// `async_trait` 装箱 Future 内部触发的 HRTB `Send` 检查缺陷。
316    async fn list_impl(&self, args: ListIssueArgs) -> Result<Paged<IssueData>> {
317        let cap = args.limit.unwrap_or(DEFAULT_LIST_LIMIT);
318        let repo_target = &self.repo_target;
319        // `glab milestone ...` 的 `--project` 只认裸 `namespace/project`,与
320        // `--repo`-系命令允许的完整 remote URL(`repo_target`)不同——见
321        // `GitLabMilestoneProvider::with_runner` 调用处的说明。
322        let repo = &self.repo;
323        let runner = &self.runner;
324        let state = args.state;
325        let search = &args.search;
326        let labels = &args.labels;
327        let milestone = &args.milestone;
328        // 页大小不必超过 cap+1:N+1 探测只需要多要一条即可判断截断,
329        // 请求整页 100 条再丢弃对 cap 很小的调用(如 `--limit 5`)是纯浪费。
330        let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
331
332        debug!(repo = %self.repo, cap, "spawning `glab issue list`");
333
334        fetch_capped(
335            FetchStrategy::Paged { per_page },
336            cap,
337            |page, per_page| async move {
338                let page_str = page.to_string();
339                let per_page_str = per_page.to_string();
340                let mut cmd_args: Vec<&str> =
341                    vec!["issue", "list", "--repo", repo_target, "--output", "json"];
342
343                // glab 用 --closed 表示已关闭、--all 表示全部;默认(不加旗标)为 open。
344                if let Some(state) = &state {
345                    match state {
346                        State::Closed => cmd_args.push("--closed"),
347                        State::All => cmd_args.push("--all"),
348                        State::Open => {}
349                    }
350                }
351
352                if let Some(search) = search {
353                    cmd_args.push("--search");
354                    cmd_args.push(search);
355                }
356
357                for label in labels {
358                    cmd_args.push("--label");
359                    cmd_args.push(label);
360                }
361
362                // `glab issue list --milestone` 的帮助文本写的是 "Filter issue by
363                // milestone <id>",看起来像要求数字 ID;但针对
364                // 192.168.230.23/iproost/iproost-docs 的实测显示,传里程碑
365                // **标题**能正确过滤命中,传数字 iid 反而返回空列表。因此这里
366                // 与 create/edit 保持一致,统一解析并传标题,不做数字特例。
367                let resolved_milestone_title;
368                if let Some(identifier) = milestone {
369                    // `--project` 必须是裸 `namespace/project`(`repo`),不是
370                    // `--repo`-系命令用的 `repo_target`(自建实例上可能是完整
371                    // remote URL)——传 URL 会 404。
372                    let milestone_provider =
373                        crate::GitLabMilestoneProvider::with_runner(repo.as_str(), runner.clone());
374                    let resolved = gitflow_core::label::resolve_milestone_identifier(
375                        &milestone_provider,
376                        identifier,
377                    )
378                    .await?;
379                    resolved_milestone_title = resolved.title;
380                    cmd_args.push("--milestone");
381                    cmd_args.push(&resolved_milestone_title);
382                }
383
384                cmd_args.push("--per-page");
385                cmd_args.push(&per_page_str);
386                cmd_args.push("--page");
387                cmd_args.push(&page_str);
388
389                let output = runner
390                    .run("glab", &cmd_args)
391                    .await
392                    .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
393
394                if !output.status.success() {
395                    return Err(parse_glab_error(&output.stderr).into());
396                }
397
398                let api_responses: Vec<IssueApiResponse> =
399                    serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
400
401                Ok(api_responses.into_iter().map(IssueData::from).collect())
402            },
403        )
404        .await
405    }
406}
407
408// ── trait 实现 ──────────────────────────────────────────────────────
409
410#[async_trait]
411impl<R: CommandRunner + Clone + 'static> IssueProvider for GitLabIssueProvider<R> {
412    async fn create(&self, args: CreateIssueArgs) -> Result<IssueData> {
413        let labels_joined = args.labels.join(",");
414        let assignees_joined = args.assignees.join(",");
415        let description = args.body.clone().unwrap_or_default();
416
417        let mut cmd_args: Vec<&str> = vec![
418            "issue",
419            "create",
420            "--repo",
421            &self.repo_target,
422            "--title",
423            &args.title,
424            "--description",
425            &description,
426        ];
427
428        if !args.labels.is_empty() {
429            cmd_args.push("--label");
430            cmd_args.push(&labels_joined);
431        }
432
433        if !args.assignees.is_empty() {
434            cmd_args.push("--assignee");
435            cmd_args.push(&assignees_joined);
436        }
437
438        let resolved_milestone_title;
439        if let Some(identifier) = &args.milestone {
440            // `--project` 要裸 `namespace/project`(`self.repo`),不能用
441            // `self.repo_target`(`--repo`-系命令的目标,自建实例上可能是完整
442            // remote URL,传给 `--project` 会 404)。
443            let milestone_provider = crate::GitLabMilestoneProvider::with_runner(
444                self.repo.as_str(),
445                self.runner.clone(),
446            );
447            let resolved =
448                gitflow_core::label::resolve_milestone_identifier(&milestone_provider, identifier)
449                    .await?;
450            resolved_milestone_title = resolved.title;
451            cmd_args.push("--milestone");
452            cmd_args.push(&resolved_milestone_title);
453        }
454
455        debug!(repo = %self.repo, title = %args.title, "spawning `glab issue create`");
456
457        let output = self
458            .runner
459            .run("glab", &cmd_args)
460            .await
461            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
462
463        if !output.status.success() {
464            // `glab issue create` may fail when a requested label doesn't exist.
465            // Auto-create missing labels and retry once.
466            let missing = extract_missing_labels_from_error(&output.stderr);
467            if !missing.is_empty() {
468                debug!(
469                    repo = %self.repo,
470                    missing_count = missing.len(),
471                    "auto-creating missing label(s) before retrying issue create"
472                );
473                for label in &missing {
474                    self.ensure_label_exists(label).await?;
475                }
476
477                let retry_output = self.runner.run("glab", &cmd_args).await.map_err(|e| {
478                    CoreError::Platform(format!("Failed to spawn glab on retry: {e}"))
479                })?;
480
481                if !retry_output.status.success() {
482                    return Err(parse_glab_error(&retry_output.stderr).into());
483                }
484
485                let stdout = String::from_utf8_lossy(&retry_output.stdout);
486                let issue_iid = parse_issue_iid_from_url(&stdout).ok_or_else(|| {
487                    CoreError::Platform(format!("Failed to parse issue URL from output: {stdout}"))
488                })?;
489                return self.view(issue_iid).await;
490            }
491
492            return Err(parse_glab_error(&output.stderr).into());
493        }
494
495        // Parse the issue URL from stdout (format: https://gitlab.com/.../-/issues/123)
496        let stdout = String::from_utf8_lossy(&output.stdout);
497        let issue_iid = parse_issue_iid_from_url(&stdout).ok_or_else(|| {
498            CoreError::Platform(format!("Failed to parse issue URL from output: {stdout}"))
499        })?;
500
501        // Fetch full issue details via view
502        self.view(issue_iid).await
503    }
504
505    /// 编辑 Issue 的标题和/或正文。
506    ///
507    /// 调用 `glab issue update <number> --repo <repo> [--title T] [--description D]`
508    /// (`glab` 没有 `issue edit` 子命令,标题/正文变更走 `issue update`),
509    /// 成功后通过 [`view`](Self::view) 重新拉取最新数据并返回。
510    ///
511    /// # Errors
512    ///
513    /// 当 Issue 不存在或 `glab` CLI 调用失败时返回错误。
514    async fn edit(&self, number: u64, args: EditIssueArgs) -> Result<IssueData> {
515        debug!(repo = %self.repo, number, "spawning `glab issue update`");
516
517        let number_str = number.to_string();
518        let mut cmd_args: Vec<&str> =
519            vec!["issue", "update", &number_str, "--repo", &self.repo_target];
520
521        if let Some(title) = &args.title {
522            cmd_args.push("--title");
523            cmd_args.push(title);
524        }
525        if let Some(body) = &args.body {
526            cmd_args.push("--description");
527            cmd_args.push(body);
528        }
529
530        let resolved_milestone_title;
531        match &args.milestone {
532            None => {}
533            Some(None) => {
534                // `glab issue update --help`: "-m --milestone Title of the
535                // milestone to assign Set to \"\" or 0 to unassign." — empirically
536                // confirmed against 192.168.230.23/iproost/iproost-docs on 2026-09-21.
537                cmd_args.push("--milestone");
538                cmd_args.push("");
539            }
540            Some(Some(identifier)) => {
541                // `--project` 要裸 `namespace/project`(`self.repo`),不能用
542                // `self.repo_target`(同上,避免 404)。
543                let milestone_provider = crate::GitLabMilestoneProvider::with_runner(
544                    self.repo.as_str(),
545                    self.runner.clone(),
546                );
547                let resolved = gitflow_core::label::resolve_milestone_identifier(
548                    &milestone_provider,
549                    identifier,
550                )
551                .await?;
552                resolved_milestone_title = resolved.title;
553                cmd_args.push("--milestone");
554                cmd_args.push(&resolved_milestone_title);
555            }
556        }
557
558        let output = self
559            .runner
560            .run("glab", &cmd_args)
561            .await
562            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
563
564        if !output.status.success() {
565            return Err(parse_glab_error(&output.stderr).into());
566        }
567
568        self.view(number).await
569    }
570
571    async fn list(&self, args: ListIssueArgs) -> Result<Paged<IssueData>> {
572        self.list_impl(args).await
573    }
574
575    async fn view(&self, number: u64) -> Result<IssueData> {
576        debug!(repo = %self.repo, number, "spawning `glab issue view`");
577
578        let number_str = number.to_string();
579        let output = self
580            .runner
581            .run(
582                "glab",
583                &[
584                    "issue",
585                    "view",
586                    &number_str,
587                    "--repo",
588                    &self.repo_target,
589                    "--output",
590                    "json",
591                ],
592            )
593            .await
594            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
595
596        if !output.status.success() {
597            return Err(parse_glab_error(&output.stderr).into());
598        }
599
600        let api_response: IssueApiResponse =
601            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
602
603        Ok(api_response.into())
604    }
605
606    /// 关闭指定编号的 Issue。
607    ///
608    /// 调用 `glab issue close <number> --repo <repo>` 关闭 Issue,
609    /// 然后通过 [`view`](Self::view) 重新拉取最新数据并返回。
610    ///
611    /// # Errors
612    ///
613    /// 当 Issue 不存在、已关闭或 `glab` CLI 调用失败时返回错误。
614    async fn close(&self, number: u64) -> Result<IssueData> {
615        debug!(repo = %self.repo, number, "spawning `glab issue close`");
616
617        let number_str = number.to_string();
618        let output = self
619            .runner
620            .run(
621                "glab",
622                &["issue", "close", &number_str, "--repo", &self.repo_target],
623            )
624            .await
625            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
626
627        if !output.status.success() {
628            return Err(parse_glab_error(&output.stderr).into());
629        }
630
631        self.view(number).await
632    }
633
634    /// 重新打开指定编号的 Issue。
635    ///
636    /// 调用 `glab issue reopen <number> --repo <repo>` 重新打开已关闭的 Issue,
637    /// 然后通过 [`view`](Self::view) 重新拉取最新数据并返回。
638    ///
639    /// # Errors
640    ///
641    /// 当 Issue 不存在、未关闭或 `glab` CLI 调用失败时返回错误。
642    async fn reopen(&self, number: u64) -> Result<IssueData> {
643        debug!(repo = %self.repo, number, "spawning `glab issue reopen`");
644
645        let number_str = number.to_string();
646        let output = self
647            .runner
648            .run(
649                "glab",
650                &["issue", "reopen", &number_str, "--repo", &self.repo_target],
651            )
652            .await
653            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
654
655        if !output.status.success() {
656            return Err(parse_glab_error(&output.stderr).into());
657        }
658
659        self.view(number).await
660    }
661
662    /// 在指定 Issue 上添加评论。
663    ///
664    /// 调用 `glab api --method POST /projects/{repo-encoded}/issues/{number}/notes`
665    /// 发布评论,其中 `{repo-encoded}` 为全量 URL 编码的项目路径
666    /// (如 `group/subgroup/project` → `group%2Fsubgroup%2Fproject`),
667    /// 并返回评论文数据。
668    ///
669    /// # Errors
670    ///
671    /// 当 Issue 不存在、`body` 为空或 `glab` CLI 调用失败时返回错误。
672    async fn comment(&self, number: u64, body: &str) -> Result<CommentData> {
673        debug!(repo = %self.repo, number, "spawning `glab api` POST issue note");
674
675        let encoded_path = encode_project_path(&self.repo);
676        let api_path = format!("/projects/{encoded_path}/issues/{number}/notes");
677        let body_arg = format!("body={body}");
678
679        let output = self
680            .runner
681            .run(
682                "glab",
683                &["api", "--method", "POST", &api_path, "-f", &body_arg],
684            )
685            .await
686            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab api: {e}")))?;
687
688        if !output.status.success() {
689            return Err(parse_glab_error(&output.stderr).into());
690        }
691
692        let api_response: CommentApiResponse =
693            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
694
695        Ok(api_response.into())
696    }
697
698    /// 列出指定 Issue 的评论。
699    ///
700    /// 调用 `glab api /projects/{repo-encoded}/issues/{iid}/notes` 获取评论列表,
701    /// 其中 `{repo-encoded}` 为全量 URL 编码的项目路径
702    /// (如 `group/subgroup/project` → `group%2Fsubgroup%2Fproject`),
703    /// 通过 `per_page`/`page` 查询参数逐页取到 `limit`。
704    ///
705    /// # Errors
706    ///
707    /// 当 Issue 不存在或 `glab` CLI 调用失败时返回错误。
708    async fn list_comments(&self, number: u64, limit: Option<u32>) -> Result<Paged<CommentData>> {
709        let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
710        let encoded_path = encode_project_path(&self.repo);
711        let encoded_path = &encoded_path;
712        let runner = &self.runner;
713        let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
714
715        debug!(repo = %self.repo, number, cap, "spawning `glab api` GET issue notes");
716
717        fetch_capped(
718            FetchStrategy::Paged { per_page },
719            cap,
720            |page, per_page| async move {
721                let api_path = format!(
722                    "/projects/{encoded_path}/issues/{number}/notes?per_page={per_page}&\
723                     page={page}"
724                );
725
726                let output = runner
727                    .run("glab", &["api", &api_path])
728                    .await
729                    .map_err(|e| CoreError::Platform(format!("Failed to spawn glab api: {e}")))?;
730
731                if !output.status.success() {
732                    return Err(parse_glab_error(&output.stderr).into());
733                }
734
735                let comments: Vec<CommentApiResponse> =
736                    serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
737                Ok(comments.into_iter().map(CommentData::from).collect())
738            },
739        )
740        .await
741    }
742
743    /// 为指定 Issue 添加一个或多个标签。
744    ///
745    /// 调用 `glab issue update <number> --repo <repo> --label <labels>` 添加标签,
746    /// 多个标签以逗号连接后一次性提交。
747    ///
748    /// # 自动创建缺失标签
749    ///
750    /// 当 `glab issue update --label` 因标签不存在而失败时,本方法会自动调用
751    /// `glab label create` 创建缺失的标签(使用默认颜色 `ededed`),然后重试原操作。
752    ///
753    /// # Errors
754    ///
755    /// 当 Issue 不存在、标签创建失败或 `glab` CLI 调用失败时返回错误。
756    async fn add_labels(&self, number: u64, labels: &[String]) -> Result<()> {
757        debug!(
758            repo = %self.repo,
759            number,
760            label_count = labels.len(),
761            "spawning `glab issue update --label`"
762        );
763
764        let labels_joined = labels.join(",");
765        let number_str = number.to_string();
766        let cmd_args: Vec<&str> = vec![
767            "issue",
768            "update",
769            &number_str,
770            "--repo",
771            &self.repo_target,
772            "--label",
773            &labels_joined,
774        ];
775        let output = self
776            .runner
777            .run("glab", &cmd_args)
778            .await
779            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
780
781        if output.status.success() {
782            return Ok(());
783        }
784
785        // glab issue update --label may fail when a label doesn't exist.
786        // Try to auto-create missing labels and retry once.
787        let missing = extract_missing_labels_from_error(&output.stderr);
788        if missing.is_empty() {
789            return Err(parse_glab_error(&output.stderr).into());
790        }
791
792        debug!(
793            repo = %self.repo,
794            missing_count = missing.len(),
795            "auto-creating missing label(s) before retry"
796        );
797
798        for label in &missing {
799            self.ensure_label_exists(label).await?;
800        }
801
802        let retry_output = self
803            .runner
804            .run("glab", &cmd_args)
805            .await
806            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab on retry: {e}")))?;
807
808        if !retry_output.status.success() {
809            return Err(parse_glab_error(&retry_output.stderr).into());
810        }
811
812        Ok(())
813    }
814
815    /// 从指定 Issue 移除一个标签。
816    ///
817    /// 调用 `glab issue update <number> --repo <repo> --unlabel <label>` 移除标签。
818    ///
819    /// # Errors
820    ///
821    /// 当 Issue 不存在、标签未附加到该 Issue 或 `glab` CLI 调用失败时返回错误。
822    async fn remove_label(&self, number: u64, label: &str) -> Result<()> {
823        debug!(repo = %self.repo, number, label, "spawning `glab issue update --unlabel`");
824
825        let number_str = number.to_string();
826        let output = self
827            .runner
828            .run(
829                "glab",
830                &[
831                    "issue",
832                    "update",
833                    &number_str,
834                    "--repo",
835                    &self.repo_target,
836                    "--unlabel",
837                    label,
838                ],
839            )
840            .await
841            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
842
843        if !output.status.success() {
844            return Err(parse_glab_error(&output.stderr).into());
845        }
846
847        Ok(())
848    }
849}
850
851/// 从 `glab issue update --label` 的 stderr 中提取缺失的标签名。
852///
853/// GitLab CLI 的错误格式可能有多种变体,本函数尝试匹配常见的
854/// `'<label>' not found` / `"label not found: <label>"` 模式。
855/// 未匹配时返回空列表,调用方据此判断是否为"标签缺失"错误。
856fn extract_missing_labels_from_error(stderr: &[u8]) -> Vec<String> {
857    let text = String::from_utf8_lossy(stderr);
858    let mut labels = Vec::new();
859    let mut search_from: usize = 0;
860
861    // 模式 1: '<label>' not found (与 gh/gitcode 一致)
862    while let Some(rel_open) = text[search_from..].find('\'') {
863        let open_pos = search_from + rel_open + 1;
864        let Some(rel_close) = text[open_pos..].find('\'') else {
865            break;
866        };
867        let close_pos = open_pos + rel_close;
868        let after_close = &text[close_pos + 1..];
869
870        if after_close.starts_with(" not found") {
871            let label = text[open_pos..close_pos].to_string();
872            if !label.is_empty() {
873                labels.push(label);
874            }
875        }
876        search_from = close_pos + 1;
877    }
878
879    labels
880}
881
882/// Parse issue IID from GitLab URL.
883///
884/// Extracts the numeric IID from URLs like:
885/// - `https://gitlab.com/owner/repo/-/issues/123`
886/// - `https://gitlab.example.com/group/project/-/issues/456`
887/// - `https://gitlab.example.com/group/project/-/work_items/789`
888fn parse_issue_iid_from_url(url: &str) -> Option<u64> {
889    url.lines().find_map(|line| {
890        let line = line.trim();
891        for marker in ["/-/issues/", "/-/work_items/"] {
892            if line.contains(marker)
893                && let Some(id) = line
894                    .rsplit(marker)
895                    .next()
896                    .and_then(|s| s.split('/').next())
897                    .and_then(|s| s.parse().ok())
898            {
899                return Some(id);
900            }
901        }
902        None
903    })
904}
905
906#[cfg(test)]
907mod tests {
908    use super::*;
909    use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
910
911    #[test]
912    fn test_should_construct_gitlab_issue_provider() {
913        let provider = GitLabIssueProvider::new("gitlab-org/gitlab");
914        assert_eq!(provider.repo, "gitlab-org/gitlab");
915    }
916
917    #[test]
918    fn test_should_construct_gitlab_issue_provider_from_string() {
919        let repo = String::from("gitlab-org/gitlab");
920        let provider = GitLabIssueProvider::new(repo);
921        assert_eq!(provider.repo, "gitlab-org/gitlab");
922    }
923
924    #[test]
925    fn test_should_deserialize_issue_api_response() {
926        let json = br#"{
927            "iid": 42,
928            "title": "Fix login bug",
929            "description": "Reproduced on v1.2.3",
930            "state": "opened",
931            "labels": ["bug", "critical"],
932            "author": {"username": "admin", "id": 1},
933            "assignees": [{"username": "alice", "id": 7}],
934            "created_at": "2026-01-15T09:30:00Z",
935            "updated_at": "2026-01-16T11:00:00Z",
936            "web_url": "https://gitlab.com/gitlab-org/gitlab/-/issues/42"
937        }"#;
938
939        let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
940        let issue: IssueData = api.into();
941
942        assert_eq!(issue.number, 42);
943        assert_eq!(issue.title, "Fix login bug");
944        assert_eq!(issue.body.as_deref(), Some("Reproduced on v1.2.3"));
945        assert_eq!(issue.state, State::Open);
946        assert_eq!(issue.labels.len(), 2);
947        assert_eq!(issue.labels[0].name, "bug");
948        assert_eq!(issue.author.login, "admin");
949        assert_eq!(issue.assignees.len(), 1);
950        assert_eq!(
951            issue.url,
952            "https://gitlab.com/gitlab-org/gitlab/-/issues/42"
953        );
954    }
955
956    #[test]
957    fn test_should_deserialize_closed_issue_api_response() {
958        let json = br#"{
959            "iid": 10,
960            "title": "Fixed typo",
961            "description": null,
962            "state": "closed",
963            "labels": [],
964            "author": {"username": "dev", "id": 5},
965            "assignees": [],
966            "created_at": "2026-06-01T08:00:00Z",
967            "updated_at": "2026-06-02T12:00:00Z",
968            "web_url": "https://gitlab.com/org/project/-/issues/10"
969        }"#;
970
971        let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
972        let issue: IssueData = api.into();
973        assert_eq!(issue.state, State::Closed);
974    }
975
976    #[test]
977    fn test_should_deserialize_comment_api_response() {
978        let json = br#"{
979            "id": 1001,
980            "body": "Thanks for reporting.",
981            "author": {"username": "maintainer", "id": 42},
982            "created_at": "2026-06-15T14:00:00Z"
983        }"#;
984
985        let api: CommentApiResponse =
986            serde_json::from_slice(json).expect("valid CommentApiResponse");
987        let comment: CommentData = api.into();
988        assert_eq!(comment.id, 1001);
989        assert_eq!(comment.body, "Thanks for reporting.");
990        assert_eq!(comment.author.login, "maintainer");
991    }
992
993    #[test]
994    fn test_should_handle_missing_author_with_fallback() {
995        let json = br#"{
996            "iid": 1,
997            "title": "No author",
998            "description": null,
999            "state": "opened",
1000            "labels": [],
1001            "author": null,
1002            "assignees": [],
1003            "created_at": null,
1004            "updated_at": null,
1005            "web_url": null
1006        }"#;
1007
1008        let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
1009        let issue: IssueData = api.into();
1010        assert_eq!(issue.author.login, "unknown");
1011        assert_eq!(issue.author.id, "0");
1012        assert!(
1013            issue.created_at.is_none(),
1014            "missing created_at must stay None, not fall back to Utc::now()"
1015        );
1016        assert!(
1017            issue.updated_at.is_none(),
1018            "missing updated_at must stay None, not fall back to Utc::now()"
1019        );
1020    }
1021
1022    #[test]
1023    fn test_should_keep_comment_created_at_none_when_api_omits_it() {
1024        let json = br#"{
1025            "id": 1002,
1026            "body": "No timestamp provided.",
1027            "author": {"username": "maintainer", "id": 42}
1028        }"#;
1029
1030        let api: CommentApiResponse =
1031            serde_json::from_slice(json).expect("valid CommentApiResponse");
1032        let comment: CommentData = api.into();
1033        assert!(
1034            comment.created_at.is_none(),
1035            "missing created_at must stay None, not fall back to Utc::now()"
1036        );
1037    }
1038
1039    #[test]
1040    fn test_should_convert_labels_from_strings() {
1041        let json = br#"{
1042            "iid": 1,
1043            "title": "Test",
1044            "description": null,
1045            "state": "opened",
1046            "labels": ["bug", "enhancement", "documentation"],
1047            "author": {"username": "admin", "id": 1},
1048            "assignees": [],
1049            "created_at": "2026-01-01T00:00:00Z",
1050            "updated_at": "2026-01-01T00:00:00Z",
1051            "web_url": "https://gitlab.com/x/y/-/issues/1"
1052        }"#;
1053
1054        let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
1055        let issue: IssueData = api.into();
1056        assert_eq!(issue.labels.len(), 3);
1057        assert_eq!(issue.labels[0].name, "bug");
1058        assert_eq!(issue.labels[1].name, "enhancement");
1059        assert!(issue.labels[0].color.is_none());
1060    }
1061
1062    #[test]
1063    fn test_should_deserialize_issue_with_milestone() {
1064        // Real shape captured from `glab issue view --output json` against
1065        // http://192.168.230.23/iproost/iproost-docs issue #10 (milestone iid 2,
1066        // title "gf-357-test-milestone") on 2026-09-21. Trimmed to the fields
1067        // this module reads; GitLab's full milestone object also has
1068        // `group_id`, `project_id`, `start_date`, `due_date`, `web_url`,
1069        // `updated_at`, `created_at`, `expired`, all ignored here.
1070        let json = r#"{
1071            "iid": 10,
1072            "title": "gf-357 milestone test issue",
1073            "description": "temp test issue for milestone shape investigation",
1074            "state": "opened",
1075            "labels": [],
1076            "milestone": {
1077                "id": 2,
1078                "iid": 2,
1079                "title": "gf-357-test-milestone",
1080                "state": "active"
1081            },
1082            "web_url": "http://192.168.230.23/iproost/iproost-docs/-/work_items/10"
1083        }"#;
1084        let api: IssueApiResponse = serde_json::from_str(json).expect("deserialize");
1085        let issue: IssueData = api.into();
1086        assert_eq!(
1087            issue.milestone,
1088            Some(gitflow_core::types::MilestoneRef {
1089                number: 2,
1090                title: "gf-357-test-milestone".into(),
1091            })
1092        );
1093    }
1094
1095    #[test]
1096    fn test_should_deserialize_issue_with_no_milestone_field() {
1097        let json = r#"{
1098            "iid": 11,
1099            "title": "No milestone",
1100            "description": null,
1101            "state": "opened",
1102            "labels": [],
1103            "web_url": "http://192.168.230.23/iproost/iproost-docs/-/issues/11"
1104        }"#;
1105        let api: IssueApiResponse = serde_json::from_str(json).expect("deserialize");
1106        let issue: IssueData = api.into();
1107        assert!(issue.milestone.is_none());
1108    }
1109
1110    #[test]
1111    fn test_should_deserialize_empty_issue_list() {
1112        let json = b"[]";
1113        let list: Vec<IssueApiResponse> = serde_json::from_slice(json).expect("valid empty list");
1114        assert!(list.is_empty());
1115    }
1116
1117    #[test]
1118    fn test_should_debug_format_provider() {
1119        let provider = GitLabIssueProvider::new("gitlab-org/gitlab");
1120        let debug = format!("{provider:?}");
1121        assert!(debug.contains("GitLabIssueProvider"));
1122        assert!(debug.contains("gitlab-org/gitlab"));
1123    }
1124
1125    #[test]
1126    fn test_should_clone_gitlab_issue_provider() {
1127        let original = GitLabIssueProvider::new("owner/repo");
1128        let cloned = original.clone();
1129        assert_eq!(original.repo, cloned.repo);
1130    }
1131
1132    #[test]
1133    fn test_should_parse_issue_iid_from_gitlab_url() {
1134        assert_eq!(
1135            parse_issue_iid_from_url("https://gitlab.com/owner/repo/-/issues/123"),
1136            Some(123)
1137        );
1138    }
1139
1140    #[test]
1141    fn test_should_parse_issue_iid_from_self_hosted_url() {
1142        assert_eq!(
1143            parse_issue_iid_from_url("https://gitlab.example.com/group/project/-/issues/456"),
1144            Some(456)
1145        );
1146    }
1147
1148    #[test]
1149    fn test_should_parse_issue_iid_from_multiline_output() {
1150        let output = "Creating issue...\nhttps://gitlab.com/owner/repo/-/issues/789\nDone.";
1151        assert_eq!(parse_issue_iid_from_url(output), Some(789));
1152    }
1153
1154    #[test]
1155    fn test_should_return_none_for_invalid_url() {
1156        assert_eq!(parse_issue_iid_from_url("not a url"), None);
1157    }
1158
1159    #[test]
1160    fn test_should_return_none_for_url_without_iid() {
1161        assert_eq!(
1162            parse_issue_iid_from_url("https://gitlab.com/owner/repo/-/issues/"),
1163            None
1164        );
1165    }
1166
1167    #[test]
1168    fn test_should_parse_work_item_url() {
1169        assert_eq!(
1170            parse_issue_iid_from_url("http://192.168.230.23/iproost/iproost-docs/-/work_items/1"),
1171            Some(1)
1172        );
1173    }
1174
1175    #[test]
1176    fn test_should_parse_work_item_url_among_lines() {
1177        let output =
1178            "Creating issue...\nhttp://192.168.230.23/iproost/iproost-docs/-/work_items/7\nDone.";
1179        assert_eq!(parse_issue_iid_from_url(output), Some(7));
1180    }
1181
1182    // --- Failure-path tests using an injected MockCommandRunner ---
1183
1184    #[tokio::test]
1185    async fn test_should_return_platform_error_when_glab_fails_for_view() {
1186        let runner = MockCommandRunner::failure(r#"{"message": "Issue not found"}"#, 256);
1187        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1188
1189        let result = provider.view(999).await;
1190
1191        assert!(result.is_err());
1192        assert!(matches!(
1193            result.unwrap_err(),
1194            gitflow_core::CoreError::Cli(_)
1195        ));
1196    }
1197
1198    #[tokio::test]
1199    async fn test_should_return_serialization_error_on_invalid_json_for_view() {
1200        let runner = MockCommandRunner::success("not valid json");
1201        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1202
1203        let result = provider.view(1).await;
1204
1205        assert!(result.is_err());
1206        assert!(matches!(
1207            result.unwrap_err(),
1208            gitflow_core::CoreError::Serialization(_)
1209        ));
1210    }
1211
1212    #[tokio::test]
1213    async fn test_should_return_platform_error_when_glab_fails_for_list() {
1214        let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
1215        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1216
1217        let result = provider.list(ListIssueArgs::default()).await;
1218
1219        assert!(result.is_err());
1220        assert!(matches!(
1221            result.unwrap_err(),
1222            gitflow_core::CoreError::Cli(_)
1223        ));
1224    }
1225
1226    #[tokio::test]
1227    async fn test_should_return_serialization_error_on_invalid_json_for_list() {
1228        let runner = MockCommandRunner::success("invalid");
1229        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1230
1231        let result = provider.list(ListIssueArgs::default()).await;
1232
1233        assert!(result.is_err());
1234        assert!(matches!(
1235            result.unwrap_err(),
1236            gitflow_core::CoreError::Serialization(_)
1237        ));
1238    }
1239
1240    #[tokio::test]
1241    async fn test_should_list_all_issues_with_all_flag() {
1242        let runner = MockCommandRunner::success("[]");
1243        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1244
1245        let _ = provider
1246            .list(ListIssueArgs {
1247                state: Some(State::All),
1248                ..Default::default()
1249            })
1250            .await;
1251
1252        assert_eq!(
1253            runner.recorded_calls()[0].1,
1254            vec![
1255                "issue",
1256                "list",
1257                "--repo",
1258                "owner/repo",
1259                "--output",
1260                "json",
1261                "--all",
1262                "--per-page",
1263                "100",
1264                "--page",
1265                "1"
1266            ]
1267            .into_iter()
1268            .map(String::from)
1269            .collect::<Vec<_>>()
1270        );
1271    }
1272
1273    fn sample_create_args() -> CreateIssueArgs {
1274        CreateIssueArgs {
1275            title: "Bug report".to_string(),
1276            body: Some("Steps to reproduce".to_string()),
1277            labels: vec!["bug".to_string()],
1278            assignees: vec!["alice".to_string()],
1279            milestone: None,
1280        }
1281    }
1282
1283    #[tokio::test]
1284    async fn test_should_pass_empty_description_when_body_is_none() {
1285        let runner = SequencedMockCommandRunner::from_results(&[
1286            (true, "https://gitlab.com/owner/repo/-/issues/7"),
1287            (true, r#"{"iid":7,"title":"t","state":"opened"}"#),
1288        ]);
1289        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1290
1291        let args = CreateIssueArgs {
1292            title: "t".to_string(),
1293            body: None,
1294            labels: vec![],
1295            assignees: vec![],
1296            milestone: None,
1297        };
1298
1299        provider.create(args).await.expect("should create");
1300
1301        let calls = runner.recorded_calls();
1302        let create_call = &calls[0];
1303        let desc_idx = create_call
1304            .1
1305            .iter()
1306            .position(|a| a == "--description")
1307            .expect("--description flag must be present even when body is None");
1308        assert_eq!(create_call.1[desc_idx + 1], "");
1309    }
1310
1311    #[tokio::test]
1312    async fn test_should_return_platform_error_when_glab_fails_for_create() {
1313        let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
1314        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1315
1316        let result = provider.create(sample_create_args()).await;
1317
1318        assert!(result.is_err());
1319        assert!(matches!(
1320            result.unwrap_err(),
1321            gitflow_core::CoreError::Cli(_)
1322        ));
1323    }
1324
1325    #[tokio::test]
1326    async fn test_should_return_serialization_error_on_invalid_json_for_create() {
1327        // `create` succeeds and parses the issue IID from this URL, then delegates
1328        // to `view`, which receives the same non-JSON stdout and fails to deserialize.
1329        let runner = MockCommandRunner::success("https://gitlab.com/owner/repo/-/issues/7");
1330        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1331
1332        let result = provider.create(sample_create_args()).await;
1333
1334        assert!(result.is_err());
1335        assert!(matches!(
1336            result.unwrap_err(),
1337            gitflow_core::CoreError::Serialization(_)
1338        ));
1339    }
1340
1341    #[tokio::test]
1342    async fn test_should_return_platform_error_when_glab_fails_for_close() {
1343        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1344        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1345
1346        let result = provider.close(42).await;
1347
1348        assert!(result.is_err());
1349        assert!(matches!(
1350            result.unwrap_err(),
1351            gitflow_core::CoreError::Cli(_)
1352        ));
1353    }
1354
1355    #[tokio::test]
1356    async fn test_should_return_serialization_error_on_invalid_json_for_close() {
1357        let runner = MockCommandRunner::success("invalid");
1358        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1359
1360        let result = provider.close(42).await;
1361
1362        assert!(result.is_err());
1363        assert!(matches!(
1364            result.unwrap_err(),
1365            gitflow_core::CoreError::Serialization(_)
1366        ));
1367    }
1368
1369    #[tokio::test]
1370    async fn test_should_return_platform_error_when_glab_fails_for_reopen() {
1371        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1372        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1373
1374        let result = provider.reopen(42).await;
1375
1376        assert!(result.is_err());
1377        assert!(matches!(
1378            result.unwrap_err(),
1379            gitflow_core::CoreError::Cli(_)
1380        ));
1381    }
1382
1383    #[tokio::test]
1384    async fn test_should_return_serialization_error_on_invalid_json_for_reopen() {
1385        let runner = MockCommandRunner::success("invalid");
1386        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1387
1388        let result = provider.reopen(42).await;
1389
1390        assert!(result.is_err());
1391        assert!(matches!(
1392            result.unwrap_err(),
1393            gitflow_core::CoreError::Serialization(_)
1394        ));
1395    }
1396
1397    #[tokio::test]
1398    async fn test_should_close_issue_without_output_json_flag_and_refetch_via_view() {
1399        let runner = MockCommandRunner::success(
1400            r#"{"iid":42,"title":"Fix","state":"closed","description":null,"labels":[]}"#,
1401        );
1402        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1403
1404        let issue = provider.close(42).await.expect("close should succeed");
1405
1406        assert_eq!(issue.number, 42);
1407        assert_eq!(issue.state, State::Closed);
1408        let calls = runner.recorded_calls();
1409        assert_eq!(
1410            calls[0].1,
1411            vec!["issue", "close", "42", "--repo", "owner/repo"]
1412                .into_iter()
1413                .map(String::from)
1414                .collect::<Vec<_>>()
1415        );
1416        // 第二次调用是重新拉取 view(带 --output json,读操作保留)
1417        assert_eq!(calls[1].0, "glab");
1418        assert!(calls[1].1.contains(&"--output".to_string()));
1419    }
1420
1421    #[tokio::test]
1422    async fn test_should_reopen_issue_without_output_json_flag_and_refetch_via_view() {
1423        let runner = MockCommandRunner::success(
1424            r#"{"iid":42,"title":"Fix","state":"opened","description":null,"labels":[]}"#,
1425        );
1426        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1427
1428        let issue = provider.reopen(42).await.expect("reopen should succeed");
1429
1430        assert_eq!(issue.number, 42);
1431        assert_eq!(issue.state, State::Open);
1432        let calls = runner.recorded_calls();
1433        assert_eq!(
1434            calls[0].1,
1435            vec!["issue", "reopen", "42", "--repo", "owner/repo"]
1436                .into_iter()
1437                .map(String::from)
1438                .collect::<Vec<_>>()
1439        );
1440        assert!(calls[1].1.contains(&"--output".to_string()));
1441    }
1442
1443    #[tokio::test]
1444    async fn test_should_use_explicit_repo_target_for_view() {
1445        let runner = MockCommandRunner::success(
1446            r#"{"iid":42,"title":"Fix","state":"opened","description":null,"labels":[]}"#,
1447        );
1448        let provider = GitLabIssueProvider::with_runner_and_repo_target(
1449            "owner/repo",
1450            "https://192.168.230.23/iproost/proxy/api-src.git",
1451            runner.clone(),
1452        );
1453
1454        let issue = provider.view(42).await.expect("view should succeed");
1455
1456        assert_eq!(issue.number, 42);
1457        assert!(
1458            runner.recorded_calls()[0]
1459                .1
1460                .contains(&"https://192.168.230.23/iproost/proxy/api-src.git".to_string())
1461        );
1462    }
1463
1464    #[tokio::test]
1465    async fn test_should_return_platform_error_when_glab_fails_for_comment() {
1466        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1467        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1468
1469        let result = provider.comment(42, "a comment").await;
1470
1471        assert!(result.is_err());
1472        assert!(matches!(
1473            result.unwrap_err(),
1474            gitflow_core::CoreError::Cli(_)
1475        ));
1476    }
1477
1478    #[tokio::test]
1479    async fn test_should_return_serialization_error_on_invalid_json_for_comment() {
1480        let runner = MockCommandRunner::success("invalid");
1481        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1482
1483        let result = provider.comment(42, "a comment").await;
1484
1485        assert!(result.is_err());
1486        assert!(matches!(
1487            result.unwrap_err(),
1488            gitflow_core::CoreError::Serialization(_)
1489        ));
1490    }
1491
1492    #[tokio::test]
1493    async fn test_should_post_issue_note_via_glab_api_with_message_field() {
1494        let runner = MockCommandRunner::success(
1495            r#"{"id":77,"body":"hello","author":{"username":"alice","id":1},"created_at":"2026-08-18T00:00:00Z"}"#,
1496        );
1497        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1498
1499        let comment = provider.comment(42, "hello").await.expect("should post");
1500
1501        assert_eq!(comment.id, 77);
1502        assert_eq!(comment.author.login, "alice");
1503        assert_eq!(
1504            runner.recorded_calls()[0].1,
1505            vec![
1506                "api",
1507                "--method",
1508                "POST",
1509                "/projects/owner%2Frepo/issues/42/notes",
1510                "-f",
1511                "body=hello",
1512            ]
1513            .into_iter()
1514            .map(String::from)
1515            .collect::<Vec<_>>()
1516        );
1517    }
1518
1519    #[tokio::test]
1520    async fn test_should_encode_nested_group_repo_path_for_comment() {
1521        let runner = MockCommandRunner::success(
1522            r#"{"id":77,"body":"hello","author":{"username":"alice","id":1},"created_at":"2026-08-18T00:00:00Z"}"#,
1523        );
1524        let provider = GitLabIssueProvider::with_runner("group/subgroup/project", runner.clone());
1525
1526        let comment = provider.comment(42, "hello").await.expect("should post");
1527
1528        assert_eq!(comment.id, 77);
1529        assert_eq!(
1530            runner.recorded_calls()[0].1,
1531            vec![
1532                "api",
1533                "--method",
1534                "POST",
1535                "/projects/group%2Fsubgroup%2Fproject/issues/42/notes",
1536                "-f",
1537                "body=hello",
1538            ]
1539            .into_iter()
1540            .map(String::from)
1541            .collect::<Vec<_>>()
1542        );
1543    }
1544
1545    #[tokio::test]
1546    async fn test_should_encode_nested_group_repo_path_for_list_comments() {
1547        let runner = MockCommandRunner::success(
1548            r#"[{"id":77,"body":"hello","author":{"username":"alice","id":1},"created_at":"2026-08-18T00:00:00Z"}]"#,
1549        );
1550        let provider = GitLabIssueProvider::with_runner("group/subgroup/project", runner.clone());
1551
1552        let paged = provider.list_comments(42, None).await.expect("should list");
1553
1554        assert_eq!(paged.items.len(), 1);
1555        assert_eq!(
1556            runner.recorded_calls()[0].1,
1557            vec![
1558                "api",
1559                "/projects/group%2Fsubgroup%2Fproject/issues/42/notes?per_page=100&page=1"
1560            ]
1561            .into_iter()
1562            .map(String::from)
1563            .collect::<Vec<_>>()
1564        );
1565    }
1566
1567    #[tokio::test]
1568    async fn test_should_produce_complete_argv_for_list_comments_with_default_limit() {
1569        let runner = MockCommandRunner::success("[]");
1570        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1571
1572        let paged = provider
1573            .list_comments(359, None)
1574            .await
1575            .expect("list_comments should succeed");
1576
1577        assert!(paged.items.is_empty());
1578        let calls = runner.recorded_calls();
1579        assert_eq!(calls[0].0, "glab");
1580        assert_eq!(
1581            calls[0].1,
1582            vec![
1583                "api",
1584                "/projects/owner%2Frepo/issues/359/notes?per_page=100&page=1"
1585            ]
1586        );
1587    }
1588
1589    #[tokio::test]
1590    async fn test_should_build_well_formed_query_string_for_list_comments() {
1591        let runner = MockCommandRunner::success("[]");
1592        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1593
1594        provider
1595            .list_comments(359, None)
1596            .await
1597            .expect("list_comments should succeed");
1598
1599        let calls = runner.recorded_calls();
1600        let api_path = &calls[0].1[1];
1601        assert_eq!(
1602            api_path.matches('?').count(),
1603            1,
1604            "must have exactly one '?', got: {api_path}"
1605        );
1606        assert_eq!(
1607            api_path.matches('&').count(),
1608            1,
1609            "must have exactly one '&', got: {api_path}"
1610        );
1611        assert!(api_path.contains("per_page=100"), "got: {api_path}");
1612        assert!(api_path.contains("page=1"), "got: {api_path}");
1613    }
1614
1615    #[tokio::test]
1616    async fn test_should_return_platform_error_when_glab_fails_for_add_labels() {
1617        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1618        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1619
1620        let result = provider.add_labels(42, &["bug".to_string()]).await;
1621
1622        assert!(result.is_err());
1623        assert!(matches!(
1624            result.unwrap_err(),
1625            gitflow_core::CoreError::Cli(_)
1626        ));
1627    }
1628
1629    #[tokio::test]
1630    async fn test_should_return_platform_error_when_glab_fails_for_remove_label() {
1631        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1632        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1633
1634        let result = provider.remove_label(42, "bug").await;
1635
1636        assert!(result.is_err());
1637        assert!(matches!(
1638            result.unwrap_err(),
1639            gitflow_core::CoreError::Cli(_)
1640        ));
1641    }
1642
1643    #[tokio::test]
1644    async fn test_should_call_issue_update_with_label_flag_for_add_labels() {
1645        let runner = MockCommandRunner::success("");
1646        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1647
1648        let result = provider
1649            .add_labels(42, &["bug".to_string(), "priority:high".to_string()])
1650            .await;
1651
1652        assert!(result.is_ok(), "expected Ok, got {result:?}");
1653        assert_eq!(
1654            runner.recorded_calls()[0].1,
1655            vec![
1656                "issue",
1657                "update",
1658                "42",
1659                "--repo",
1660                "owner/repo",
1661                "--label",
1662                "bug,priority:high"
1663            ]
1664            .into_iter()
1665            .map(String::from)
1666            .collect::<Vec<_>>()
1667        );
1668    }
1669
1670    #[tokio::test]
1671    async fn test_should_use_explicit_repo_target_for_add_labels() {
1672        let runner = MockCommandRunner::success("");
1673        let provider = GitLabIssueProvider::with_runner_and_repo_target(
1674            "owner/repo",
1675            "https://192.168.230.23/iproost/proxy/api-src.git",
1676            runner.clone(),
1677        );
1678
1679        let result = provider
1680            .add_labels(42, &["priority:medium".to_string()])
1681            .await;
1682
1683        assert!(result.is_ok(), "expected Ok, got {result:?}");
1684        assert_eq!(
1685            runner.recorded_calls()[0].1,
1686            vec![
1687                "issue",
1688                "update",
1689                "42",
1690                "--repo",
1691                "https://192.168.230.23/iproost/proxy/api-src.git",
1692                "--label",
1693                "priority:medium",
1694            ]
1695            .into_iter()
1696            .map(String::from)
1697            .collect::<Vec<_>>()
1698        );
1699    }
1700
1701    #[tokio::test]
1702    async fn test_should_call_issue_update_with_unlabel_flag_for_remove_label() {
1703        let runner = MockCommandRunner::success("");
1704        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1705
1706        let result = provider.remove_label(42, "bug").await;
1707
1708        assert!(result.is_ok(), "expected Ok, got {result:?}");
1709        assert_eq!(
1710            runner.recorded_calls()[0].1,
1711            vec![
1712                "issue",
1713                "update",
1714                "42",
1715                "--repo",
1716                "owner/repo",
1717                "--unlabel",
1718                "bug"
1719            ]
1720            .into_iter()
1721            .map(String::from)
1722            .collect::<Vec<_>>()
1723        );
1724    }
1725
1726    #[tokio::test]
1727    async fn test_should_use_explicit_repo_target_for_remove_label() {
1728        let runner = MockCommandRunner::success("");
1729        let provider = GitLabIssueProvider::with_runner_and_repo_target(
1730            "owner/repo",
1731            "https://192.168.230.23/iproost/proxy/api-src.git",
1732            runner.clone(),
1733        );
1734
1735        let result = provider.remove_label(42, "priority:medium").await;
1736
1737        assert!(result.is_ok(), "expected Ok, got {result:?}");
1738        assert_eq!(
1739            runner.recorded_calls()[0].1,
1740            vec![
1741                "issue",
1742                "update",
1743                "42",
1744                "--repo",
1745                "https://192.168.230.23/iproost/proxy/api-src.git",
1746                "--unlabel",
1747                "priority:medium",
1748            ]
1749            .into_iter()
1750            .map(String::from)
1751            .collect::<Vec<_>>()
1752        );
1753    }
1754
1755    #[tokio::test]
1756    async fn test_should_edit_issue_via_update_and_view_result() {
1757        // Sequence: 1. `glab issue update` → succeeds
1758        //           2. `glab issue view --output json` → returns updated issue JSON
1759        let runner = SequencedMockCommandRunner::from_results(&[
1760            (true, ""),
1761            (
1762                true,
1763                r#"{"iid":42,"title":"New title","description":"orig","state":"opened","labels":[],"author":{"username":"admin","id":1},"assignees":[],"created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-02T00:00:00Z","web_url":"https://gitlab.com/owner/repo/-/issues/42"}"#,
1764            ),
1765        ]);
1766        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1767
1768        let issue = provider
1769            .edit(
1770                42,
1771                gitflow_core::issue::EditIssueArgs {
1772                    title: Some("New title".to_string()),
1773                    body: None,
1774                    milestone: None,
1775                },
1776            )
1777            .await
1778            .expect("edit should succeed");
1779
1780        assert_eq!(issue.number, 42);
1781        assert_eq!(issue.title, "New title");
1782    }
1783
1784    #[tokio::test]
1785    async fn test_should_send_title_and_description_flags_for_edit() {
1786        let runner = MockCommandRunner::success("");
1787        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1788
1789        let _ = provider
1790            .edit(
1791                7,
1792                gitflow_core::issue::EditIssueArgs {
1793                    title: Some("T".to_string()),
1794                    body: Some("B".to_string()),
1795                    milestone: None,
1796                },
1797            )
1798            .await;
1799
1800        assert_eq!(
1801            runner.recorded_calls()[0].1,
1802            vec![
1803                "issue",
1804                "update",
1805                "7",
1806                "--repo",
1807                "owner/repo",
1808                "--title",
1809                "T",
1810                "--description",
1811                "B"
1812            ]
1813            .into_iter()
1814            .map(String::from)
1815            .collect::<Vec<_>>()
1816        );
1817    }
1818
1819    #[tokio::test]
1820    async fn test_should_return_platform_error_when_glab_fails_for_edit() {
1821        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1822        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1823
1824        let result = provider
1825            .edit(42, gitflow_core::issue::EditIssueArgs::default())
1826            .await;
1827
1828        assert!(result.is_err());
1829        assert!(matches!(
1830            result.unwrap_err(),
1831            gitflow_core::CoreError::Cli(_)
1832        ));
1833    }
1834
1835    // --- extract_missing_labels_from_error: pure-function tests ---
1836
1837    #[test]
1838    fn test_should_extract_single_missing_label_from_glab_stderr() {
1839        let stderr = b"failed to update ...: 'type:enhancement' not found";
1840        let missing = extract_missing_labels_from_error(stderr);
1841        assert_eq!(missing, vec!["type:enhancement".to_string()]);
1842    }
1843
1844    #[test]
1845    fn test_should_return_empty_when_no_label_not_found_in_glab_stderr() {
1846        let stderr = b"glab: Not logged in";
1847        let missing = extract_missing_labels_from_error(stderr);
1848        assert!(missing.is_empty());
1849    }
1850
1851    // --- add_labels: auto-create missing labels ---
1852
1853    #[tokio::test]
1854    async fn test_should_auto_create_label_and_retry_on_add_labels_glab() {
1855        let runner = SequencedMockCommandRunner::from_results(&[
1856            (false, "failed to update ...: 'type:enhancement' not found"),
1857            (true, "Created label type:enhancement"),
1858            (true, ""),
1859        ]);
1860        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1861
1862        let result = provider
1863            .add_labels(18, &["type:enhancement".to_string()])
1864            .await;
1865
1866        assert!(result.is_ok(), "expected Ok, got {result:?}");
1867    }
1868
1869    #[tokio::test]
1870    async fn test_should_propagate_error_when_glab_label_create_fails() {
1871        let runner = SequencedMockCommandRunner::from_results(&[
1872            (false, "failed to update ...: 'ghost' not found"),
1873            (false, "glab: 403 Forbidden"),
1874        ]);
1875        let provider = GitLabIssueProvider::with_runner("o/r", runner);
1876
1877        let result = provider.add_labels(1, &["ghost".to_string()]).await;
1878
1879        assert!(result.is_err());
1880    }
1881
1882    #[tokio::test]
1883    async fn test_should_not_retry_on_non_label_error_glab() {
1884        let runner = SequencedMockCommandRunner::from_results(&[(false, "glab: Not logged in")]);
1885        let provider = GitLabIssueProvider::with_runner("o/r", runner);
1886
1887        let result = provider.add_labels(1, &["bug".to_string()]).await;
1888
1889        assert!(result.is_err());
1890    }
1891
1892    #[tokio::test]
1893    async fn test_should_walk_pages_with_per_page_100_on_glab() {
1894        let runner = MockCommandRunner::success("[]");
1895        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1896        provider
1897            .list(ListIssueArgs::default())
1898            .await
1899            .expect("list should succeed");
1900        let recorded = &runner.recorded_calls()[0].1;
1901        assert!(
1902            recorded
1903                .windows(2)
1904                .any(|w| w[0] == "--per-page" && w[1] == "100"),
1905            "glab 的 --per-page 受 API 限制上限 100,必须按页大小而非总数传,实际 argv: \
1906             {recorded:?}"
1907        );
1908        assert!(
1909            recorded.windows(2).any(|w| w[0] == "--page" && w[1] == "1"),
1910            "必须显式指定页号,实际 argv: {recorded:?}"
1911        );
1912        assert_eq!(
1913            runner.recorded_calls().len(),
1914            1,
1915            "首页为空(短于 per_page)即已取尽,不得请求第 2 页"
1916        );
1917    }
1918
1919    #[tokio::test]
1920    async fn test_should_forward_label_filter_to_glab() {
1921        let runner = MockCommandRunner::success("[]");
1922        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1923        let args = ListIssueArgs {
1924            labels: vec!["bug".to_string()],
1925            ..ListIssueArgs::default()
1926        };
1927        provider.list(args).await.expect("list should succeed");
1928        let recorded = &runner.recorded_calls()[0].1;
1929        assert!(
1930            recorded
1931                .windows(2)
1932                .any(|w| w[0] == "--label" && w[1] == "bug"),
1933            "--label 过滤此前被静默丢弃,必须真正传给 glab,实际 argv: {recorded:?}"
1934        );
1935    }
1936
1937    // --- milestone wiring: create/edit/list ---
1938
1939    /// A single-item `glab milestone list --output json` response resolving to
1940    /// number 3 / title "v2.0", matching `resolve_milestone_identifier`'s contract.
1941    const MILESTONE_LIST_JSON: &str = r#"[
1942        {"id": 30, "iid": 3, "title": "v2.0", "state": "active"}
1943    ]"#;
1944
1945    #[tokio::test]
1946    async fn test_should_wire_resolved_milestone_title_into_issue_create() {
1947        // Sequence:
1948        // 1. milestone resolution: `glab milestone list --project ...`
1949        //    (GitLabMilestoneProvider::list)
1950        // 2. `glab issue create ... --milestone v2.0`
1951        // 3. `glab issue view <number>` (create() delegates to view())
1952        let runner = SequencedMockCommandRunner::from_results(&[
1953            (true, MILESTONE_LIST_JSON),
1954            (true, "http://192.168.230.23/owner/repo/-/issues/42"),
1955            (
1956                true,
1957                r#"{"iid":42,"title":"New feature","description":"Description","state":"opened","labels":[],"milestone":{"id":30,"iid":3,"title":"v2.0","state":"active"},"web_url":"http://192.168.230.23/owner/repo/-/issues/42"}"#,
1958            ),
1959        ]);
1960        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
1961
1962        let mut args = sample_create_args();
1963        args.milestone = Some("3".to_string()); // resolve by number
1964
1965        let issue = provider.create(args).await.expect("create should succeed");
1966        assert_eq!(
1967            issue.milestone,
1968            Some(gitflow_core::types::MilestoneRef {
1969                number: 3,
1970                title: "v2.0".into()
1971            })
1972        );
1973
1974        let calls = runner.recorded_calls();
1975        assert_eq!(calls.len(), 3, "expected exactly 3 glab invocations");
1976        assert!(
1977            calls[0].1.first().map(String::as_str) == Some("milestone"),
1978            "first call must resolve the milestone via `glab milestone list`, got: {:?}",
1979            calls[0].1
1980        );
1981        let create_call = &calls[1].1;
1982        assert!(
1983            create_call
1984                .windows(2)
1985                .any(|w| w[0] == "--milestone" && w[1] == "v2.0"),
1986            "issue create argv must carry the resolved milestone title, got: {create_call:?}"
1987        );
1988    }
1989
1990    #[tokio::test]
1991    async fn test_should_propagate_error_when_milestone_identifier_not_found_on_create() {
1992        // Milestone list resolves to no match for "does-not-exist" → resolve_milestone_identifier
1993        // returns an error before `glab issue create` is ever invoked.
1994        let runner = SequencedMockCommandRunner::from_results(&[(true, MILESTONE_LIST_JSON)]);
1995        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1996
1997        let mut args = sample_create_args();
1998        args.milestone = Some("does-not-exist".to_string());
1999
2000        let result = provider.create(args).await;
2001        assert!(result.is_err());
2002    }
2003
2004    #[tokio::test]
2005    async fn test_should_wire_resolved_milestone_title_into_issue_edit() {
2006        // Sequence:
2007        // 1. milestone resolution
2008        // 2. `glab issue update <number> --milestone v2.0`
2009        // 3. `glab issue view <number>` (edit() delegates to view())
2010        let runner = SequencedMockCommandRunner::from_results(&[
2011            (true, MILESTONE_LIST_JSON),
2012            (true, ""),
2013            (
2014                true,
2015                r#"{"iid":42,"title":"T","description":null,"state":"opened","labels":[],"milestone":{"id":30,"iid":3,"title":"v2.0","state":"active"},"web_url":"http://192.168.230.23/owner/repo/-/issues/42"}"#,
2016            ),
2017        ]);
2018        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
2019
2020        let issue = provider
2021            .edit(
2022                42,
2023                gitflow_core::issue::EditIssueArgs {
2024                    title: None,
2025                    body: None,
2026                    milestone: Some(Some("v2.0".to_string())),
2027                },
2028            )
2029            .await
2030            .expect("edit should succeed");
2031        assert_eq!(issue.milestone.map(|m| m.title), Some("v2.0".to_string()));
2032
2033        let calls = runner.recorded_calls();
2034        let edit_call = &calls[1].1;
2035        assert!(
2036            edit_call
2037                .windows(2)
2038                .any(|w| w[0] == "--milestone" && w[1] == "v2.0"),
2039            "issue edit argv must carry the resolved milestone title, got: {edit_call:?}"
2040        );
2041    }
2042
2043    #[tokio::test]
2044    async fn test_should_send_empty_milestone_flag_to_unassign_without_resolving() {
2045        // `Some(None)` means "clear the milestone". Unlike GitHub's
2046        // `--remove-milestone`, `glab issue update --help` documents
2047        // `--milestone "" ` (or `0`) as the unassign incantation — confirmed
2048        // against 192.168.230.23/iproost/iproost-docs on 2026-09-21. No
2049        // cross-provider resolution call should happen.
2050        let runner = MockCommandRunner::success("");
2051        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
2052
2053        let _ = provider
2054            .edit(
2055                7,
2056                gitflow_core::issue::EditIssueArgs {
2057                    title: None,
2058                    body: None,
2059                    milestone: Some(None),
2060                },
2061            )
2062            .await;
2063
2064        let calls = runner.recorded_calls();
2065        // `edit()` always delegates to `view()` afterward — 2 calls total, neither of
2066        // which is a milestone-resolution `glab milestone list` call.
2067        assert_eq!(calls.len(), 2, "no milestone resolution call expected");
2068        assert!(
2069            calls[0]
2070                .1
2071                .windows(2)
2072                .any(|w| w[0] == "--milestone" && w[1].is_empty()),
2073            "edit argv must carry --milestone \"\", got: {:?}",
2074            calls[0].1
2075        );
2076    }
2077
2078    #[tokio::test]
2079    async fn test_should_wire_resolved_milestone_title_into_issue_list_filter() {
2080        // Sequence:
2081        // 1. milestone resolution
2082        // 2. `glab issue list ... --milestone v2.0`
2083        let runner =
2084            SequencedMockCommandRunner::from_results(&[(true, MILESTONE_LIST_JSON), (true, "[]")]);
2085        let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
2086
2087        let args = ListIssueArgs {
2088            milestone: Some("v2.0".to_string()),
2089            ..ListIssueArgs::default()
2090        };
2091        provider.list(args).await.expect("list should succeed");
2092
2093        let calls = runner.recorded_calls();
2094        let list_call = &calls[1].1;
2095        assert!(
2096            list_call
2097                .windows(2)
2098                .any(|w| w[0] == "--milestone" && w[1] == "v2.0"),
2099            "issue list argv must carry the resolved milestone title, got: {list_call:?}"
2100        );
2101    }
2102
2103    // --- regression: milestone resolution must use the bare repo, not repo_target ---
2104    //
2105    // `glab milestone ...` subcommands take `--project`, which (unlike `--repo`)
2106    // rejects a full git remote URL and 404s. `repo_target` may hold that URL on
2107    // self-hosted instances (see `with_remote_url`'s doc comment and
2108    // <https://gitlab.com/gitlab-org/cli/-/issues/1370>); the milestone-resolution
2109    // provider must always be constructed from the bare `repo` field instead.
2110
2111    #[tokio::test]
2112    async fn test_should_resolve_milestone_against_bare_repo_not_repo_target_for_create() {
2113        let runner = SequencedMockCommandRunner::from_results(&[
2114            (true, MILESTONE_LIST_JSON),
2115            (true, "http://192.168.230.23/owner/repo/-/issues/42"),
2116            (
2117                true,
2118                r#"{"iid":42,"title":"T","description":null,"state":"opened","labels":[]}"#,
2119            ),
2120        ]);
2121        let provider = GitLabIssueProvider::with_runner_and_repo_target(
2122            "owner/repo",
2123            "https://192.168.230.23/iproost/proxy/api-src.git",
2124            runner.clone(),
2125        );
2126
2127        let mut args = sample_create_args();
2128        args.milestone = Some("3".to_string());
2129        provider.create(args).await.expect("create should succeed");
2130
2131        let resolve_call = &runner.recorded_calls()[0].1;
2132        assert!(
2133            resolve_call.iter().any(|a| a == "owner/repo"),
2134            "milestone resolution must target the bare repo, got: {resolve_call:?}"
2135        );
2136        assert!(
2137            !resolve_call
2138                .iter()
2139                .any(|a| a.contains("192.168.230.23/iproost/proxy")),
2140            "milestone resolution must NOT use repo_target's remote URL, got: {resolve_call:?}"
2141        );
2142    }
2143
2144    #[tokio::test]
2145    async fn test_should_resolve_milestone_against_bare_repo_not_repo_target_for_edit() {
2146        let runner = SequencedMockCommandRunner::from_results(&[
2147            (true, MILESTONE_LIST_JSON),
2148            (true, ""),
2149            (
2150                true,
2151                r#"{"iid":42,"title":"T","description":null,"state":"opened","labels":[]}"#,
2152            ),
2153        ]);
2154        let provider = GitLabIssueProvider::with_runner_and_repo_target(
2155            "owner/repo",
2156            "https://192.168.230.23/iproost/proxy/api-src.git",
2157            runner.clone(),
2158        );
2159
2160        provider
2161            .edit(
2162                42,
2163                gitflow_core::issue::EditIssueArgs {
2164                    title: None,
2165                    body: None,
2166                    milestone: Some(Some("v2.0".to_string())),
2167                },
2168            )
2169            .await
2170            .expect("edit should succeed");
2171
2172        let resolve_call = &runner.recorded_calls()[0].1;
2173        assert!(
2174            resolve_call.iter().any(|a| a == "owner/repo"),
2175            "milestone resolution must target the bare repo, got: {resolve_call:?}"
2176        );
2177        assert!(
2178            !resolve_call
2179                .iter()
2180                .any(|a| a.contains("192.168.230.23/iproost/proxy")),
2181            "milestone resolution must NOT use repo_target's remote URL, got: {resolve_call:?}"
2182        );
2183    }
2184
2185    #[tokio::test]
2186    async fn test_should_resolve_milestone_against_bare_repo_not_repo_target_for_list() {
2187        let runner =
2188            SequencedMockCommandRunner::from_results(&[(true, MILESTONE_LIST_JSON), (true, "[]")]);
2189        let provider = GitLabIssueProvider::with_runner_and_repo_target(
2190            "owner/repo",
2191            "https://192.168.230.23/iproost/proxy/api-src.git",
2192            runner.clone(),
2193        );
2194
2195        let args = ListIssueArgs {
2196            milestone: Some("v2.0".to_string()),
2197            ..ListIssueArgs::default()
2198        };
2199        provider.list(args).await.expect("list should succeed");
2200
2201        let resolve_call = &runner.recorded_calls()[0].1;
2202        assert!(
2203            resolve_call.iter().any(|a| a == "owner/repo"),
2204            "milestone resolution must target the bare repo, got: {resolve_call:?}"
2205        );
2206        assert!(
2207            !resolve_call
2208                .iter()
2209                .any(|a| a.contains("192.168.230.23/iproost/proxy")),
2210            "milestone resolution must NOT use repo_target's remote URL, got: {resolve_call:?}"
2211        );
2212    }
2213}
2214
2215#[cfg(test)]
2216mod contract_tests {
2217    use super::*;
2218    use crate::runner::MockCommandRunner;
2219
2220    /// 契约测试:验证 glab issue list JSON 输出与反序列化一致。
2221    ///
2222    /// 夹具来源:glab v1.x `--output json` 格式。
2223    #[tokio::test]
2224    async fn test_contract_issue_list_gitlab_v1() {
2225        let fixture = include_str!("../tests/fixtures/issue_list_gitlab_v1.json");
2226        let runner = MockCommandRunner::success(fixture);
2227        let provider = GitLabIssueProvider::with_runner("group/project", runner);
2228
2229        let issues = provider
2230            .list(ListIssueArgs::default())
2231            .await
2232            .expect("contract fixture must parse");
2233        let issues = issues.items;
2234
2235        assert_eq!(issues.len(), 1);
2236        let issue = &issues[0];
2237        assert_eq!(issue.number, 10);
2238        assert!(!issue.title.is_empty());
2239        assert_eq!(issue.state, gitflow_core::types::State::Open);
2240    }
2241}