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, Result,
15    issue::{CreateIssueArgs, IssueData, IssueProvider, ListIssueArgs},
16    types::{CommentData, Label, State, UserSummary},
17};
18use serde::Deserialize;
19use tracing::debug;
20
21use crate::{
22    error::parse_glab_error,
23    runner::{CommandRunner, RealCommandRunner},
24};
25
26/// GitLab Issue 提供者,通过 `glab` CLI 操作。
27///
28/// 该结构体通过调用 `glab` CLI 实现 [`IssueProvider`] trait 的所有方法,
29/// 使上层命令能够以统一的方式操作 GitLab Issue。
30///
31/// 命令执行通过 [`CommandRunner`] 抽象,生产环境默认使用
32/// [`RealCommandRunner`],测试可注入自定义 runner 以模拟成功或失败场景。
33///
34/// # Examples
35///
36/// ```no_run
37/// use gitflow_gitlab::GitLabIssueProvider;
38///
39/// let provider = GitLabIssueProvider::new("gitlab-org/gitlab");
40/// ```
41#[derive(Debug, Clone)]
42pub struct GitLabIssueProvider<R: CommandRunner = RealCommandRunner> {
43    /// GitLab `namespace/project`,如 `"gitlab-org/gitlab"`。
44    repo: String,
45    /// 用于执行 `glab` CLI 命令的 runner。
46    runner: R,
47}
48
49impl GitLabIssueProvider<RealCommandRunner> {
50    /// 创建新的 GitLab Issue 提供者,使用真实的进程执行器。
51    ///
52    /// `repo` 格式为 `namespace/project`。
53    #[must_use]
54    pub fn new(repo: impl Into<String>) -> Self {
55        Self {
56            repo: repo.into(),
57            runner: RealCommandRunner,
58        }
59    }
60}
61
62impl<R: CommandRunner> GitLabIssueProvider<R> {
63    /// 使用自定义 [`CommandRunner`] 创建提供者。
64    ///
65    /// 主要用于测试,可注入模拟 runner 以控制 `glab` CLI 的输出。
66    /// `repo` 格式为 `namespace/project`。
67    #[must_use]
68    pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
69        Self {
70            repo: repo.into(),
71            runner,
72        }
73    }
74
75    /// 创建缺失的标签。
76    ///
77    /// 调用 `glab label create --name <name> --color <color> --repo <repo>`。
78    ///
79    /// # Errors
80    ///
81    /// 当 `glab label create` 调用失败时返回错误。
82    async fn ensure_label_exists(&self, name: &str) -> Result<()> {
83        debug!(repo = %self.repo, name, "auto-creating missing label via `glab label create`");
84
85        let output = self
86            .runner
87            .run(
88                "glab",
89                &[
90                    "label", "create", "--name", name, "--color", "ededed", "--repo", &self.repo,
91                ],
92            )
93            .await
94            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab label create: {e}")))?;
95
96        if !output.status.success() {
97            let glab_err = parse_glab_error(&output.stderr);
98            tracing::debug!(error = %glab_err, "Failed to auto-create label");
99            return Err(CoreError::Platform(format!(
100                "Failed to auto-create label '{name}': {}",
101                glab_err.user_message
102            )));
103        }
104
105        Ok(())
106    }
107}
108
109// ── 中间 API 响应类型 ──────────────────────────────────────────────
110
111/// `glab issue` JSON 输出中的用户信息。
112#[derive(Debug, Clone, Deserialize)]
113struct ApiUser {
114    username: String,
115    #[serde(default)]
116    id: u64,
117}
118
119impl From<&ApiUser> for UserSummary {
120    fn from(u: &ApiUser) -> Self {
121        Self {
122            login: u.username.clone(),
123            id: u.id.to_string(),
124        }
125    }
126}
127
128/// `glab issue --output json` 返回的 JSON 结构。
129#[derive(Debug, Clone, Deserialize)]
130struct IssueApiResponse {
131    iid: u64,
132    title: String,
133    #[serde(default)]
134    description: Option<String>,
135    state: String,
136    #[serde(default)]
137    labels: Vec<String>,
138    #[serde(default)]
139    author: Option<ApiUser>,
140    #[serde(default)]
141    assignees: Vec<ApiUser>,
142    #[serde(default)]
143    created_at: Option<DateTime<Utc>>,
144    #[serde(default)]
145    updated_at: Option<DateTime<Utc>>,
146    #[serde(default)]
147    web_url: Option<String>,
148}
149
150impl From<IssueApiResponse> for IssueData {
151    fn from(api: IssueApiResponse) -> Self {
152        let now = Utc::now();
153        let labels: Vec<Label> = api
154            .labels
155            .into_iter()
156            .map(|name| Label {
157                name,
158                color: None,
159                description: None,
160            })
161            .collect();
162        let author = api.author.as_ref().map_or_else(
163            || UserSummary {
164                login: "unknown".into(),
165                id: "0".to_string(),
166            },
167            UserSummary::from,
168        );
169
170        Self {
171            number: api.iid,
172            title: api.title,
173            body: api.description,
174            state: if api.state == "closed" {
175                State::Closed
176            } else {
177                State::Open
178            },
179            labels,
180            author,
181            assignees: api.assignees.iter().map(UserSummary::from).collect(),
182            created_at: api.created_at.unwrap_or(now),
183            updated_at: api.updated_at.unwrap_or(now),
184            url: api.web_url.unwrap_or_default(),
185        }
186    }
187}
188
189/// `glab issue comment --output json` 返回的 JSON 结构。
190#[derive(Debug, Clone, Deserialize)]
191struct CommentApiResponse {
192    id: u64,
193    #[serde(default)]
194    body: String,
195    #[serde(default)]
196    author: Option<ApiUser>,
197    #[serde(default)]
198    created_at: Option<DateTime<Utc>>,
199}
200
201impl From<CommentApiResponse> for CommentData {
202    fn from(api: CommentApiResponse) -> Self {
203        let author = api.author.as_ref().map_or_else(
204            || UserSummary {
205                login: "unknown".into(),
206                id: "0".to_string(),
207            },
208            UserSummary::from,
209        );
210        Self {
211            id: api.id,
212            body: api.body,
213            author,
214            created_at: api.created_at.unwrap_or_else(Utc::now),
215        }
216    }
217}
218
219// ── trait 实现 ──────────────────────────────────────────────────────
220
221#[async_trait]
222impl<R: CommandRunner + 'static> IssueProvider for GitLabIssueProvider<R> {
223    async fn create(&self, args: CreateIssueArgs) -> Result<IssueData> {
224        let labels_joined = args.labels.join(",");
225        let assignees_joined = args.assignees.join(",");
226
227        let mut cmd_args: Vec<&str> = vec![
228            "issue",
229            "create",
230            "--repo",
231            &self.repo,
232            "--title",
233            &args.title,
234        ];
235
236        if let Some(body) = &args.body {
237            cmd_args.push("--description");
238            cmd_args.push(body);
239        }
240
241        if !args.labels.is_empty() {
242            cmd_args.push("--label");
243            cmd_args.push(&labels_joined);
244        }
245
246        if !args.assignees.is_empty() {
247            cmd_args.push("--assignee");
248            cmd_args.push(&assignees_joined);
249        }
250
251        debug!(repo = %self.repo, title = %args.title, "spawning `glab issue create`");
252
253        let output = self
254            .runner
255            .run("glab", &cmd_args)
256            .await
257            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
258
259        if !output.status.success() {
260            // `glab issue create` may fail when a requested label doesn't exist.
261            // Auto-create missing labels and retry once.
262            let missing = extract_missing_labels_from_error(&output.stderr);
263            if !missing.is_empty() {
264                debug!(
265                    repo = %self.repo,
266                    missing_count = missing.len(),
267                    "auto-creating missing label(s) before retrying issue create"
268                );
269                for label in &missing {
270                    self.ensure_label_exists(label).await?;
271                }
272
273                let retry_output = self.runner.run("glab", &cmd_args).await.map_err(|e| {
274                    CoreError::Platform(format!("Failed to spawn glab on retry: {e}"))
275                })?;
276
277                if !retry_output.status.success() {
278                    return Err(parse_glab_error(&retry_output.stderr).into());
279                }
280
281                let stdout = String::from_utf8_lossy(&retry_output.stdout);
282                let issue_iid = parse_issue_iid_from_url(&stdout).ok_or_else(|| {
283                    CoreError::Platform(format!("Failed to parse issue URL from output: {stdout}"))
284                })?;
285                return self.view(issue_iid).await;
286            }
287
288            return Err(parse_glab_error(&output.stderr).into());
289        }
290
291        // Parse the issue URL from stdout (format: https://gitlab.com/.../-/issues/123)
292        let stdout = String::from_utf8_lossy(&output.stdout);
293        let issue_iid = parse_issue_iid_from_url(&stdout).ok_or_else(|| {
294            CoreError::Platform(format!("Failed to parse issue URL from output: {stdout}"))
295        })?;
296
297        // Fetch full issue details via view
298        self.view(issue_iid).await
299    }
300
301    async fn list(&self, args: ListIssueArgs) -> Result<Vec<IssueData>> {
302        let mut cmd_args: Vec<&str> =
303            vec!["issue", "list", "--repo", &self.repo, "--output", "json"];
304
305        // glab uses --closed for closed issues, --all for all issues
306        // Default (no flag) shows open issues
307        if let Some(state) = &args.state
308            && matches!(state, State::Closed)
309        {
310            cmd_args.push("--closed");
311        }
312
313        if let Some(ref search) = args.search {
314            cmd_args.push("--search");
315            cmd_args.push(search);
316        }
317
318        let limit_str = args.limit.map(|limit| limit.to_string());
319        if let Some(ref limit) = limit_str {
320            cmd_args.push("--per-page");
321            cmd_args.push(limit);
322        }
323
324        debug!(repo = %self.repo, "spawning `glab issue list`");
325
326        let output = self
327            .runner
328            .run("glab", &cmd_args)
329            .await
330            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
331
332        if !output.status.success() {
333            return Err(parse_glab_error(&output.stderr).into());
334        }
335
336        let api_responses: Vec<IssueApiResponse> =
337            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
338
339        Ok(api_responses.into_iter().map(IssueData::from).collect())
340    }
341
342    async fn view(&self, number: u64) -> Result<IssueData> {
343        debug!(repo = %self.repo, number, "spawning `glab issue view`");
344
345        let number_str = number.to_string();
346        let output = self
347            .runner
348            .run(
349                "glab",
350                &[
351                    "issue",
352                    "view",
353                    &number_str,
354                    "--repo",
355                    &self.repo,
356                    "--output",
357                    "json",
358                ],
359            )
360            .await
361            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
362
363        if !output.status.success() {
364            return Err(parse_glab_error(&output.stderr).into());
365        }
366
367        let api_response: IssueApiResponse =
368            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
369
370        Ok(api_response.into())
371    }
372
373    /// 关闭指定编号的 Issue。
374    ///
375    /// 调用 `glab issue close <number> --repo <repo> --output json` 关闭 Issue,
376    /// 并返回更新后的完整 Issue 数据。
377    ///
378    /// # Errors
379    ///
380    /// 当 Issue 不存在、已关闭或 `glab` CLI 调用失败时返回错误。
381    async fn close(&self, number: u64) -> Result<IssueData> {
382        debug!(repo = %self.repo, number, "spawning `glab issue close`");
383
384        let number_str = number.to_string();
385        let output = self
386            .runner
387            .run(
388                "glab",
389                &[
390                    "issue",
391                    "close",
392                    &number_str,
393                    "--repo",
394                    &self.repo,
395                    "--output",
396                    "json",
397                ],
398            )
399            .await
400            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
401
402        if !output.status.success() {
403            return Err(parse_glab_error(&output.stderr).into());
404        }
405
406        let api_response: IssueApiResponse =
407            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
408
409        Ok(api_response.into())
410    }
411
412    /// 重新打开指定编号的 Issue。
413    ///
414    /// 调用 `glab issue reopen <number> --repo <repo> --output json` 重新打开已关闭的 Issue,
415    /// 并返回更新后的完整 Issue 数据。
416    ///
417    /// # Errors
418    ///
419    /// 当 Issue 不存在、未关闭或 `glab` CLI 调用失败时返回错误。
420    async fn reopen(&self, number: u64) -> Result<IssueData> {
421        debug!(repo = %self.repo, number, "spawning `glab issue reopen`");
422
423        let number_str = number.to_string();
424        let output = self
425            .runner
426            .run(
427                "glab",
428                &[
429                    "issue",
430                    "reopen",
431                    &number_str,
432                    "--repo",
433                    &self.repo,
434                    "--output",
435                    "json",
436                ],
437            )
438            .await
439            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
440
441        if !output.status.success() {
442            return Err(parse_glab_error(&output.stderr).into());
443        }
444
445        let api_response: IssueApiResponse =
446            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
447
448        Ok(api_response.into())
449    }
450
451    /// 在指定 Issue 上添加评论。
452    ///
453    /// 调用 `glab issue note <number> --repo <repo> --body "<body>" --output json` 发布评论,
454    /// 并返回评论文数据。
455    ///
456    /// # Errors
457    ///
458    /// 当 Issue 不存在、`body` 为空或 `glab` CLI 调用失败时返回错误。
459    async fn comment(&self, number: u64, body: &str) -> Result<CommentData> {
460        debug!(repo = %self.repo, number, "spawning `glab issue note`");
461
462        let number_str = number.to_string();
463        let output = self
464            .runner
465            .run(
466                "glab",
467                &[
468                    "issue",
469                    "note",
470                    &number_str,
471                    "--repo",
472                    &self.repo,
473                    "--body",
474                    body,
475                    "--output",
476                    "json",
477                ],
478            )
479            .await
480            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
481
482        if !output.status.success() {
483            return Err(parse_glab_error(&output.stderr).into());
484        }
485
486        let api_response: CommentApiResponse =
487            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
488
489        Ok(api_response.into())
490    }
491
492    /// 为指定 Issue 添加一个或多个标签。
493    ///
494    /// 调用 `glab issue edit <number> --repo <repo> --add-label <labels>` 添加标签,
495    /// 多个标签以逗号连接后一次性提交。
496    ///
497    /// # 自动创建缺失标签
498    ///
499    /// 当 `glab issue edit --add-label` 因标签不存在而失败时,本方法会自动调用
500    /// `glab label create` 创建缺失的标签(使用默认颜色 `ededed`),然后重试原操作。
501    ///
502    /// # Errors
503    ///
504    /// 当 Issue 不存在、标签创建失败或 `glab` CLI 调用失败时返回错误。
505    async fn add_labels(&self, number: u64, labels: &[String]) -> Result<()> {
506        debug!(
507            repo = %self.repo,
508            number,
509            label_count = labels.len(),
510            "spawning `glab issue edit --add-label`"
511        );
512
513        let labels_joined = labels.join(",");
514        let number_str = number.to_string();
515        let cmd_args: Vec<&str> = vec![
516            "issue",
517            "edit",
518            &number_str,
519            "--repo",
520            &self.repo,
521            "--add-label",
522            &labels_joined,
523        ];
524        let output = self
525            .runner
526            .run("glab", &cmd_args)
527            .await
528            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
529
530        if output.status.success() {
531            return Ok(());
532        }
533
534        // glab issue edit --add-label may fail when a label doesn't exist.
535        // Try to auto-create missing labels and retry once.
536        let missing = extract_missing_labels_from_error(&output.stderr);
537        if missing.is_empty() {
538            return Err(parse_glab_error(&output.stderr).into());
539        }
540
541        debug!(
542            repo = %self.repo,
543            missing_count = missing.len(),
544            "auto-creating missing label(s) before retry"
545        );
546
547        for label in &missing {
548            self.ensure_label_exists(label).await?;
549        }
550
551        let retry_output = self
552            .runner
553            .run("glab", &cmd_args)
554            .await
555            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab on retry: {e}")))?;
556
557        if !retry_output.status.success() {
558            return Err(parse_glab_error(&retry_output.stderr).into());
559        }
560
561        Ok(())
562    }
563
564    /// 从指定 Issue 移除一个标签。
565    ///
566    /// 调用 `glab issue edit <number> --repo <repo> --remove-label <label>` 移除标签。
567    ///
568    /// # Errors
569    ///
570    /// 当 Issue 不存在、标签未附加到该 Issue 或 `glab` CLI 调用失败时返回错误。
571    async fn remove_label(&self, number: u64, label: &str) -> Result<()> {
572        debug!(repo = %self.repo, number, label, "spawning `glab issue edit --remove-label`");
573
574        let number_str = number.to_string();
575        let output = self
576            .runner
577            .run(
578                "glab",
579                &[
580                    "issue",
581                    "edit",
582                    &number_str,
583                    "--repo",
584                    &self.repo,
585                    "--remove-label",
586                    label,
587                ],
588            )
589            .await
590            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
591
592        if !output.status.success() {
593            return Err(parse_glab_error(&output.stderr).into());
594        }
595
596        Ok(())
597    }
598}
599
600/// 从 `glab issue edit --add-label` 的 stderr 中提取缺失的标签名。
601///
602/// GitLab CLI 的错误格式可能有多种变体,本函数尝试匹配常见的
603/// `'<label>' not found` / `"label not found: <label>"` 模式。
604/// 未匹配时返回空列表,调用方据此判断是否为"标签缺失"错误。
605fn extract_missing_labels_from_error(stderr: &[u8]) -> Vec<String> {
606    let text = String::from_utf8_lossy(stderr);
607    let mut labels = Vec::new();
608    let mut search_from: usize = 0;
609
610    // 模式 1: '<label>' not found (与 gh/gitcode 一致)
611    while let Some(rel_open) = text[search_from..].find('\'') {
612        let open_pos = search_from + rel_open + 1;
613        let Some(rel_close) = text[open_pos..].find('\'') else {
614            break;
615        };
616        let close_pos = open_pos + rel_close;
617        let after_close = &text[close_pos + 1..];
618
619        if after_close.starts_with(" not found") {
620            let label = text[open_pos..close_pos].to_string();
621            if !label.is_empty() {
622                labels.push(label);
623            }
624        }
625        search_from = close_pos + 1;
626    }
627
628    labels
629}
630
631/// Parse issue IID from GitLab URL.
632///
633/// Extracts the numeric IID from URLs like:
634/// - `https://gitlab.com/owner/repo/-/issues/123`
635/// - `https://gitlab.example.com/group/project/-/issues/456`
636fn parse_issue_iid_from_url(url: &str) -> Option<u64> {
637    url.lines().find_map(|line| {
638        let line = line.trim();
639        if line.contains("/-/issues/") {
640            line.rsplit("/-/issues/")
641                .next()
642                .and_then(|s| s.split('/').next())
643                .and_then(|s| s.parse().ok())
644        } else {
645            None
646        }
647    })
648}
649
650#[cfg(test)]
651mod tests {
652    use super::*;
653    use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
654
655    #[test]
656    fn test_should_construct_gitlab_issue_provider() {
657        let provider = GitLabIssueProvider::new("gitlab-org/gitlab");
658        assert_eq!(provider.repo, "gitlab-org/gitlab");
659    }
660
661    #[test]
662    fn test_should_construct_gitlab_issue_provider_from_string() {
663        let repo = String::from("gitlab-org/gitlab");
664        let provider = GitLabIssueProvider::new(repo);
665        assert_eq!(provider.repo, "gitlab-org/gitlab");
666    }
667
668    #[test]
669    fn test_should_deserialize_issue_api_response() {
670        let json = br#"{
671            "iid": 42,
672            "title": "Fix login bug",
673            "description": "Reproduced on v1.2.3",
674            "state": "opened",
675            "labels": ["bug", "critical"],
676            "author": {"username": "admin", "id": 1},
677            "assignees": [{"username": "alice", "id": 7}],
678            "created_at": "2026-01-15T09:30:00Z",
679            "updated_at": "2026-01-16T11:00:00Z",
680            "web_url": "https://gitlab.com/gitlab-org/gitlab/-/issues/42"
681        }"#;
682
683        let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
684        let issue: IssueData = api.into();
685
686        assert_eq!(issue.number, 42);
687        assert_eq!(issue.title, "Fix login bug");
688        assert_eq!(issue.body.as_deref(), Some("Reproduced on v1.2.3"));
689        assert_eq!(issue.state, State::Open);
690        assert_eq!(issue.labels.len(), 2);
691        assert_eq!(issue.labels[0].name, "bug");
692        assert_eq!(issue.author.login, "admin");
693        assert_eq!(issue.assignees.len(), 1);
694        assert_eq!(
695            issue.url,
696            "https://gitlab.com/gitlab-org/gitlab/-/issues/42"
697        );
698    }
699
700    #[test]
701    fn test_should_deserialize_closed_issue_api_response() {
702        let json = br#"{
703            "iid": 10,
704            "title": "Fixed typo",
705            "description": null,
706            "state": "closed",
707            "labels": [],
708            "author": {"username": "dev", "id": 5},
709            "assignees": [],
710            "created_at": "2026-06-01T08:00:00Z",
711            "updated_at": "2026-06-02T12:00:00Z",
712            "web_url": "https://gitlab.com/org/project/-/issues/10"
713        }"#;
714
715        let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
716        let issue: IssueData = api.into();
717        assert_eq!(issue.state, State::Closed);
718    }
719
720    #[test]
721    fn test_should_deserialize_comment_api_response() {
722        let json = br#"{
723            "id": 1001,
724            "body": "Thanks for reporting.",
725            "author": {"username": "maintainer", "id": 42},
726            "created_at": "2026-06-15T14:00:00Z"
727        }"#;
728
729        let api: CommentApiResponse =
730            serde_json::from_slice(json).expect("valid CommentApiResponse");
731        let comment: CommentData = api.into();
732        assert_eq!(comment.id, 1001);
733        assert_eq!(comment.body, "Thanks for reporting.");
734        assert_eq!(comment.author.login, "maintainer");
735    }
736
737    #[test]
738    fn test_should_handle_missing_author_with_fallback() {
739        let json = br#"{
740            "iid": 1,
741            "title": "No author",
742            "description": null,
743            "state": "opened",
744            "labels": [],
745            "author": null,
746            "assignees": [],
747            "created_at": null,
748            "updated_at": null,
749            "web_url": null
750        }"#;
751
752        let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
753        let issue: IssueData = api.into();
754        assert_eq!(issue.author.login, "unknown");
755        assert_eq!(issue.author.id, "0");
756    }
757
758    #[test]
759    fn test_should_convert_labels_from_strings() {
760        let json = br#"{
761            "iid": 1,
762            "title": "Test",
763            "description": null,
764            "state": "opened",
765            "labels": ["bug", "enhancement", "documentation"],
766            "author": {"username": "admin", "id": 1},
767            "assignees": [],
768            "created_at": "2026-01-01T00:00:00Z",
769            "updated_at": "2026-01-01T00:00:00Z",
770            "web_url": "https://gitlab.com/x/y/-/issues/1"
771        }"#;
772
773        let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
774        let issue: IssueData = api.into();
775        assert_eq!(issue.labels.len(), 3);
776        assert_eq!(issue.labels[0].name, "bug");
777        assert_eq!(issue.labels[1].name, "enhancement");
778        assert!(issue.labels[0].color.is_none());
779    }
780
781    #[test]
782    fn test_should_deserialize_empty_issue_list() {
783        let json = b"[]";
784        let list: Vec<IssueApiResponse> = serde_json::from_slice(json).expect("valid empty list");
785        assert!(list.is_empty());
786    }
787
788    #[test]
789    fn test_should_debug_format_provider() {
790        let provider = GitLabIssueProvider::new("gitlab-org/gitlab");
791        let debug = format!("{provider:?}");
792        assert!(debug.contains("GitLabIssueProvider"));
793        assert!(debug.contains("gitlab-org/gitlab"));
794    }
795
796    #[test]
797    fn test_should_clone_gitlab_issue_provider() {
798        let original = GitLabIssueProvider::new("owner/repo");
799        let cloned = original.clone();
800        assert_eq!(original.repo, cloned.repo);
801    }
802
803    #[test]
804    fn test_should_parse_issue_iid_from_gitlab_url() {
805        assert_eq!(
806            parse_issue_iid_from_url("https://gitlab.com/owner/repo/-/issues/123"),
807            Some(123)
808        );
809    }
810
811    #[test]
812    fn test_should_parse_issue_iid_from_self_hosted_url() {
813        assert_eq!(
814            parse_issue_iid_from_url("https://gitlab.example.com/group/project/-/issues/456"),
815            Some(456)
816        );
817    }
818
819    #[test]
820    fn test_should_parse_issue_iid_from_multiline_output() {
821        let output = "Creating issue...\nhttps://gitlab.com/owner/repo/-/issues/789\nDone.";
822        assert_eq!(parse_issue_iid_from_url(output), Some(789));
823    }
824
825    #[test]
826    fn test_should_return_none_for_invalid_url() {
827        assert_eq!(parse_issue_iid_from_url("not a url"), None);
828    }
829
830    #[test]
831    fn test_should_return_none_for_url_without_iid() {
832        assert_eq!(
833            parse_issue_iid_from_url("https://gitlab.com/owner/repo/-/issues/"),
834            None
835        );
836    }
837
838    // --- Failure-path tests using an injected MockCommandRunner ---
839
840    #[tokio::test]
841    async fn test_should_return_platform_error_when_glab_fails_for_view() {
842        let runner = MockCommandRunner::failure(r#"{"message": "Issue not found"}"#, 256);
843        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
844
845        let result = provider.view(999).await;
846
847        assert!(result.is_err());
848        assert!(matches!(
849            result.unwrap_err(),
850            gitflow_core::CoreError::Cli(_)
851        ));
852    }
853
854    #[tokio::test]
855    async fn test_should_return_serialization_error_on_invalid_json_for_view() {
856        let runner = MockCommandRunner::success("not valid json");
857        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
858
859        let result = provider.view(1).await;
860
861        assert!(result.is_err());
862        assert!(matches!(
863            result.unwrap_err(),
864            gitflow_core::CoreError::Serialization(_)
865        ));
866    }
867
868    #[tokio::test]
869    async fn test_should_return_platform_error_when_glab_fails_for_list() {
870        let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
871        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
872
873        let result = provider.list(ListIssueArgs::default()).await;
874
875        assert!(result.is_err());
876        assert!(matches!(
877            result.unwrap_err(),
878            gitflow_core::CoreError::Cli(_)
879        ));
880    }
881
882    #[tokio::test]
883    async fn test_should_return_serialization_error_on_invalid_json_for_list() {
884        let runner = MockCommandRunner::success("invalid");
885        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
886
887        let result = provider.list(ListIssueArgs::default()).await;
888
889        assert!(result.is_err());
890        assert!(matches!(
891            result.unwrap_err(),
892            gitflow_core::CoreError::Serialization(_)
893        ));
894    }
895
896    fn sample_create_args() -> CreateIssueArgs {
897        CreateIssueArgs {
898            title: "Bug report".to_string(),
899            body: Some("Steps to reproduce".to_string()),
900            labels: vec!["bug".to_string()],
901            assignees: vec!["alice".to_string()],
902        }
903    }
904
905    #[tokio::test]
906    async fn test_should_return_platform_error_when_glab_fails_for_create() {
907        let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
908        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
909
910        let result = provider.create(sample_create_args()).await;
911
912        assert!(result.is_err());
913        assert!(matches!(
914            result.unwrap_err(),
915            gitflow_core::CoreError::Cli(_)
916        ));
917    }
918
919    #[tokio::test]
920    async fn test_should_return_serialization_error_on_invalid_json_for_create() {
921        // `create` succeeds and parses the issue IID from this URL, then delegates
922        // to `view`, which receives the same non-JSON stdout and fails to deserialize.
923        let runner = MockCommandRunner::success("https://gitlab.com/owner/repo/-/issues/7");
924        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
925
926        let result = provider.create(sample_create_args()).await;
927
928        assert!(result.is_err());
929        assert!(matches!(
930            result.unwrap_err(),
931            gitflow_core::CoreError::Serialization(_)
932        ));
933    }
934
935    #[tokio::test]
936    async fn test_should_return_platform_error_when_glab_fails_for_close() {
937        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
938        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
939
940        let result = provider.close(42).await;
941
942        assert!(result.is_err());
943        assert!(matches!(
944            result.unwrap_err(),
945            gitflow_core::CoreError::Cli(_)
946        ));
947    }
948
949    #[tokio::test]
950    async fn test_should_return_serialization_error_on_invalid_json_for_close() {
951        let runner = MockCommandRunner::success("invalid");
952        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
953
954        let result = provider.close(42).await;
955
956        assert!(result.is_err());
957        assert!(matches!(
958            result.unwrap_err(),
959            gitflow_core::CoreError::Serialization(_)
960        ));
961    }
962
963    #[tokio::test]
964    async fn test_should_return_platform_error_when_glab_fails_for_reopen() {
965        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
966        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
967
968        let result = provider.reopen(42).await;
969
970        assert!(result.is_err());
971        assert!(matches!(
972            result.unwrap_err(),
973            gitflow_core::CoreError::Cli(_)
974        ));
975    }
976
977    #[tokio::test]
978    async fn test_should_return_serialization_error_on_invalid_json_for_reopen() {
979        let runner = MockCommandRunner::success("invalid");
980        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
981
982        let result = provider.reopen(42).await;
983
984        assert!(result.is_err());
985        assert!(matches!(
986            result.unwrap_err(),
987            gitflow_core::CoreError::Serialization(_)
988        ));
989    }
990
991    #[tokio::test]
992    async fn test_should_return_platform_error_when_glab_fails_for_comment() {
993        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
994        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
995
996        let result = provider.comment(42, "a comment").await;
997
998        assert!(result.is_err());
999        assert!(matches!(
1000            result.unwrap_err(),
1001            gitflow_core::CoreError::Cli(_)
1002        ));
1003    }
1004
1005    #[tokio::test]
1006    async fn test_should_return_serialization_error_on_invalid_json_for_comment() {
1007        let runner = MockCommandRunner::success("invalid");
1008        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1009
1010        let result = provider.comment(42, "a comment").await;
1011
1012        assert!(result.is_err());
1013        assert!(matches!(
1014            result.unwrap_err(),
1015            gitflow_core::CoreError::Serialization(_)
1016        ));
1017    }
1018
1019    #[tokio::test]
1020    async fn test_should_return_platform_error_when_glab_fails_for_add_labels() {
1021        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1022        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1023
1024        let result = provider.add_labels(42, &["bug".to_string()]).await;
1025
1026        assert!(result.is_err());
1027        assert!(matches!(
1028            result.unwrap_err(),
1029            gitflow_core::CoreError::Cli(_)
1030        ));
1031    }
1032
1033    #[tokio::test]
1034    async fn test_should_return_platform_error_when_glab_fails_for_remove_label() {
1035        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
1036        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1037
1038        let result = provider.remove_label(42, "bug").await;
1039
1040        assert!(result.is_err());
1041        assert!(matches!(
1042            result.unwrap_err(),
1043            gitflow_core::CoreError::Cli(_)
1044        ));
1045    }
1046
1047    // --- extract_missing_labels_from_error: pure-function tests ---
1048
1049    #[test]
1050    fn test_should_extract_single_missing_label_from_glab_stderr() {
1051        let stderr = b"failed to update ...: 'type:enhancement' not found";
1052        let missing = extract_missing_labels_from_error(stderr);
1053        assert_eq!(missing, vec!["type:enhancement".to_string()]);
1054    }
1055
1056    #[test]
1057    fn test_should_return_empty_when_no_label_not_found_in_glab_stderr() {
1058        let stderr = b"glab: Not logged in";
1059        let missing = extract_missing_labels_from_error(stderr);
1060        assert!(missing.is_empty());
1061    }
1062
1063    // --- add_labels: auto-create missing labels ---
1064
1065    #[tokio::test]
1066    async fn test_should_auto_create_label_and_retry_on_add_labels_glab() {
1067        let runner = SequencedMockCommandRunner::from_results(&[
1068            (false, "failed to update ...: 'type:enhancement' not found"),
1069            (true, "Created label type:enhancement"),
1070            (true, ""),
1071        ]);
1072        let provider = GitLabIssueProvider::with_runner("owner/repo", runner);
1073
1074        let result = provider
1075            .add_labels(18, &["type:enhancement".to_string()])
1076            .await;
1077
1078        assert!(result.is_ok(), "expected Ok, got {result:?}");
1079    }
1080
1081    #[tokio::test]
1082    async fn test_should_propagate_error_when_glab_label_create_fails() {
1083        let runner = SequencedMockCommandRunner::from_results(&[
1084            (false, "failed to update ...: 'ghost' not found"),
1085            (false, "glab: 403 Forbidden"),
1086        ]);
1087        let provider = GitLabIssueProvider::with_runner("o/r", runner);
1088
1089        let result = provider.add_labels(1, &["ghost".to_string()]).await;
1090
1091        assert!(result.is_err());
1092    }
1093
1094    #[tokio::test]
1095    async fn test_should_not_retry_on_non_label_error_glab() {
1096        let runner = SequencedMockCommandRunner::from_results(&[(false, "glab: Not logged in")]);
1097        let provider = GitLabIssueProvider::with_runner("o/r", runner);
1098
1099        let result = provider.add_labels(1, &["bug".to_string()]).await;
1100
1101        assert!(result.is_err());
1102    }
1103}
1104
1105#[cfg(test)]
1106mod contract_tests {
1107    use super::*;
1108    use crate::runner::MockCommandRunner;
1109
1110    /// 契约测试:验证 glab issue list JSON 输出与反序列化一致。
1111    ///
1112    /// 夹具来源:glab v1.x `--output json` 格式。
1113    #[tokio::test]
1114    async fn test_contract_issue_list_gitlab_v1() {
1115        let fixture = include_str!("../tests/fixtures/issue_list_gitlab_v1.json");
1116        let runner = MockCommandRunner::success(fixture);
1117        let provider = GitLabIssueProvider::with_runner("group/project", runner);
1118
1119        let issues = provider
1120            .list(ListIssueArgs::default())
1121            .await
1122            .expect("contract fixture must parse");
1123
1124        assert_eq!(issues.len(), 1);
1125        let issue = &issues[0];
1126        assert_eq!(issue.number, 10);
1127        assert!(!issue.title.is_empty());
1128        assert_eq!(issue.state, gitflow_core::types::State::Open);
1129    }
1130}