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, Result,
15    release::{CreateReleaseArgs, ReleaseData, ReleaseProvider},
16    types::UserSummary,
17};
18use serde::Deserialize;
19use tracing::debug;
20
21use crate::{
22    error::parse_glab_error,
23    runner::{CommandRunner, RealCommandRunner},
24};
25
26/// GitLab Release 提供者,通过 `glab` CLI 操作。
27///
28/// 命令执行通过 [`CommandRunner`] 抽象,生产环境默认使用
29/// [`RealCommandRunner`],测试可注入自定义 runner 以模拟成功或失败场景。
30///
31/// # Examples
32///
33/// ```no_run
34/// use gitflow_gitlab::GitLabReleaseProvider;
35///
36/// let provider = GitLabReleaseProvider::new("gitlab-org/gitlab");
37/// ```
38#[derive(Debug, Clone)]
39pub struct GitLabReleaseProvider<R: CommandRunner = RealCommandRunner> {
40    /// GitLab `namespace/project`。
41    repo: String,
42    /// 用于执行 `glab` CLI 命令的 runner。
43    runner: R,
44}
45
46impl GitLabReleaseProvider<RealCommandRunner> {
47    /// 创建新的 GitLab Release 提供者,使用真实的进程执行器。
48    ///
49    /// `repo` 格式为 `namespace/project`。
50    #[must_use]
51    pub fn new(repo: impl Into<String>) -> Self {
52        Self {
53            repo: repo.into(),
54            runner: RealCommandRunner,
55        }
56    }
57}
58
59impl<R: CommandRunner> GitLabReleaseProvider<R> {
60    /// 使用自定义 [`CommandRunner`] 创建提供者。
61    ///
62    /// 主要用于测试,可注入模拟 runner 以控制 `glab` CLI 的输出。
63    /// `repo` 格式为 `namespace/project`。
64    #[must_use]
65    pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
66        Self {
67            repo: repo.into(),
68            runner,
69        }
70    }
71}
72
73// ── 中间 API 响应类型 ──────────────────────────────────────────────
74
75/// `glab release` JSON 输出中的用户信息。
76#[derive(Debug, Clone, Deserialize)]
77struct ApiUser {
78    username: String,
79    #[serde(default)]
80    id: u64,
81}
82
83impl From<&ApiUser> for UserSummary {
84    fn from(u: &ApiUser) -> Self {
85        Self {
86            login: u.username.clone(),
87            id: u.id.to_string(),
88        }
89    }
90}
91
92/// `glab release --output json` 返回的 JSON 结构。
93#[derive(Debug, Clone, Deserialize)]
94struct ReleaseApiResponse {
95    #[serde(default)]
96    tag_name: String,
97    #[serde(default)]
98    name: Option<String>,
99    #[serde(default)]
100    description: Option<String>,
101    #[serde(default)]
102    draft: bool,
103    #[serde(default)]
104    prerelease: bool,
105    #[serde(default)]
106    author: Option<ApiUser>,
107    #[serde(default)]
108    created_at: Option<DateTime<Utc>>,
109    #[serde(default)]
110    released_at: Option<DateTime<Utc>>,
111    #[serde(default)]
112    url: Option<String>,
113    /// GitLab uses `upcoming_release` instead of a numeric id in some versions.
114    #[serde(default)]
115    id: Option<u64>,
116}
117
118impl From<ReleaseApiResponse> for ReleaseData {
119    fn from(api: ReleaseApiResponse) -> Self {
120        let now = Utc::now();
121        let author = api.author.as_ref().map(UserSummary::from);
122
123        Self {
124            id: api.id.unwrap_or(0),
125            tag_name: api.tag_name,
126            name: api.name,
127            body: api.description,
128            draft: api.draft,
129            prerelease: api.prerelease,
130            author,
131            created_at: api.created_at.unwrap_or(now),
132            published_at: api.released_at,
133            url: api.url.unwrap_or_default(),
134        }
135    }
136}
137
138// ── trait 实现 ──────────────────────────────────────────────────────
139
140#[async_trait]
141impl<R: CommandRunner + 'static> ReleaseProvider for GitLabReleaseProvider<R> {
142    async fn create(&self, args: CreateReleaseArgs) -> Result<ReleaseData> {
143        let mut cmd_args: Vec<&str> = vec![
144            "release",
145            "create",
146            &args.tag_name,
147            "--repo",
148            &self.repo,
149            "--output",
150            "json",
151        ];
152
153        if let Some(ref name) = args.name {
154            cmd_args.push("--name");
155            cmd_args.push(name);
156        }
157
158        if let Some(ref body) = args.body {
159            cmd_args.push("--notes");
160            cmd_args.push(body);
161        }
162
163        if args.draft {
164            cmd_args.push("--draft");
165        }
166
167        if args.prerelease {
168            cmd_args.push("--prerelease");
169        }
170
171        if let Some(ref commitish) = args.target_commitish {
172            cmd_args.push("--ref");
173            cmd_args.push(commitish);
174        }
175
176        debug!(
177            repo = %self.repo,
178            tag = %args.tag_name,
179            "spawning `glab release create`"
180        );
181
182        let output = self
183            .runner
184            .run("glab", &cmd_args)
185            .await
186            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
187
188        if !output.status.success() {
189            return Err(parse_glab_error(&output.stderr).into());
190        }
191
192        let api_response: ReleaseApiResponse =
193            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
194
195        Ok(api_response.into())
196    }
197
198    async fn list(&self) -> Result<Vec<ReleaseData>> {
199        debug!(repo = %self.repo, "spawning `glab release list`");
200
201        let output = self
202            .runner
203            .run(
204                "glab",
205                &["release", "list", "--repo", &self.repo, "--output", "json"],
206            )
207            .await
208            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
209
210        if !output.status.success() {
211            return Err(parse_glab_error(&output.stderr).into());
212        }
213
214        let api_responses: Vec<ReleaseApiResponse> =
215            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
216
217        Ok(api_responses.into_iter().map(ReleaseData::from).collect())
218    }
219
220    async fn view(&self, tag_name: &str) -> Result<ReleaseData> {
221        debug!(repo = %self.repo, tag = %tag_name, "spawning `glab release view`");
222
223        let output = self
224            .runner
225            .run(
226                "glab",
227                &[
228                    "release", "view", tag_name, "--repo", &self.repo, "--output", "json",
229                ],
230            )
231            .await
232            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
233
234        if !output.status.success() {
235            return Err(parse_glab_error(&output.stderr).into());
236        }
237
238        let api_response: ReleaseApiResponse =
239            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
240
241        Ok(api_response.into())
242    }
243
244    async fn edit(&self, tag_name: &str, args: CreateReleaseArgs) -> Result<ReleaseData> {
245        let mut cmd_args: Vec<&str> = vec![
246            "release", "edit", tag_name, "--repo", &self.repo, "--output", "json",
247        ];
248
249        if let Some(ref name) = args.name {
250            cmd_args.push("--name");
251            cmd_args.push(name);
252        }
253
254        if let Some(ref body) = args.body {
255            cmd_args.push("--notes");
256            cmd_args.push(body);
257        }
258
259        if args.draft {
260            cmd_args.push("--draft");
261        }
262
263        if args.prerelease {
264            cmd_args.push("--prerelease");
265        }
266
267        if let Some(ref commitish) = args.target_commitish {
268            cmd_args.push("--ref");
269            cmd_args.push(commitish);
270        }
271
272        debug!(
273            repo = %self.repo,
274            tag = %tag_name,
275            "spawning `glab release edit`"
276        );
277
278        let output = self
279            .runner
280            .run("glab", &cmd_args)
281            .await
282            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
283
284        if !output.status.success() {
285            return Err(parse_glab_error(&output.stderr).into());
286        }
287
288        let api_response: ReleaseApiResponse =
289            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
290
291        Ok(api_response.into())
292    }
293
294    async fn upload_asset(&self, tag_name: &str, file_path: &str, _asset_name: &str) -> Result<()> {
295        debug!(
296            repo = %self.repo,
297            tag = %tag_name,
298            file = %file_path,
299            "spawning `glab release upload`"
300        );
301
302        let output = self
303            .runner
304            .run(
305                "glab",
306                &[
307                    "release", "upload", tag_name, file_path, "--repo", &self.repo,
308                ],
309            )
310            .await
311            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
312
313        if !output.status.success() {
314            return Err(parse_glab_error(&output.stderr).into());
315        }
316
317        Ok(())
318    }
319
320    #[allow(
321        clippy::disallowed_methods,
322        reason = "Path parent extraction required for download"
323    )]
324    async fn download_asset(
325        &self,
326        tag_name: &str,
327        asset_name: &str,
328        dest_path: &str,
329    ) -> Result<()> {
330        debug!(
331            repo = %self.repo,
332            tag = %tag_name,
333            asset = %asset_name,
334            dest = %dest_path,
335            "spawning `glab release download`"
336        );
337
338        let dest = std::path::PathBuf::from(dest_path);
339        let parent = dest.parent().unwrap_or_else(|| std::path::Path::new("."));
340        let parent_str = parent.to_string_lossy();
341
342        let output = self
343            .runner
344            .run(
345                "glab",
346                &[
347                    "release",
348                    "download",
349                    tag_name,
350                    "--repo",
351                    &self.repo,
352                    "--pattern",
353                    asset_name,
354                    "--dir",
355                    &parent_str,
356                ],
357            )
358            .await
359            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
360
361        if !output.status.success() {
362            return Err(parse_glab_error(&output.stderr).into());
363        }
364
365        let downloaded = parent.join(asset_name);
366        if downloaded != dest && downloaded.exists() {
367            std::fs::rename(&downloaded, &dest).map_err(|e| {
368                CoreError::Platform(format!(
369                    "Failed to move downloaded asset to {dest_path}: {e}"
370                ))
371            })?;
372        }
373
374        Ok(())
375    }
376
377    async fn delete(&self, tag_name: &str) -> Result<()> {
378        debug!(repo = %self.repo, tag = %tag_name, "spawning `glab release delete`");
379
380        let output = self
381            .runner
382            .run(
383                "glab",
384                &["release", "delete", tag_name, "--repo", &self.repo, "--yes"],
385            )
386            .await
387            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
388
389        if !output.status.success() {
390            return Err(parse_glab_error(&output.stderr).into());
391        }
392
393        Ok(())
394    }
395}
396
397#[cfg(test)]
398mod tests {
399    use super::*;
400    use crate::runner::MockCommandRunner;
401
402    #[test]
403    fn test_should_construct_gitlab_release_provider() {
404        let provider = GitLabReleaseProvider::new("gitlab-org/gitlab");
405        assert_eq!(provider.repo, "gitlab-org/gitlab");
406    }
407
408    #[test]
409    fn test_should_construct_gitlab_release_provider_from_string() {
410        let repo = String::from("gitlab-org/gitlab");
411        let provider = GitLabReleaseProvider::new(repo);
412        assert_eq!(provider.repo, "gitlab-org/gitlab");
413    }
414
415    #[test]
416    fn test_should_deserialize_release_api_response() {
417        let json = br#"{
418            "id": 1001,
419            "tag_name": "v1.0.0",
420            "name": "Version 1.0.0",
421            "description": "Initial stable release",
422            "draft": false,
423            "prerelease": false,
424            "author": {"username": "admin", "id": 1},
425            "created_at": "2026-01-01T00:00:00Z",
426            "released_at": "2026-01-15T12:00:00Z",
427            "url": "https://gitlab.com/gitlab-org/gitlab/-/releases/v1.0.0"
428        }"#;
429
430        let api: ReleaseApiResponse =
431            serde_json::from_slice(json).expect("valid ReleaseApiResponse");
432        let release: ReleaseData = api.into();
433
434        assert_eq!(release.id, 1001);
435        assert_eq!(release.tag_name, "v1.0.0");
436        assert_eq!(release.name.as_deref(), Some("Version 1.0.0"));
437        assert_eq!(release.body.as_deref(), Some("Initial stable release"));
438        assert!(!release.draft);
439        assert!(!release.prerelease);
440        assert_eq!(
441            release.author.as_ref().expect("author present").login,
442            "admin"
443        );
444        assert_eq!(
445            release.url,
446            "https://gitlab.com/gitlab-org/gitlab/-/releases/v1.0.0"
447        );
448    }
449
450    #[test]
451    fn test_should_deserialize_draft_release() {
452        let json = br#"{
453            "tag_name": "v0.1.0-draft",
454            "name": null,
455            "description": null,
456            "draft": true,
457            "prerelease": true,
458            "author": {"username": "dev", "id": 99},
459            "created_at": "2026-03-01T00:00:00Z",
460            "released_at": null,
461            "url": null
462        }"#;
463
464        let api: ReleaseApiResponse =
465            serde_json::from_slice(json).expect("valid ReleaseApiResponse");
466        let release: ReleaseData = api.into();
467        assert!(release.draft);
468        assert!(release.prerelease);
469        assert!(release.name.is_none());
470        assert!(release.published_at.is_none());
471    }
472
473    #[test]
474    fn test_should_deserialize_empty_release_list() {
475        let json = b"[]";
476        let list: Vec<ReleaseApiResponse> = serde_json::from_slice(json).expect("valid empty list");
477        assert!(list.is_empty());
478    }
479
480    #[test]
481    fn test_should_debug_format_provider() {
482        let provider = GitLabReleaseProvider::new("gitlab-org/gitlab");
483        let debug = format!("{provider:?}");
484        assert!(debug.contains("GitLabReleaseProvider"));
485        assert!(debug.contains("gitlab-org/gitlab"));
486    }
487
488    #[test]
489    fn test_should_clone_gitlab_release_provider() {
490        let original = GitLabReleaseProvider::new("owner/repo");
491        let cloned = original.clone();
492        assert_eq!(original.repo, cloned.repo);
493    }
494
495    // --- Failure-path tests using an injected MockCommandRunner ---
496
497    fn sample_create_args() -> CreateReleaseArgs {
498        CreateReleaseArgs {
499            tag_name: "v1.0.0".to_string(),
500            name: Some("Version 1.0.0".to_string()),
501            body: Some("Release notes".to_string()),
502            draft: false,
503            prerelease: false,
504            target_commitish: None,
505        }
506    }
507
508    #[tokio::test]
509    async fn test_should_return_platform_error_when_glab_fails_for_create() {
510        let runner = MockCommandRunner::failure(r#"{"message": "Tag exists"}"#, 256);
511        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
512
513        let result = provider.create(sample_create_args()).await;
514
515        assert!(matches!(
516            result.unwrap_err(),
517            gitflow_core::CoreError::Cli(_)
518        ));
519    }
520
521    #[tokio::test]
522    async fn test_should_return_serialization_error_on_invalid_json_for_create() {
523        let runner = MockCommandRunner::success("not valid json");
524        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
525
526        let result = provider.create(sample_create_args()).await;
527
528        assert!(matches!(
529            result.unwrap_err(),
530            gitflow_core::CoreError::Serialization(_)
531        ));
532    }
533
534    #[tokio::test]
535    async fn test_should_return_platform_error_when_glab_fails_for_list() {
536        let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
537        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
538
539        let result = provider.list().await;
540
541        assert!(matches!(
542            result.unwrap_err(),
543            gitflow_core::CoreError::Cli(_)
544        ));
545    }
546
547    #[tokio::test]
548    async fn test_should_return_serialization_error_on_invalid_json_for_list() {
549        let runner = MockCommandRunner::success("invalid");
550        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
551
552        let result = provider.list().await;
553
554        assert!(matches!(
555            result.unwrap_err(),
556            gitflow_core::CoreError::Serialization(_)
557        ));
558    }
559
560    #[tokio::test]
561    async fn test_should_return_platform_error_when_glab_fails_for_view() {
562        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
563        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
564
565        let result = provider.view("v1.0.0").await;
566
567        assert!(matches!(
568            result.unwrap_err(),
569            gitflow_core::CoreError::Cli(_)
570        ));
571    }
572
573    #[tokio::test]
574    async fn test_should_return_serialization_error_on_invalid_json_for_view() {
575        let runner = MockCommandRunner::success("invalid");
576        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
577
578        let result = provider.view("v1.0.0").await;
579
580        assert!(matches!(
581            result.unwrap_err(),
582            gitflow_core::CoreError::Serialization(_)
583        ));
584    }
585
586    #[tokio::test]
587    async fn test_should_return_platform_error_when_glab_fails_for_edit() {
588        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
589        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
590
591        let result = provider.edit("v1.0.0", sample_create_args()).await;
592
593        assert!(matches!(
594            result.unwrap_err(),
595            gitflow_core::CoreError::Cli(_)
596        ));
597    }
598
599    #[tokio::test]
600    async fn test_should_return_serialization_error_on_invalid_json_for_edit() {
601        let runner = MockCommandRunner::success("invalid");
602        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
603
604        let result = provider.edit("v1.0.0", sample_create_args()).await;
605
606        assert!(matches!(
607            result.unwrap_err(),
608            gitflow_core::CoreError::Serialization(_)
609        ));
610    }
611
612    #[tokio::test]
613    async fn test_should_return_platform_error_when_glab_fails_for_delete() {
614        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
615        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
616
617        let result = provider.delete("v1.0.0").await;
618
619        assert!(matches!(
620            result.unwrap_err(),
621            gitflow_core::CoreError::Cli(_)
622        ));
623    }
624
625    #[tokio::test]
626    async fn test_should_return_platform_error_when_glab_fails_for_upload_asset() {
627        let runner = MockCommandRunner::failure(r#"{"message": "Upload failed"}"#, 256);
628        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
629
630        let result = provider
631            .upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
632            .await;
633
634        assert!(matches!(
635            result.unwrap_err(),
636            gitflow_core::CoreError::Cli(_)
637        ));
638    }
639
640    #[tokio::test]
641    async fn test_should_return_platform_error_when_glab_fails_for_download_asset() {
642        let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
643        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
644
645        let result = provider
646            .download_asset("v1.0.0", "asset.tar.gz", "/tmp/asset.tar.gz")
647            .await;
648
649        assert!(matches!(
650            result.unwrap_err(),
651            gitflow_core::CoreError::Cli(_)
652        ));
653    }
654
655    // --- ApiUser to UserSummary conversion ---
656
657    #[test]
658    fn test_should_convert_api_user_to_user_summary() {
659        let api_user = ApiUser {
660            username: "admin".into(),
661            id: 42,
662        };
663        let summary: UserSummary = (&api_user).into();
664        assert_eq!(summary.login, "admin");
665        assert_eq!(summary.id, "42");
666    }
667
668    #[test]
669    fn test_should_convert_api_user_with_zero_id() {
670        let api_user = ApiUser {
671            username: "bot".into(),
672            id: 0,
673        };
674        let summary: UserSummary = (&api_user).into();
675        assert_eq!(summary.login, "bot");
676        assert_eq!(summary.id, "0");
677    }
678
679    // --- ReleaseApiResponse to ReleaseData conversion edge cases ---
680
681    #[test]
682    fn test_should_convert_minimal_api_response_to_release_data() {
683        let api = ReleaseApiResponse {
684            tag_name: "v1.0.0".into(),
685            name: None,
686            description: None,
687            draft: false,
688            prerelease: false,
689            author: None,
690            created_at: None,
691            released_at: None,
692            url: None,
693            id: None,
694        };
695        let release: ReleaseData = api.into();
696        assert_eq!(release.tag_name, "v1.0.0");
697        assert_eq!(release.id, 0); // defaults to 0 when id is None
698        assert!(release.name.is_none());
699        assert!(release.body.is_none());
700        assert!(!release.draft);
701        assert!(!release.prerelease);
702        assert!(release.author.is_none());
703        assert!(release.published_at.is_none());
704        assert_eq!(release.url, ""); // defaults to empty string
705        // created_at defaults to Utc::now() when None
706    }
707
708    #[test]
709    fn test_should_preserve_all_fields_in_full_api_response_conversion() {
710        let api = ReleaseApiResponse {
711            tag_name: "v2.0.0".into(),
712            name: Some("Major Release".into()),
713            description: Some("Breaking changes".into()),
714            draft: true,
715            prerelease: false,
716            author: Some(ApiUser {
717                username: "dev".into(),
718                id: 7,
719            }),
720            created_at: Some("2026-06-01T00:00:00Z".parse().expect("valid datetime")),
721            released_at: Some("2026-06-15T12:00:00Z".parse().expect("valid datetime")),
722            url: Some("https://gitlab.com/ns/proj/-/releases/v2.0.0".into()),
723            id: Some(200),
724        };
725        let release: ReleaseData = api.into();
726        assert_eq!(release.id, 200);
727        assert_eq!(release.tag_name, "v2.0.0");
728        assert_eq!(release.name.as_deref(), Some("Major Release"));
729        assert_eq!(release.body.as_deref(), Some("Breaking changes"));
730        assert!(release.draft);
731        assert!(!release.prerelease);
732        assert_eq!(release.author.as_ref().expect("author").login, "dev");
733        assert_eq!(release.author.as_ref().expect("author").id, "7");
734        assert_eq!(release.url, "https://gitlab.com/ns/proj/-/releases/v2.0.0");
735    }
736
737    // --- with_runner constructor ---
738
739    #[test]
740    fn test_should_create_provider_with_custom_runner() {
741        let runner = MockCommandRunner::success("");
742        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
743        assert_eq!(provider.repo, "owner/repo");
744    }
745
746    // --- Success-path tests ---
747
748    fn valid_release_api_json() -> &'static str {
749        r#"{
750            "id": 1,
751            "tag_name": "v1.0.0",
752            "name": "Version 1.0.0",
753            "description": "Release notes",
754            "draft": false,
755            "prerelease": false,
756            "author": {"username": "admin", "id": 1},
757            "created_at": "2026-01-01T00:00:00Z",
758            "released_at": "2026-01-01T00:00:00Z",
759            "url": "https://gitlab.com/owner/repo/-/releases/v1.0.0"
760        }"#
761    }
762
763    #[tokio::test]
764    async fn test_should_view_release_successfully() {
765        let runner = MockCommandRunner::success(valid_release_api_json());
766        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
767
768        let release = provider.view("v1.0.0").await.expect("view should succeed");
769        assert_eq!(release.tag_name, "v1.0.0");
770        assert_eq!(release.name.as_deref(), Some("Version 1.0.0"));
771        assert_eq!(release.id, 1);
772    }
773
774    #[tokio::test]
775    async fn test_should_list_releases_successfully() {
776        let json = format!("[{}]", valid_release_api_json());
777        let runner = MockCommandRunner::success(&json);
778        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
779
780        let releases = provider.list().await.expect("list should succeed");
781        assert_eq!(releases.len(), 1);
782        assert_eq!(releases[0].tag_name, "v1.0.0");
783    }
784
785    #[tokio::test]
786    async fn test_should_create_release_successfully() {
787        let runner = MockCommandRunner::success(valid_release_api_json());
788        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
789
790        let release = provider
791            .create(sample_create_args())
792            .await
793            .expect("create should succeed");
794        assert_eq!(release.tag_name, "v1.0.0");
795    }
796
797    #[tokio::test]
798    async fn test_should_edit_release_successfully() {
799        let runner = MockCommandRunner::success(valid_release_api_json());
800        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
801
802        let release = provider
803            .edit("v1.0.0", sample_create_args())
804            .await
805            .expect("edit should succeed");
806        assert_eq!(release.tag_name, "v1.0.0");
807    }
808
809    #[tokio::test]
810    async fn test_should_delete_release_successfully() {
811        let runner = MockCommandRunner::success("");
812        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
813
814        assert!(provider.delete("v1.0.0").await.is_ok());
815    }
816
817    #[tokio::test]
818    async fn test_should_upload_asset_successfully() {
819        let runner = MockCommandRunner::success("");
820        let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
821
822        assert!(
823            provider
824                .upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
825                .await
826                .is_ok()
827        );
828    }
829}