Skip to main content

gitflow_gitlab/
release.rs

1//! GitLab Release 提供者实现。
2//!
3//! 通过 `glab release` CLI 实现 [`ReleaseProvider`] trait,支持 Release 的创建、
4//! 列表、查看、编辑、资源上传/下载及删除。
5//! 所有方法通过 [`CommandRunner`] 抽象调用 `glab`,捕获 stdout 并解析 JSON。
6//!
7//! `glab` 的 `JSON` 输出使用 `snake_case` 字段名(如 `tag_name`、`created_at`),
8//! 因此使用中间类型 [`ReleaseApiResponse`] 进行反序列化,然后转换为核心类型
9//! [`ReleaseData`]。
10
11use async_trait::async_trait;
12use chrono::{DateTime, Utc};
13use gitflow_core::{
14    CoreError, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, fetch_capped,
15    release::{CreateReleaseArgs, ReleaseData, ReleaseProvider},
16    types::UserSummary,
17};
18use serde::Deserialize;
19use tracing::debug;
20
21use crate::{
22    GITLAB_MAX_PER_PAGE,
23    error::parse_glab_error,
24    runner::{CommandRunner, RealCommandRunner},
25};
26
27/// GitLab Release 提供者,通过 `glab` CLI 操作。
28///
29/// 命令执行通过 [`CommandRunner`] 抽象,生产环境默认使用
30/// [`RealCommandRunner`],测试可注入自定义 runner 以模拟成功或失败场景。
31///
32/// # Examples
33///
34/// ```no_run
35/// use gitflow_gitlab::GitLabReleaseProvider;
36///
37/// let provider = GitLabReleaseProvider::new("gitlab-org/gitlab");
38/// ```
39#[derive(Debug, Clone)]
40pub struct GitLabReleaseProvider<R: CommandRunner = RealCommandRunner> {
41    /// GitLab `namespace/project`。
42    repo: String,
43    /// 传给 `glab release ...` 子命令 `--repo` 参数的目标字符串。默认等于
44    /// `repo`;通过 [`with_remote_url`](GitLabReleaseProvider::with_remote_url)
45    /// 构造时为完整 git remote URL,用于在自建 GitLab 实例上显式锁定 host。
46    repo_target: String,
47    /// 用于执行 `glab` CLI 命令的 runner。
48    runner: R,
49}
50
51impl GitLabReleaseProvider<RealCommandRunner> {
52    /// 创建新的 GitLab Release 提供者,使用真实的进程执行器。
53    ///
54    /// `repo` 格式为 `namespace/project`。
55    #[must_use]
56    pub fn new(repo: impl Into<String>) -> Self {
57        let repo = repo.into();
58        Self {
59            repo_target: repo.clone(),
60            repo,
61            runner: RealCommandRunner,
62        }
63    }
64
65    /// Create a new provider from a shared [`Session`].
66    ///
67    /// This enables state reuse across multiple operations in workflow chains.
68    #[must_use]
69    pub fn with_session(session: &gitflow_core::Session) -> Self {
70        let repo = session.repo.clone();
71        Self {
72            repo_target: repo.clone(),
73            repo,
74            runner: RealCommandRunner,
75        }
76    }
77
78    /// 使用完整 git remote URL 作为 `glab release ...` 的 `--repo` 目标创建提供者。
79    #[must_use]
80    pub fn with_remote_url(repo: impl Into<String>, remote_url: impl Into<String>) -> Self {
81        Self {
82            repo: repo.into(),
83            repo_target: remote_url.into(),
84            runner: RealCommandRunner,
85        }
86    }
87}
88
89impl<R: CommandRunner> GitLabReleaseProvider<R> {
90    /// 使用自定义 [`CommandRunner`] 创建提供者。
91    ///
92    /// 主要用于测试,可注入模拟 runner 以控制 `glab` CLI 的输出。
93    /// `repo` 格式为 `namespace/project`。
94    #[must_use]
95    pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
96        let repo = repo.into();
97        Self {
98            repo_target: repo.clone(),
99            repo,
100            runner,
101        }
102    }
103
104    /// 使用自定义 [`CommandRunner`] 并显式指定 `--repo` 目标创建提供者。
105    ///
106    /// 主要用于测试,验证 `repo_target`(如完整 remote URL)被正确传给 `glab`。
107    #[must_use]
108    pub fn with_runner_and_repo_target(
109        repo: impl Into<String>,
110        repo_target: impl Into<String>,
111        runner: R,
112    ) -> Self {
113        Self {
114            repo: repo.into(),
115            repo_target: repo_target.into(),
116            runner,
117        }
118    }
119}
120
121// ── 中间 API 响应类型 ──────────────────────────────────────────────
122
123/// `glab release` JSON 输出中的用户信息。
124#[derive(Debug, Clone, Deserialize)]
125struct ApiUser {
126    username: String,
127    #[serde(default)]
128    id: u64,
129}
130
131impl From<&ApiUser> for UserSummary {
132    fn from(u: &ApiUser) -> Self {
133        Self {
134            login: u.username.clone(),
135            id: u.id.to_string(),
136        }
137    }
138}
139
140/// `glab release --output json` 返回的 JSON 结构。
141#[derive(Debug, Clone, Deserialize)]
142struct ReleaseApiResponse {
143    #[serde(default)]
144    tag_name: String,
145    #[serde(default)]
146    name: Option<String>,
147    #[serde(default)]
148    description: Option<String>,
149    #[serde(default)]
150    draft: bool,
151    #[serde(default)]
152    prerelease: bool,
153    #[serde(default)]
154    author: Option<ApiUser>,
155    #[serde(default)]
156    created_at: Option<DateTime<Utc>>,
157    #[serde(default)]
158    released_at: Option<DateTime<Utc>>,
159    #[serde(default)]
160    url: Option<String>,
161    /// GitLab uses `upcoming_release` instead of a numeric id in some versions.
162    #[serde(default)]
163    id: Option<u64>,
164}
165
166impl From<ReleaseApiResponse> for ReleaseData {
167    fn from(api: ReleaseApiResponse) -> Self {
168        let author = api.author.as_ref().map(UserSummary::from);
169
170        Self {
171            id: api.id.unwrap_or(0),
172            tag_name: api.tag_name,
173            name: api.name,
174            body: api.description,
175            draft: api.draft,
176            prerelease: api.prerelease,
177            author,
178            created_at: api.created_at,
179            published_at: api.released_at,
180            url: api.url.unwrap_or_default(),
181        }
182    }
183}
184
185// ── trait 实现 ──────────────────────────────────────────────────────
186
187#[async_trait]
188impl<R: CommandRunner + 'static> ReleaseProvider for GitLabReleaseProvider<R> {
189    async fn create(&self, args: CreateReleaseArgs) -> Result<ReleaseData> {
190        let mut cmd_args: Vec<&str> = vec![
191            "release",
192            "create",
193            &args.tag_name,
194            "--repo",
195            &self.repo_target,
196        ];
197
198        if let Some(ref name) = args.name {
199            cmd_args.push("--name");
200            cmd_args.push(name);
201        }
202
203        if let Some(ref body) = args.body {
204            cmd_args.push("--notes");
205            cmd_args.push(body);
206        }
207
208        // glab 1.113 has no `--draft`/`--prerelease` flags on `release create`;
209        // `CreateReleaseArgs.draft/prerelease` are GitHub-only and must not be
210        // forwarded to the GitLab CLI (passing them fails with "Unknown flag").
211
212        if let Some(ref commitish) = args.target_commitish {
213            cmd_args.push("--ref");
214            cmd_args.push(commitish);
215        }
216
217        debug!(
218            repo = %self.repo,
219            tag = %args.tag_name,
220            "spawning `glab release create`"
221        );
222
223        let output = self
224            .runner
225            .run("glab", &cmd_args)
226            .await
227            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
228
229        if !output.status.success() {
230            return Err(parse_glab_error(&output.stderr).into());
231        }
232
233        self.view(&args.tag_name).await
234    }
235
236    async fn list(&self, limit: Option<u32>) -> Result<Paged<ReleaseData>> {
237        let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
238        let repo_target = &self.repo_target;
239        let runner = &self.runner;
240        // 页大小不必超过 cap+1:N+1 探测只需要多要一条即可判断截断,
241        // 请求整页 100 条再丢弃对 cap 很小的调用(如 `--limit 5`)是纯浪费。
242        let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
243
244        debug!(repo = %self.repo, cap, "spawning `glab release list`");
245
246        fetch_capped(
247            FetchStrategy::Paged { per_page },
248            cap,
249            |page, per_page| async move {
250                let page_str = page.to_string();
251                let per_page_str = per_page.to_string();
252
253                let output = runner
254                    .run(
255                        "glab",
256                        &[
257                            "release",
258                            "list",
259                            "--repo",
260                            repo_target,
261                            "--output",
262                            "json",
263                            "--per-page",
264                            &per_page_str,
265                            "--page",
266                            &page_str,
267                        ],
268                    )
269                    .await
270                    .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
271
272                if !output.status.success() {
273                    return Err(parse_glab_error(&output.stderr).into());
274                }
275
276                let api_responses: Vec<ReleaseApiResponse> =
277                    serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
278
279                Ok(api_responses.into_iter().map(ReleaseData::from).collect())
280            },
281        )
282        .await
283    }
284
285    async fn view(&self, tag_name: &str) -> Result<ReleaseData> {
286        debug!(repo = %self.repo, tag = %tag_name, "spawning `glab release view`");
287
288        let output = self
289            .runner
290            .run(
291                "glab",
292                &[
293                    "release",
294                    "view",
295                    tag_name,
296                    "--repo",
297                    &self.repo_target,
298                    "--output",
299                    "json",
300                ],
301            )
302            .await
303            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
304
305        if !output.status.success() {
306            return Err(parse_glab_error(&output.stderr).into());
307        }
308
309        let api_response: ReleaseApiResponse =
310            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
311
312        Ok(api_response.into())
313    }
314
315    async fn edit(&self, tag_name: &str, args: CreateReleaseArgs) -> Result<ReleaseData> {
316        // glab 1.113 has no `release edit` subcommand (it prints parent help and
317        // exits 0, silently swallowing the edit). `release create <tag>` updates
318        // an existing release, so the edit path reuses it.
319        let mut cmd_args: Vec<&str> =
320            vec!["release", "create", tag_name, "--repo", &self.repo_target];
321
322        if let Some(ref name) = args.name {
323            cmd_args.push("--name");
324            cmd_args.push(name);
325        }
326
327        if let Some(ref body) = args.body {
328            cmd_args.push("--notes");
329            cmd_args.push(body);
330        }
331
332        // glab 1.113 has no `--draft`/`--prerelease` flags on `release create`;
333        // `CreateReleaseArgs.draft/prerelease` are GitHub-only and must not be
334        // forwarded to the GitLab CLI (passing them fails with "Unknown flag").
335
336        if let Some(ref commitish) = args.target_commitish {
337            cmd_args.push("--ref");
338            cmd_args.push(commitish);
339        }
340
341        debug!(
342            repo = %self.repo,
343            tag = %tag_name,
344            "spawning `glab release create` (edit path)"
345        );
346
347        let output = self
348            .runner
349            .run("glab", &cmd_args)
350            .await
351            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
352
353        if !output.status.success() {
354            return Err(parse_glab_error(&output.stderr).into());
355        }
356
357        self.view(tag_name).await
358    }
359
360    async fn upload_asset(&self, tag_name: &str, file_path: &str, _asset_name: &str) -> Result<()> {
361        debug!(
362            repo = %self.repo,
363            tag = %tag_name,
364            file = %file_path,
365            "spawning `glab release upload`"
366        );
367
368        let output = self
369            .runner
370            .run(
371                "glab",
372                &[
373                    "release",
374                    "upload",
375                    tag_name,
376                    file_path,
377                    "--repo",
378                    &self.repo_target,
379                ],
380            )
381            .await
382            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
383
384        if !output.status.success() {
385            return Err(parse_glab_error(&output.stderr).into());
386        }
387
388        Ok(())
389    }
390
391    #[allow(
392        clippy::disallowed_methods,
393        reason = "Path parent extraction required for download"
394    )]
395    async fn download_asset(
396        &self,
397        tag_name: &str,
398        asset_name: &str,
399        dest_path: &str,
400    ) -> Result<()> {
401        debug!(
402            repo = %self.repo,
403            tag = %tag_name,
404            asset = %asset_name,
405            dest = %dest_path,
406            "spawning `glab release download`"
407        );
408
409        let dest = std::path::PathBuf::from(dest_path);
410        let parent = dest.parent().unwrap_or_else(|| std::path::Path::new("."));
411        let parent_str = parent.to_string_lossy();
412
413        let output = self
414            .runner
415            .run(
416                "glab",
417                &[
418                    "release",
419                    "download",
420                    tag_name,
421                    "--repo",
422                    &self.repo_target,
423                    "--pattern",
424                    asset_name,
425                    "--dir",
426                    &parent_str,
427                ],
428            )
429            .await
430            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
431
432        if !output.status.success() {
433            return Err(parse_glab_error(&output.stderr).into());
434        }
435
436        let downloaded = parent.join(asset_name);
437        if downloaded != dest && downloaded.exists() {
438            std::fs::rename(&downloaded, &dest).map_err(|e| {
439                CoreError::Platform(format!(
440                    "Failed to move downloaded asset to {dest_path}: {e}"
441                ))
442            })?;
443        }
444
445        Ok(())
446    }
447
448    async fn delete(&self, tag_name: &str) -> Result<()> {
449        debug!(repo = %self.repo, tag = %tag_name, "spawning `glab release delete`");
450
451        let output = self
452            .runner
453            .run(
454                "glab",
455                &[
456                    "release",
457                    "delete",
458                    tag_name,
459                    "--repo",
460                    &self.repo_target,
461                    "--yes",
462                ],
463            )
464            .await
465            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
466
467        if !output.status.success() {
468            return Err(parse_glab_error(&output.stderr).into());
469        }
470
471        Ok(())
472    }
473}
474
475#[cfg(test)]
476mod tests {
477    use super::*;
478    use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
479
480    #[test]
481    fn test_should_construct_gitlab_release_provider() {
482        let provider = GitLabReleaseProvider::new("gitlab-org/gitlab");
483        assert_eq!(provider.repo, "gitlab-org/gitlab");
484    }
485
486    #[test]
487    fn test_should_construct_gitlab_release_provider_from_string() {
488        let repo = String::from("gitlab-org/gitlab");
489        let provider = GitLabReleaseProvider::new(repo);
490        assert_eq!(provider.repo, "gitlab-org/gitlab");
491    }
492
493    #[tokio::test]
494    async fn test_should_use_explicit_repo_target_for_delete() {
495        let runner = MockCommandRunner::success("");
496        let provider = GitLabReleaseProvider::with_runner_and_repo_target(
497            "owner/repo",
498            "https://192.168.230.23/iproost/proxy/api-src.git",
499            runner.clone(),
500        );
501
502        let result = provider.delete("v1.0.0").await;
503
504        assert!(result.is_ok(), "expected Ok, got {result:?}");
505        assert_eq!(
506            runner.recorded_calls()[0].1,
507            vec![
508                "release",
509                "delete",
510                "v1.0.0",
511                "--repo",
512                "https://192.168.230.23/iproost/proxy/api-src.git",
513                "--yes",
514            ]
515            .into_iter()
516            .map(String::from)
517            .collect::<Vec<_>>()
518        );
519    }
520
521    #[test]
522    fn test_should_deserialize_release_api_response() {
523        let json = br#"{
524            "id": 1001,
525            "tag_name": "v1.0.0",
526            "name": "Version 1.0.0",
527            "description": "Initial stable release",
528            "draft": false,
529            "prerelease": false,
530            "author": {"username": "admin", "id": 1},
531            "created_at": "2026-01-01T00:00:00Z",
532            "released_at": "2026-01-15T12:00:00Z",
533            "url": "https://gitlab.com/gitlab-org/gitlab/-/releases/v1.0.0"
534        }"#;
535
536        let api: ReleaseApiResponse =
537            serde_json::from_slice(json).expect("valid ReleaseApiResponse");
538        let release: ReleaseData = api.into();
539
540        assert_eq!(release.id, 1001);
541        assert_eq!(release.tag_name, "v1.0.0");
542        assert_eq!(release.name.as_deref(), Some("Version 1.0.0"));
543        assert_eq!(release.body.as_deref(), Some("Initial stable release"));
544        assert!(!release.draft);
545        assert!(!release.prerelease);
546        assert_eq!(
547            release.author.as_ref().expect("author present").login,
548            "admin"
549        );
550        assert_eq!(
551            release.url,
552            "https://gitlab.com/gitlab-org/gitlab/-/releases/v1.0.0"
553        );
554    }
555
556    #[test]
557    fn test_should_deserialize_draft_release() {
558        let json = br#"{
559            "tag_name": "v0.1.0-draft",
560            "name": null,
561            "description": null,
562            "draft": true,
563            "prerelease": true,
564            "author": {"username": "dev", "id": 99},
565            "created_at": "2026-03-01T00:00:00Z",
566            "released_at": null,
567            "url": null
568        }"#;
569
570        let api: ReleaseApiResponse =
571            serde_json::from_slice(json).expect("valid ReleaseApiResponse");
572        let release: ReleaseData = api.into();
573        assert!(release.draft);
574        assert!(release.prerelease);
575        assert!(release.name.is_none());
576        assert!(release.published_at.is_none());
577    }
578
579    #[test]
580    fn test_should_deserialize_empty_release_list() {
581        let json = b"[]";
582        let list: Vec<ReleaseApiResponse> = serde_json::from_slice(json).expect("valid empty list");
583        assert!(list.is_empty());
584    }
585
586    #[test]
587    fn test_should_debug_format_provider() {
588        let provider = GitLabReleaseProvider::new("gitlab-org/gitlab");
589        let debug = format!("{provider:?}");
590        assert!(debug.contains("GitLabReleaseProvider"));
591        assert!(debug.contains("gitlab-org/gitlab"));
592    }
593
594    #[test]
595    fn test_should_clone_gitlab_release_provider() {
596        let original = GitLabReleaseProvider::new("owner/repo");
597        let cloned = original.clone();
598        assert_eq!(original.repo, cloned.repo);
599    }
600
601    // --- Failure-path tests using an injected MockCommandRunner ---
602
603    fn sample_create_args() -> CreateReleaseArgs {
604        CreateReleaseArgs {
605            tag_name: "v1.0.0".to_string(),
606            name: Some("Version 1.0.0".to_string()),
607            body: Some("Release notes".to_string()),
608            draft: false,
609            prerelease: false,
610            target_commitish: None,
611        }
612    }
613
614    #[tokio::test]
615    async fn test_should_return_platform_error_when_glab_fails_for_create() {
616        let runner = MockCommandRunner::failure(r#"{"message": "Tag exists"}"#, 256);
617        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
618
619        let result = provider.create(sample_create_args()).await;
620
621        assert!(matches!(
622            result.unwrap_err(),
623            gitflow_core::CoreError::Cli(_)
624        ));
625    }
626
627    #[tokio::test]
628    async fn test_should_return_serialization_error_on_invalid_json_for_create() {
629        let runner = MockCommandRunner::success("not valid json");
630        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
631
632        let result = provider.create(sample_create_args()).await;
633
634        assert!(matches!(
635            result.unwrap_err(),
636            gitflow_core::CoreError::Serialization(_)
637        ));
638    }
639
640    #[tokio::test]
641    async fn test_should_return_platform_error_when_glab_fails_for_list() {
642        let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
643        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
644
645        let result = provider.list(None).await;
646
647        assert!(matches!(
648            result.unwrap_err(),
649            gitflow_core::CoreError::Cli(_)
650        ));
651    }
652
653    #[tokio::test]
654    async fn test_should_return_serialization_error_on_invalid_json_for_list() {
655        let runner = MockCommandRunner::success("invalid");
656        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
657
658        let result = provider.list(None).await;
659
660        assert!(matches!(
661            result.unwrap_err(),
662            gitflow_core::CoreError::Serialization(_)
663        ));
664    }
665
666    #[tokio::test]
667    async fn test_should_return_platform_error_when_glab_fails_for_view() {
668        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
669        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
670
671        let result = provider.view("v1.0.0").await;
672
673        assert!(matches!(
674            result.unwrap_err(),
675            gitflow_core::CoreError::Cli(_)
676        ));
677    }
678
679    #[tokio::test]
680    async fn test_should_return_serialization_error_on_invalid_json_for_view() {
681        let runner = MockCommandRunner::success("invalid");
682        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
683
684        let result = provider.view("v1.0.0").await;
685
686        assert!(matches!(
687            result.unwrap_err(),
688            gitflow_core::CoreError::Serialization(_)
689        ));
690    }
691
692    #[tokio::test]
693    async fn test_should_return_platform_error_when_glab_fails_for_edit() {
694        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
695        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
696
697        let result = provider.edit("v1.0.0", sample_create_args()).await;
698
699        assert!(matches!(
700            result.unwrap_err(),
701            gitflow_core::CoreError::Cli(_)
702        ));
703    }
704
705    #[tokio::test]
706    async fn test_should_return_serialization_error_on_invalid_json_for_edit() {
707        let runner = MockCommandRunner::success("invalid");
708        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
709
710        let result = provider.edit("v1.0.0", sample_create_args()).await;
711
712        assert!(matches!(
713            result.unwrap_err(),
714            gitflow_core::CoreError::Serialization(_)
715        ));
716    }
717
718    #[tokio::test]
719    async fn test_should_return_platform_error_when_glab_fails_for_delete() {
720        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
721        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
722
723        let result = provider.delete("v1.0.0").await;
724
725        assert!(matches!(
726            result.unwrap_err(),
727            gitflow_core::CoreError::Cli(_)
728        ));
729    }
730
731    #[tokio::test]
732    async fn test_should_return_platform_error_when_glab_fails_for_upload_asset() {
733        let runner = MockCommandRunner::failure(r#"{"message": "Upload failed"}"#, 256);
734        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
735
736        let result = provider
737            .upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
738            .await;
739
740        assert!(matches!(
741            result.unwrap_err(),
742            gitflow_core::CoreError::Cli(_)
743        ));
744    }
745
746    #[tokio::test]
747    async fn test_should_return_platform_error_when_glab_fails_for_download_asset() {
748        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
749        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
750
751        let result = provider
752            .download_asset("v1.0.0", "asset.tar.gz", "/tmp/asset.tar.gz")
753            .await;
754
755        assert!(matches!(
756            result.unwrap_err(),
757            gitflow_core::CoreError::Cli(_)
758        ));
759    }
760
761    // --- ApiUser to UserSummary conversion ---
762
763    #[test]
764    fn test_should_convert_api_user_to_user_summary() {
765        let api_user = ApiUser {
766            username: "admin".into(),
767            id: 42,
768        };
769        let summary: UserSummary = (&api_user).into();
770        assert_eq!(summary.login, "admin");
771        assert_eq!(summary.id, "42");
772    }
773
774    #[test]
775    fn test_should_convert_api_user_with_zero_id() {
776        let api_user = ApiUser {
777            username: "bot".into(),
778            id: 0,
779        };
780        let summary: UserSummary = (&api_user).into();
781        assert_eq!(summary.login, "bot");
782        assert_eq!(summary.id, "0");
783    }
784
785    // --- ReleaseApiResponse to ReleaseData conversion edge cases ---
786
787    #[test]
788    fn test_should_convert_minimal_api_response_to_release_data() {
789        let api = ReleaseApiResponse {
790            tag_name: "v1.0.0".into(),
791            name: None,
792            description: None,
793            draft: false,
794            prerelease: false,
795            author: None,
796            created_at: None,
797            released_at: None,
798            url: None,
799            id: None,
800        };
801        let release: ReleaseData = api.into();
802        assert_eq!(release.tag_name, "v1.0.0");
803        assert_eq!(release.id, 0); // defaults to 0 when id is None
804        assert!(release.name.is_none());
805        assert!(release.body.is_none());
806        assert!(!release.draft);
807        assert!(!release.prerelease);
808        assert!(release.author.is_none());
809        assert!(release.published_at.is_none());
810        assert_eq!(release.url, ""); // defaults to empty string
811        assert!(
812            release.created_at.is_none(),
813            "missing created_at must stay None, not fall back to Utc::now()"
814        );
815    }
816
817    #[test]
818    fn test_should_preserve_all_fields_in_full_api_response_conversion() {
819        let api = ReleaseApiResponse {
820            tag_name: "v2.0.0".into(),
821            name: Some("Major Release".into()),
822            description: Some("Breaking changes".into()),
823            draft: true,
824            prerelease: false,
825            author: Some(ApiUser {
826                username: "dev".into(),
827                id: 7,
828            }),
829            created_at: Some("2026-06-01T00:00:00Z".parse().expect("valid datetime")),
830            released_at: Some("2026-06-15T12:00:00Z".parse().expect("valid datetime")),
831            url: Some("https://gitlab.com/ns/proj/-/releases/v2.0.0".into()),
832            id: Some(200),
833        };
834        let release: ReleaseData = api.into();
835        assert_eq!(release.id, 200);
836        assert_eq!(release.tag_name, "v2.0.0");
837        assert_eq!(release.name.as_deref(), Some("Major Release"));
838        assert_eq!(release.body.as_deref(), Some("Breaking changes"));
839        assert!(release.draft);
840        assert!(!release.prerelease);
841        assert_eq!(release.author.as_ref().expect("author").login, "dev");
842        assert_eq!(release.author.as_ref().expect("author").id, "7");
843        assert_eq!(release.url, "https://gitlab.com/ns/proj/-/releases/v2.0.0");
844    }
845
846    // --- with_runner constructor ---
847
848    #[test]
849    fn test_should_create_provider_with_custom_runner() {
850        let runner = MockCommandRunner::success("");
851        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
852        assert_eq!(provider.repo, "owner/repo");
853    }
854
855    // --- Success-path tests ---
856
857    fn valid_release_api_json() -> &'static str {
858        r#"{
859            "id": 1,
860            "tag_name": "v1.0.0",
861            "name": "Version 1.0.0",
862            "description": "Release notes",
863            "draft": false,
864            "prerelease": false,
865            "author": {"username": "admin", "id": 1},
866            "created_at": "2026-01-01T00:00:00Z",
867            "released_at": "2026-01-01T00:00:00Z",
868            "url": "https://gitlab.com/owner/repo/-/releases/v1.0.0"
869        }"#
870    }
871
872    #[tokio::test]
873    async fn test_should_view_release_successfully() {
874        let runner = MockCommandRunner::success(valid_release_api_json());
875        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
876
877        let release = provider.view("v1.0.0").await.expect("view should succeed");
878        assert_eq!(release.tag_name, "v1.0.0");
879        assert_eq!(release.name.as_deref(), Some("Version 1.0.0"));
880        assert_eq!(release.id, 1);
881    }
882
883    #[tokio::test]
884    async fn test_should_list_releases_successfully() {
885        let json = format!("[{}]", valid_release_api_json());
886        let runner = MockCommandRunner::success(&json);
887        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
888
889        let paged = provider.list(None).await.expect("list should succeed");
890        assert_eq!(paged.items.len(), 1);
891        assert_eq!(paged.items[0].tag_name, "v1.0.0");
892    }
893
894    #[tokio::test]
895    async fn test_should_request_max_per_page_for_default_release_list() {
896        let runner = MockCommandRunner::success("[]");
897        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
898        provider.list(None).await.expect("list should succeed");
899        let recorded = &runner.recorded_calls()[0].1;
900        assert!(
901            recorded
902                .windows(2)
903                .any(|w| w[0] == "--per-page" && w[1] == "100"),
904            "实际 argv: {recorded:?}"
905        );
906        assert!(
907            recorded.windows(2).any(|w| w[0] == "--page" && w[1] == "1"),
908            "实际 argv: {recorded:?}"
909        );
910    }
911
912    #[tokio::test]
913    async fn test_should_produce_complete_argv_for_release_list_with_default_limit() {
914        let runner = MockCommandRunner::success("[]");
915        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
916        provider.list(None).await.expect("list should succeed");
917        let recorded = &runner.recorded_calls()[0];
918        assert_eq!(recorded.0, "glab");
919        assert_eq!(
920            recorded.1,
921            vec![
922                "release",
923                "list",
924                "--repo",
925                "owner/repo",
926                "--output",
927                "json",
928                "--per-page",
929                "100",
930                "--page",
931                "1",
932            ]
933        );
934    }
935
936    #[tokio::test]
937    async fn test_should_honour_user_release_limit_via_per_page() {
938        let runner = MockCommandRunner::success("[]");
939        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
940        provider.list(Some(10)).await.expect("list should succeed");
941        let recorded = &runner.recorded_calls()[0].1;
942        assert!(
943            recorded
944                .windows(2)
945                .any(|w| w[0] == "--per-page" && w[1] == "11"),
946            "cap+1=11 应作为 per_page 传给 glab,实际 argv: {recorded:?}"
947        );
948    }
949
950    #[tokio::test]
951    async fn test_should_create_release_successfully() {
952        let runner = MockCommandRunner::success(valid_release_api_json());
953        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
954
955        let release = provider
956            .create(sample_create_args())
957            .await
958            .expect("create should succeed");
959        assert_eq!(release.tag_name, "v1.0.0");
960    }
961
962    #[tokio::test]
963    async fn test_should_create_release_without_output_json_and_refetch_via_view() {
964        let runner = SequencedMockCommandRunner::from_results(&[
965            (true, ""), // release create 成功(stdout 为纯文本,忽略)
966            (
967                true,
968                r#"{"tag_name":"v1.0.0","name":"v1.0.0","description":"notes"}"#,
969            ),
970        ]);
971        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
972
973        let args = CreateReleaseArgs {
974            tag_name: "v1.0.0".to_string(),
975            name: None,
976            body: Some("notes".to_string()),
977            draft: false,
978            prerelease: false,
979            target_commitish: None,
980        };
981
982        let rel = provider.create(args).await.expect("should create");
983
984        assert_eq!(rel.tag_name, "v1.0.0");
985    }
986
987    #[tokio::test]
988    async fn test_should_not_pass_draft_or_prerelease_flags_on_release_create() {
989        // glab 1.113 has no `--draft`/`--prerelease` flags on `release create`;
990        // passing them makes every release creation fail with "Unknown flag".
991        let runner = SequencedMockCommandRunner::from_results(&[
992            (true, ""), // release create 成功(stdout 为纯文本,忽略)
993            (
994                true,
995                r#"{"tag_name":"v1.0.0","name":"Version 1.0.0","description":"notes"}"#,
996            ),
997        ]);
998        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
999
1000        let args = CreateReleaseArgs {
1001            tag_name: "v1.0.0".to_string(),
1002            name: Some("Version 1.0.0".to_string()),
1003            body: Some("notes".to_string()),
1004            draft: true,
1005            prerelease: true,
1006            target_commitish: Some("main".to_string()),
1007        };
1008
1009        provider.create(args).await.expect("should create");
1010
1011        assert_eq!(
1012            runner.recorded_calls()[0].1,
1013            [
1014                "release",
1015                "create",
1016                "v1.0.0",
1017                "--repo",
1018                "owner/repo",
1019                "--name",
1020                "Version 1.0.0",
1021                "--notes",
1022                "notes",
1023                "--ref",
1024                "main",
1025            ]
1026            .into_iter()
1027            .map(String::from)
1028            .collect::<Vec<_>>()
1029        );
1030    }
1031
1032    #[tokio::test]
1033    async fn test_should_edit_release_without_output_json_and_refetch_via_view() {
1034        let runner = SequencedMockCommandRunner::from_results(&[
1035            (true, ""), // release edit 成功
1036            (
1037                true,
1038                r#"{"tag_name":"v1.0.0","name":"v1.0.0","description":"notes"}"#,
1039            ),
1040        ]);
1041        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
1042
1043        let args = CreateReleaseArgs {
1044            tag_name: "v1.0.0".to_string(),
1045            name: None,
1046            body: Some("notes".to_string()),
1047            draft: false,
1048            prerelease: false,
1049            target_commitish: None,
1050        };
1051
1052        let rel = provider.edit("v1.0.0", args).await.expect("should edit");
1053
1054        assert_eq!(rel.tag_name, "v1.0.0");
1055    }
1056
1057    #[tokio::test]
1058    async fn test_should_edit_release_via_release_create() {
1059        // glab 1.113 has no `release edit` subcommand (it prints parent help and
1060        // exits 0, silently swallowing the edit). `release create <tag>` updates
1061        // an existing release, so the edit path must reuse it.
1062        let runner = SequencedMockCommandRunner::from_results(&[
1063            (true, ""), // release create (edit path) 成功
1064            (
1065                true,
1066                r#"{"tag_name":"v1.0.0","name":"Version 1.0.0","description":"notes"}"#,
1067            ),
1068        ]);
1069        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
1070
1071        let args = CreateReleaseArgs {
1072            tag_name: "v1.0.0".to_string(),
1073            name: Some("Version 1.0.0".to_string()),
1074            body: Some("notes".to_string()),
1075            draft: true,
1076            prerelease: true,
1077            target_commitish: Some("main".to_string()),
1078        };
1079
1080        provider.edit("v1.0.0", args).await.expect("should edit");
1081
1082        assert_eq!(
1083            runner.recorded_calls()[0].1,
1084            [
1085                "release",
1086                "create",
1087                "v1.0.0",
1088                "--repo",
1089                "owner/repo",
1090                "--name",
1091                "Version 1.0.0",
1092                "--notes",
1093                "notes",
1094                "--ref",
1095                "main",
1096            ]
1097            .into_iter()
1098            .map(String::from)
1099            .collect::<Vec<_>>()
1100        );
1101    }
1102
1103    #[tokio::test]
1104    async fn test_should_edit_release_successfully() {
1105        let runner = MockCommandRunner::success(valid_release_api_json());
1106        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
1107
1108        let release = provider
1109            .edit("v1.0.0", sample_create_args())
1110            .await
1111            .expect("edit should succeed");
1112        assert_eq!(release.tag_name, "v1.0.0");
1113    }
1114
1115    #[tokio::test]
1116    async fn test_should_delete_release_successfully() {
1117        let runner = MockCommandRunner::success("");
1118        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
1119
1120        assert!(provider.delete("v1.0.0").await.is_ok());
1121    }
1122
1123    #[tokio::test]
1124    async fn test_should_upload_asset_successfully() {
1125        let runner = MockCommandRunner::success("");
1126        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
1127
1128        assert!(
1129            provider
1130                .upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
1131                .await
1132                .is_ok()
1133        );
1134    }
1135}