Skip to main content

gitflow_github/
release.rs

1//! GitHub Release 提供者实现。
2//!
3//! 通过 `gh` CLI 实现 [`ReleaseProvider`] trait,支持 Release 的创建、列表、
4//! 查看、编辑、资源上传/下载及删除。
5//! 命令执行通过 [`CommandRunner`] 抽象,捕获 stdout 并解析 JSON。
6
7use async_trait::async_trait;
8use gitflow_core::{
9    CoreError, Result,
10    release::{CreateReleaseArgs, ReleaseData, ReleaseProvider},
11};
12use tracing::debug;
13
14use crate::{
15    error::parse_gh_error,
16    runner::{CommandRunner, RealCommandRunner},
17};
18
19/// `gh release list` 请求的 JSON 字段列表。
20const RELEASE_LIST_FIELDS: &str = "tagName,name,isDraft,isPrerelease,createdAt,publishedAt";
21
22/// `gh release view` 请求的 JSON 字段列表。
23const RELEASE_VIEW_FIELDS: &str =
24    "databaseId,tagName,name,body,isDraft,isPrerelease,author,createdAt,publishedAt,url";
25
26/// GitHub Release 提供者,通过 `gh` CLI 操作。
27///
28/// 该结构体通过调用 `gh` CLI 实现 [`ReleaseProvider`] trait 的所有方法,
29/// 使上层命令能够以统一的方式操作 GitHub Release。
30///
31/// 命令执行通过 [`CommandRunner`] 抽象,生产环境默认使用
32/// [`RealCommandRunner`],测试可注入自定义 runner 以模拟成功或失败场景。
33///
34/// # Examples
35///
36/// ```no_run
37/// use gitflow_github::GitHubReleaseProvider;
38///
39/// let provider = GitHubReleaseProvider::new("octocat/hello-world");
40/// ```
41#[derive(Debug, Clone)]
42pub struct GitHubReleaseProvider<R: CommandRunner = RealCommandRunner> {
43    /// GitHub `owner/repo`,如 `"byx-darwin/gitflow-cli"`。
44    repo: String,
45    /// 用于执行 `gh` CLI 命令的 runner。
46    runner: R,
47}
48
49impl GitHubReleaseProvider<RealCommandRunner> {
50    /// 创建新的 GitHub Release 提供者,使用真实的进程执行器。
51    ///
52    /// `repo` 格式为 `owner/repo`。
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> GitHubReleaseProvider<R> {
63    /// 使用自定义 [`CommandRunner`] 创建提供者。
64    ///
65    /// 主要用于测试,可注入模拟 runner 以控制 `gh` CLI 的输出。
66    /// `repo` 格式为 `owner/repo`。
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#[async_trait]
77impl<R: CommandRunner + 'static> ReleaseProvider for GitHubReleaseProvider<R> {
78    async fn create(&self, args: CreateReleaseArgs) -> Result<ReleaseData> {
79        let mut cmd_args: Vec<&str> =
80            vec!["release", "create", &args.tag_name, "--repo", &self.repo];
81
82        if let Some(name) = &args.name {
83            cmd_args.push("--title");
84            cmd_args.push(name);
85        }
86
87        if let Some(body) = &args.body {
88            cmd_args.push("--notes");
89            cmd_args.push(body);
90        }
91
92        if args.draft {
93            cmd_args.push("--draft");
94        }
95
96        if args.prerelease {
97            cmd_args.push("--prerelease");
98        }
99
100        if let Some(commitish) = &args.target_commitish {
101            cmd_args.push("--target");
102            cmd_args.push(commitish);
103        }
104
105        debug!(
106            repo = %self.repo,
107            tag = %args.tag_name,
108            "spawning `gh release create`"
109        );
110
111        let output = self
112            .runner
113            .run("gh", &cmd_args)
114            .await
115            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
116
117        if !output.status.success() {
118            return Err(parse_gh_error(&output.stderr).into());
119        }
120
121        // gh release create doesn't support --json, so we fetch the created release
122        self.view(&args.tag_name).await
123    }
124
125    async fn list(&self) -> Result<Vec<ReleaseData>> {
126        debug!(repo = %self.repo, "spawning `gh release list`");
127
128        let output = self
129            .runner
130            .run(
131                "gh",
132                &[
133                    "release",
134                    "list",
135                    "--repo",
136                    &self.repo,
137                    "--json",
138                    RELEASE_LIST_FIELDS,
139                ],
140            )
141            .await
142            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
143
144        if !output.status.success() {
145            return Err(parse_gh_error(&output.stderr).into());
146        }
147
148        let releases: Vec<ReleaseData> =
149            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
150
151        Ok(releases)
152    }
153
154    async fn view(&self, tag_name: &str) -> Result<ReleaseData> {
155        debug!(repo = %self.repo, tag = %tag_name, "spawning `gh release view`");
156
157        let output = self
158            .runner
159            .run(
160                "gh",
161                &[
162                    "release",
163                    "view",
164                    tag_name,
165                    "--repo",
166                    &self.repo,
167                    "--json",
168                    RELEASE_VIEW_FIELDS,
169                ],
170            )
171            .await
172            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
173
174        if !output.status.success() {
175            return Err(parse_gh_error(&output.stderr).into());
176        }
177
178        let release: ReleaseData =
179            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
180
181        Ok(release)
182    }
183
184    async fn edit(&self, tag_name: &str, args: CreateReleaseArgs) -> Result<ReleaseData> {
185        let mut cmd_args: Vec<&str> = vec!["release", "edit", tag_name, "--repo", &self.repo];
186
187        if let Some(name) = &args.name {
188            cmd_args.push("--title");
189            cmd_args.push(name);
190        }
191
192        if let Some(body) = &args.body {
193            cmd_args.push("--notes");
194            cmd_args.push(body);
195        }
196
197        if args.draft {
198            cmd_args.push("--draft");
199        }
200
201        if args.prerelease {
202            cmd_args.push("--prerelease");
203        }
204
205        if let Some(commitish) = &args.target_commitish {
206            cmd_args.push("--target");
207            cmd_args.push(commitish);
208        }
209
210        debug!(
211            repo = %self.repo,
212            tag = %tag_name,
213            "spawning `gh release edit`"
214        );
215
216        let output = self
217            .runner
218            .run("gh", &cmd_args)
219            .await
220            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
221
222        if !output.status.success() {
223            return Err(parse_gh_error(&output.stderr).into());
224        }
225
226        // gh release edit doesn't support --json, so we fetch the edited release
227        self.view(tag_name).await
228    }
229
230    async fn upload_asset(&self, tag_name: &str, file_path: &str, _asset_name: &str) -> Result<()> {
231        debug!(
232            repo = %self.repo,
233            tag = %tag_name,
234            file = %file_path,
235            "spawning `gh release upload`"
236        );
237
238        let output = self
239            .runner
240            .run(
241                "gh",
242                &[
243                    "release", "upload", tag_name, file_path, "--repo", &self.repo,
244                ],
245            )
246            .await
247            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
248
249        if !output.status.success() {
250            return Err(parse_gh_error(&output.stderr).into());
251        }
252
253        Ok(())
254    }
255
256    #[allow(clippy::disallowed_methods)]
257    async fn download_asset(
258        &self,
259        tag_name: &str,
260        asset_name: &str,
261        dest_path: &str,
262    ) -> Result<()> {
263        debug!(
264            repo = %self.repo,
265            tag = %tag_name,
266            asset = %asset_name,
267            dest = %dest_path,
268            "spawning `gh release download`"
269        );
270
271        // 下载到目标文件的父目录,然后重命名到目标路径
272        let dest = std::path::PathBuf::from(dest_path);
273        let parent = dest.parent().unwrap_or_else(|| std::path::Path::new("."));
274        let parent_str = parent.to_str().ok_or_else(|| {
275            CoreError::Platform(format!(
276                "Destination directory is not valid UTF-8: {dest_path}"
277            ))
278        })?;
279
280        let output = self
281            .runner
282            .run(
283                "gh",
284                &[
285                    "release",
286                    "download",
287                    tag_name,
288                    "--repo",
289                    &self.repo,
290                    "--pattern",
291                    asset_name,
292                    "--dir",
293                    parent_str,
294                ],
295            )
296            .await
297            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
298
299        if !output.status.success() {
300            return Err(parse_gh_error(&output.stderr).into());
301        }
302
303        // gh 使用资源的实际文件名下载,尝试找到并移动
304        let downloaded = parent.join(asset_name);
305        if downloaded != dest && downloaded.exists() {
306            std::fs::rename(&downloaded, &dest).map_err(|e| {
307                CoreError::Platform(format!(
308                    "Failed to move downloaded asset to {dest_path}: {e}"
309                ))
310            })?;
311        }
312
313        Ok(())
314    }
315
316    async fn delete(&self, tag_name: &str) -> Result<()> {
317        debug!(repo = %self.repo, tag = %tag_name, "spawning `gh release delete`");
318
319        let output = self
320            .runner
321            .run(
322                "gh",
323                &[
324                    "release",
325                    "delete",
326                    tag_name,
327                    "--repo",
328                    &self.repo,
329                    "--yes",
330                    "--cleanup-tag",
331                ],
332            )
333            .await
334            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
335
336        if !output.status.success() {
337            // Idempotency: deleting an already-deleted release reports "not found".
338            // Treat it as success so automation can safely re-run delete.
339            if is_release_not_found(&output.stderr) {
340                debug!(repo = %self.repo, tag = %tag_name, "release already deleted, treating as success");
341                return Ok(());
342            }
343            return Err(parse_gh_error(&output.stderr).into());
344        }
345
346        Ok(())
347    }
348}
349
350/// Detect whether `gh` reported that a release (or its tag) does not exist.
351///
352/// `gh release delete` returns a non-zero exit with a "not found" message when the
353/// release was already deleted. `delete` treats this as idempotent success so that
354/// automation can safely re-run deletion. Detection is intentionally conservative:
355/// only messages mentioning a missing release/tag qualify, so unrelated errors
356/// (auth, permission, network) still surface as failures.
357///
358/// Accepts both the JSON form (`{"message": "Not Found", "code": "NOT_FOUND"}`) and
359/// plain-text stderr (`release not found`).
360#[must_use]
361fn is_release_not_found(stderr: &[u8]) -> bool {
362    let text = String::from_utf8_lossy(stderr);
363    let lower = text.to_ascii_lowercase();
364
365    // JSON error shape: code NOT_FOUND or message contains "not found".
366    if let Ok(json) = serde_json::from_slice::<serde_json::Value>(stderr) {
367        let code_matches = json
368            .get("code")
369            .and_then(serde_json::Value::as_str)
370            .is_some_and(|c| c == "NOT_FOUND");
371        let msg_matches = json
372            .get("message")
373            .and_then(serde_json::Value::as_str)
374            .is_some_and(|m| m.to_ascii_lowercase().contains("not found"));
375        if code_matches || msg_matches {
376            return true;
377        }
378    }
379
380    // Plain-text form: mention of a missing release or tag.
381    lower.contains("release not found")
382        || (lower.contains("not found")
383            && (lower.contains("release") || lower.contains("tag") || lower.contains("404")))
384}
385
386#[cfg(test)]
387mod tests {
388    use super::*;
389    use crate::runner::{CommandOutput, MockCommandRunner};
390
391    /// Test runner that records every invocation's arguments.
392    ///
393    /// Used to assert that the `gh release delete` call includes `--cleanup-tag`.
394    /// Clones share the same recorded call list via `Arc<Mutex<...>>`.
395    #[derive(Debug, Clone)]
396    struct ArgsCapturingRunner {
397        calls: std::sync::Arc<std::sync::Mutex<Vec<Vec<String>>>>,
398    }
399
400    impl ArgsCapturingRunner {
401        fn new() -> Self {
402            Self {
403                calls: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
404            }
405        }
406    }
407
408    #[async_trait::async_trait]
409    impl CommandRunner for ArgsCapturingRunner {
410        async fn run(&self, _program: &str, args: &[&str]) -> std::io::Result<CommandOutput> {
411            self.calls
412                .lock()
413                .expect("lock calls")
414                .push(args.iter().map(ToString::to_string).collect());
415            Ok(CommandOutput {
416                status: MockCommandRunner::make_exit_status(0),
417                stdout: Vec::new(),
418                stderr: Vec::new(),
419            })
420        }
421
422        async fn run_with_stdin(
423            &self,
424            program: &str,
425            args: &[&str],
426            _stdin_data: &[u8],
427        ) -> std::io::Result<CommandOutput> {
428            self.run(program, args).await
429        }
430    }
431
432    #[test]
433    fn test_should_construct_github_release_provider() {
434        let provider = GitHubReleaseProvider::new("octocat/hello-world");
435        assert_eq!(provider.repo, "octocat/hello-world");
436    }
437
438    #[test]
439    fn test_should_construct_github_release_provider_from_string() {
440        let repo = String::from("octocat/hello-world");
441        let provider = GitHubReleaseProvider::new(repo);
442        assert_eq!(provider.repo, "octocat/hello-world");
443    }
444
445    #[test]
446    fn test_should_deserialize_release_data_from_gh_output() {
447        // 模拟 `gh release view --json ...` 的实际输出
448        let gh_json = br#"{
449            "id": 1001,
450            "tagName": "v1.0.0",
451            "name": "Version 1.0.0",
452            "body": "Initial stable release",
453            "draft": false,
454            "prerelease": false,
455            "author": {"login": "octocat", "id": "1"},
456            "createdAt": "2026-01-01T00:00:00Z",
457            "publishedAt": "2026-01-15T12:00:00Z",
458            "url": "https://github.com/octocat/hello-world/releases/tag/v1.0.0"
459        }"#;
460
461        let release: ReleaseData = serde_json::from_slice(gh_json).expect("valid ReleaseData JSON");
462        assert_eq!(release.id, 1001);
463        assert_eq!(release.tag_name, "v1.0.0");
464        assert_eq!(release.name.as_deref(), Some("Version 1.0.0"));
465        assert_eq!(release.body.as_deref(), Some("Initial stable release"));
466        assert!(!release.draft);
467        assert!(!release.prerelease);
468        assert_eq!(release.author.as_ref().unwrap().login, "octocat");
469        assert_eq!(release.author.as_ref().unwrap().id, "1");
470        assert_eq!(
471            release.url,
472            "https://github.com/octocat/hello-world/releases/tag/v1.0.0"
473        );
474    }
475
476    #[test]
477    fn test_should_deserialize_empty_release_list_from_gh_output() {
478        let gh_json = b"[]";
479        let releases: Vec<ReleaseData> =
480            serde_json::from_slice(gh_json).expect("valid ReleaseData list");
481        assert!(releases.is_empty());
482    }
483
484    #[test]
485    fn test_should_deserialize_draft_release_from_gh_output() {
486        let gh_json = br#"{
487            "id": 5,
488            "tagName": "v0.1.0-draft",
489            "name": null,
490            "body": null,
491            "draft": true,
492            "prerelease": true,
493            "author": {"login": "dev", "id": "99"},
494            "createdAt": "2026-03-01T00:00:00Z",
495            "publishedAt": null,
496            "url": "https://example.com/releases/5"
497        }"#;
498
499        let release: ReleaseData =
500            serde_json::from_slice(gh_json).expect("valid draft ReleaseData");
501        assert!(release.draft);
502        assert!(release.prerelease);
503        assert!(release.name.is_none());
504        assert!(release.body.is_none());
505        assert!(release.published_at.is_none());
506    }
507
508    #[test]
509    fn test_should_debug_format_provider() {
510        let provider = GitHubReleaseProvider::new("octocat/hello-world");
511        let debug = format!("{provider:?}");
512        assert!(debug.contains("GitHubReleaseProvider"));
513        assert!(debug.contains("octocat/hello-world"));
514    }
515
516    #[test]
517    fn test_should_create_provider_with_different_repos() {
518        let r1 = GitHubReleaseProvider::new("org/repo-a");
519        let r2 = GitHubReleaseProvider::new("org/repo-b");
520        assert_eq!(r1.repo, "org/repo-a");
521        assert_eq!(r2.repo, "org/repo-b");
522    }
523
524    #[test]
525    fn test_should_clone_github_release_provider() {
526        let original = GitHubReleaseProvider::new("owner/repo");
527        let cloned = original.clone();
528        assert_eq!(original.repo, cloned.repo);
529    }
530
531    // --- Failure-path tests using an injected MockCommandRunner ---
532
533    fn sample_create_args() -> CreateReleaseArgs {
534        CreateReleaseArgs {
535            tag_name: "v1.0.0".to_string(),
536            name: Some("Version 1.0.0".to_string()),
537            body: Some("Release notes".to_string()),
538            draft: false,
539            prerelease: false,
540            target_commitish: None,
541        }
542    }
543
544    #[tokio::test]
545    async fn test_should_return_platform_error_when_gh_fails_for_create() {
546        let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
547        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
548
549        let result = provider.create(sample_create_args()).await;
550
551        assert!(result.is_err());
552        assert!(matches!(
553            result.unwrap_err(),
554            gitflow_core::CoreError::Cli(_)
555        ));
556    }
557
558    #[tokio::test]
559    async fn test_should_return_serialization_error_on_invalid_json_for_create() {
560        // `create` succeeds, then re-fetches via `view`, whose invalid JSON fails parsing.
561        let runner = MockCommandRunner::success("invalid json");
562        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
563
564        let result = provider.create(sample_create_args()).await;
565
566        assert!(result.is_err());
567        assert!(matches!(
568            result.unwrap_err(),
569            gitflow_core::CoreError::Serialization(_)
570        ));
571    }
572
573    #[tokio::test]
574    async fn test_should_return_platform_error_when_gh_fails_for_list() {
575        let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
576        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
577
578        let result = provider.list().await;
579
580        assert!(result.is_err());
581        assert!(matches!(
582            result.unwrap_err(),
583            gitflow_core::CoreError::Cli(_)
584        ));
585    }
586
587    #[tokio::test]
588    async fn test_should_return_serialization_error_on_invalid_json_for_list() {
589        let runner = MockCommandRunner::success("invalid json");
590        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
591
592        let result = provider.list().await;
593
594        assert!(result.is_err());
595        assert!(matches!(
596            result.unwrap_err(),
597            gitflow_core::CoreError::Serialization(_)
598        ));
599    }
600
601    #[tokio::test]
602    async fn test_should_return_platform_error_when_gh_fails_for_view() {
603        let runner = MockCommandRunner::failure(r#"{"message": "Release not found"}"#, 256);
604        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
605
606        let result = provider.view("v1.0.0").await;
607
608        assert!(result.is_err());
609        assert!(matches!(
610            result.unwrap_err(),
611            gitflow_core::CoreError::Cli(_)
612        ));
613    }
614
615    #[tokio::test]
616    async fn test_should_return_serialization_error_on_invalid_json_for_view() {
617        let runner = MockCommandRunner::success("invalid json");
618        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
619
620        let result = provider.view("v1.0.0").await;
621
622        assert!(result.is_err());
623        assert!(matches!(
624            result.unwrap_err(),
625            gitflow_core::CoreError::Serialization(_)
626        ));
627    }
628
629    #[tokio::test]
630    async fn test_should_return_platform_error_when_gh_fails_for_edit() {
631        let runner = MockCommandRunner::failure(r#"{"message": "Release not found"}"#, 256);
632        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
633
634        let result = provider.edit("v1.0.0", sample_create_args()).await;
635
636        assert!(result.is_err());
637        assert!(matches!(
638            result.unwrap_err(),
639            gitflow_core::CoreError::Cli(_)
640        ));
641    }
642
643    #[tokio::test]
644    async fn test_should_return_serialization_error_on_invalid_json_for_edit() {
645        // `edit` succeeds, then re-fetches via `view`, whose invalid JSON fails parsing.
646        let runner = MockCommandRunner::success("invalid json");
647        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
648
649        let result = provider.edit("v1.0.0", sample_create_args()).await;
650
651        assert!(result.is_err());
652        assert!(matches!(
653            result.unwrap_err(),
654            gitflow_core::CoreError::Serialization(_)
655        ));
656    }
657
658    #[tokio::test]
659    async fn test_should_return_platform_error_when_gh_fails_for_delete() {
660        // Non-"not found" failures must still surface as errors.
661        let runner = MockCommandRunner::failure(r#"{"message": "Not logged in"}"#, 256);
662        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
663
664        let result = provider.delete("v1.0.0").await;
665
666        assert!(result.is_err());
667        assert!(matches!(
668            result.unwrap_err(),
669            gitflow_core::CoreError::Cli(_)
670        ));
671    }
672
673    #[tokio::test]
674    async fn test_should_treat_missing_release_as_idempotent_success() {
675        // gh reports "Release not found" when deleting an already-deleted release.
676        // The delete must treat this as success (idempotent), not an error.
677        let runner = MockCommandRunner::failure(r#"{"message": "Release not found"}"#, 256);
678        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
679
680        let result = provider.delete("v1.0.0").await;
681
682        assert!(result.is_ok(), "expected Ok (idempotent), got {result:?}");
683    }
684
685    #[tokio::test]
686    async fn test_should_treat_text_not_found_as_idempotent_success() {
687        // gh may emit a plain-text "release not found" (non-JSON) stderr.
688        // It must also be treated as idempotent success.
689        let runner = MockCommandRunner::failure("release not found\n", 256);
690        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
691
692        let result = provider.delete("v1.0.0").await;
693
694        assert!(result.is_ok(), "expected Ok (idempotent), got {result:?}");
695    }
696
697    #[tokio::test]
698    async fn test_should_pass_cleanup_tag_flag_on_delete() {
699        // The `gh release delete` invocation must include `--cleanup-tag` so the
700        // underlying git tag is removed alongside the GitHub Release record.
701        let runner = ArgsCapturingRunner::new();
702        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner.clone());
703
704        provider
705            .delete("v1.0.0")
706            .await
707            .expect("delete must succeed");
708
709        let calls = runner.calls.lock().expect("lock calls");
710        let last = calls.last().expect("at least one gh call");
711        assert!(
712            last.contains(&"--cleanup-tag".to_string()),
713            "delete args must include --cleanup-tag, got: {last:?}"
714        );
715    }
716
717    #[tokio::test]
718    async fn test_should_return_platform_error_when_gh_fails_for_upload_asset() {
719        let runner = MockCommandRunner::failure(r#"{"message": "Upload failed"}"#, 256);
720        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
721
722        let result = provider
723            .upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
724            .await;
725
726        assert!(result.is_err());
727        assert!(matches!(
728            result.unwrap_err(),
729            gitflow_core::CoreError::Cli(_)
730        ));
731    }
732
733    #[tokio::test]
734    async fn test_should_return_platform_error_when_gh_fails_for_download_asset() {
735        let runner = MockCommandRunner::failure(r#"{"message": "Asset not found"}"#, 256);
736        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
737
738        let result = provider
739            .download_asset("v1.0.0", "asset.tar.gz", "/tmp/download/asset.tar.gz")
740            .await;
741
742        assert!(result.is_err());
743        assert!(matches!(
744            result.unwrap_err(),
745            gitflow_core::CoreError::Cli(_)
746        ));
747    }
748}