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, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, fetch_capped,
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    /// Create a new provider from a shared [`Session`].
62    ///
63    /// This enables state reuse across multiple operations in workflow chains.
64    #[must_use]
65    pub fn with_session(session: &gitflow_core::Session) -> Self {
66        Self {
67            repo: session.repo.clone(),
68            runner: RealCommandRunner,
69        }
70    }
71}
72
73impl<R: CommandRunner> GitHubReleaseProvider<R> {
74    /// 使用自定义 [`CommandRunner`] 创建提供者。
75    ///
76    /// 主要用于测试,可注入模拟 runner 以控制 `gh` CLI 的输出。
77    /// `repo` 格式为 `owner/repo`。
78    #[must_use]
79    pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
80        Self {
81            repo: repo.into(),
82            runner,
83        }
84    }
85}
86
87#[async_trait]
88impl<R: CommandRunner + 'static> ReleaseProvider for GitHubReleaseProvider<R> {
89    async fn create(&self, args: CreateReleaseArgs) -> Result<ReleaseData> {
90        let mut cmd_args: Vec<&str> =
91            vec!["release", "create", &args.tag_name, "--repo", &self.repo];
92
93        if let Some(name) = &args.name {
94            cmd_args.push("--title");
95            cmd_args.push(name);
96        }
97
98        if let Some(body) = &args.body {
99            cmd_args.push("--notes");
100            cmd_args.push(body);
101        }
102
103        if args.draft {
104            cmd_args.push("--draft");
105        }
106
107        if args.prerelease {
108            cmd_args.push("--prerelease");
109        }
110
111        if let Some(commitish) = &args.target_commitish {
112            cmd_args.push("--target");
113            cmd_args.push(commitish);
114        }
115
116        debug!(
117            repo = %self.repo,
118            tag = %args.tag_name,
119            "spawning `gh release create`"
120        );
121
122        let output = self
123            .runner
124            .run("gh", &cmd_args)
125            .await
126            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
127
128        if !output.status.success() {
129            return Err(parse_gh_error(&output.stderr).into());
130        }
131
132        // gh release create doesn't support --json, so we fetch the created release
133        self.view(&args.tag_name).await
134    }
135
136    async fn list(&self, limit: Option<u32>) -> Result<Paged<ReleaseData>> {
137        let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
138        let repo = &self.repo;
139        let runner = &self.runner;
140
141        debug!(repo = %self.repo, cap, "spawning `gh release list`");
142
143        fetch_capped(FetchStrategy::SingleShot, cap, |_page, limit| async move {
144            let limit_str = limit.to_string();
145            let output = runner
146                .run(
147                    "gh",
148                    &[
149                        "release",
150                        "list",
151                        "--repo",
152                        repo,
153                        "--json",
154                        RELEASE_LIST_FIELDS,
155                        "--limit",
156                        &limit_str,
157                    ],
158                )
159                .await
160                .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
161
162            if !output.status.success() {
163                return Err(parse_gh_error(&output.stderr).into());
164            }
165
166            let releases: Vec<ReleaseData> =
167                serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
168            Ok(releases)
169        })
170        .await
171    }
172
173    async fn view(&self, tag_name: &str) -> Result<ReleaseData> {
174        debug!(repo = %self.repo, tag = %tag_name, "spawning `gh release view`");
175
176        let output = self
177            .runner
178            .run(
179                "gh",
180                &[
181                    "release",
182                    "view",
183                    tag_name,
184                    "--repo",
185                    &self.repo,
186                    "--json",
187                    RELEASE_VIEW_FIELDS,
188                ],
189            )
190            .await
191            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
192
193        if !output.status.success() {
194            return Err(parse_gh_error(&output.stderr).into());
195        }
196
197        let release: ReleaseData =
198            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
199
200        Ok(release)
201    }
202
203    async fn edit(&self, tag_name: &str, args: CreateReleaseArgs) -> Result<ReleaseData> {
204        let mut cmd_args: Vec<&str> = vec!["release", "edit", tag_name, "--repo", &self.repo];
205
206        if let Some(name) = &args.name {
207            cmd_args.push("--title");
208            cmd_args.push(name);
209        }
210
211        if let Some(body) = &args.body {
212            cmd_args.push("--notes");
213            cmd_args.push(body);
214        }
215
216        if args.draft {
217            cmd_args.push("--draft");
218        }
219
220        if args.prerelease {
221            cmd_args.push("--prerelease");
222        }
223
224        if let Some(commitish) = &args.target_commitish {
225            cmd_args.push("--target");
226            cmd_args.push(commitish);
227        }
228
229        debug!(
230            repo = %self.repo,
231            tag = %tag_name,
232            "spawning `gh release edit`"
233        );
234
235        let output = self
236            .runner
237            .run("gh", &cmd_args)
238            .await
239            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
240
241        if !output.status.success() {
242            return Err(parse_gh_error(&output.stderr).into());
243        }
244
245        // gh release edit doesn't support --json, so we fetch the edited release
246        self.view(tag_name).await
247    }
248
249    async fn upload_asset(&self, tag_name: &str, file_path: &str, _asset_name: &str) -> Result<()> {
250        debug!(
251            repo = %self.repo,
252            tag = %tag_name,
253            file = %file_path,
254            "spawning `gh release upload`"
255        );
256
257        let output = self
258            .runner
259            .run(
260                "gh",
261                &[
262                    "release", "upload", tag_name, file_path, "--repo", &self.repo,
263                ],
264            )
265            .await
266            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
267
268        if !output.status.success() {
269            return Err(parse_gh_error(&output.stderr).into());
270        }
271
272        Ok(())
273    }
274
275    #[allow(clippy::disallowed_methods)]
276    async fn download_asset(
277        &self,
278        tag_name: &str,
279        asset_name: &str,
280        dest_path: &str,
281    ) -> Result<()> {
282        debug!(
283            repo = %self.repo,
284            tag = %tag_name,
285            asset = %asset_name,
286            dest = %dest_path,
287            "spawning `gh release download`"
288        );
289
290        // 下载到目标文件的父目录,然后重命名到目标路径
291        let dest = std::path::PathBuf::from(dest_path);
292        let parent = dest.parent().unwrap_or_else(|| std::path::Path::new("."));
293        let parent_str = parent.to_str().ok_or_else(|| {
294            CoreError::Platform(format!(
295                "Destination directory is not valid UTF-8: {dest_path}"
296            ))
297        })?;
298
299        let output = self
300            .runner
301            .run(
302                "gh",
303                &[
304                    "release",
305                    "download",
306                    tag_name,
307                    "--repo",
308                    &self.repo,
309                    "--pattern",
310                    asset_name,
311                    "--dir",
312                    parent_str,
313                ],
314            )
315            .await
316            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
317
318        if !output.status.success() {
319            return Err(parse_gh_error(&output.stderr).into());
320        }
321
322        // gh 使用资源的实际文件名下载,尝试找到并移动
323        let downloaded = parent.join(asset_name);
324        if downloaded != dest && downloaded.exists() {
325            std::fs::rename(&downloaded, &dest).map_err(|e| {
326                CoreError::Platform(format!(
327                    "Failed to move downloaded asset to {dest_path}: {e}"
328                ))
329            })?;
330        }
331
332        Ok(())
333    }
334
335    async fn delete(&self, tag_name: &str) -> Result<()> {
336        debug!(repo = %self.repo, tag = %tag_name, "spawning `gh release delete`");
337
338        let output = self
339            .runner
340            .run(
341                "gh",
342                &[
343                    "release",
344                    "delete",
345                    tag_name,
346                    "--repo",
347                    &self.repo,
348                    "--yes",
349                    "--cleanup-tag",
350                ],
351            )
352            .await
353            .map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
354
355        if !output.status.success() {
356            // Idempotency: deleting an already-deleted release reports "not found".
357            // Treat it as success so automation can safely re-run delete.
358            if is_release_not_found(&output.stderr) {
359                debug!(repo = %self.repo, tag = %tag_name, "release already deleted, treating as success");
360                return Ok(());
361            }
362            return Err(parse_gh_error(&output.stderr).into());
363        }
364
365        Ok(())
366    }
367}
368
369/// Detect whether `gh` reported that a release (or its tag) does not exist.
370///
371/// `gh release delete` returns a non-zero exit with a "not found" message when the
372/// release was already deleted. `delete` treats this as idempotent success so that
373/// automation can safely re-run deletion. Detection is intentionally conservative:
374/// only messages mentioning a missing release/tag qualify, so unrelated errors
375/// (auth, permission, network) still surface as failures.
376///
377/// Accepts both the JSON form (`{"message": "Not Found", "code": "NOT_FOUND"}`) and
378/// plain-text stderr (`release not found`).
379#[must_use]
380fn is_release_not_found(stderr: &[u8]) -> bool {
381    let text = String::from_utf8_lossy(stderr);
382    let lower = text.to_ascii_lowercase();
383
384    // JSON error shape: code NOT_FOUND or message contains "not found".
385    if let Ok(json) = serde_json::from_slice::<serde_json::Value>(stderr) {
386        let code_matches = json
387            .get("code")
388            .and_then(serde_json::Value::as_str)
389            .is_some_and(|c| c == "NOT_FOUND");
390        let msg_matches = json
391            .get("message")
392            .and_then(serde_json::Value::as_str)
393            .is_some_and(|m| m.to_ascii_lowercase().contains("not found"));
394        if code_matches || msg_matches {
395            return true;
396        }
397    }
398
399    // Plain-text form: mention of a missing release or tag.
400    lower.contains("release not found")
401        || (lower.contains("not found")
402            && (lower.contains("release") || lower.contains("tag") || lower.contains("404")))
403}
404
405#[cfg(test)]
406mod tests {
407    use super::*;
408    use crate::runner::{CommandOutput, MockCommandRunner, SequencedMockCommandRunner};
409
410    /// Test runner that records every invocation's arguments.
411    ///
412    /// Used to assert that the `gh release delete` call includes `--cleanup-tag`.
413    /// Clones share the same recorded call list via `Arc<Mutex<...>>`.
414    #[derive(Debug, Clone)]
415    struct ArgsCapturingRunner {
416        calls: std::sync::Arc<std::sync::Mutex<Vec<Vec<String>>>>,
417    }
418
419    impl ArgsCapturingRunner {
420        fn new() -> Self {
421            Self {
422                calls: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
423            }
424        }
425    }
426
427    #[async_trait::async_trait]
428    impl CommandRunner for ArgsCapturingRunner {
429        async fn run(&self, _program: &str, args: &[&str]) -> std::io::Result<CommandOutput> {
430            self.calls
431                .lock()
432                .expect("lock calls")
433                .push(args.iter().map(ToString::to_string).collect());
434            Ok(CommandOutput {
435                status: MockCommandRunner::make_exit_status(0),
436                stdout: Vec::new(),
437                stderr: Vec::new(),
438            })
439        }
440
441        async fn run_with_stdin(
442            &self,
443            program: &str,
444            args: &[&str],
445            _stdin_data: &[u8],
446        ) -> std::io::Result<CommandOutput> {
447            self.run(program, args).await
448        }
449    }
450
451    #[test]
452    fn test_should_construct_github_release_provider() {
453        let provider = GitHubReleaseProvider::new("octocat/hello-world");
454        assert_eq!(provider.repo, "octocat/hello-world");
455    }
456
457    #[test]
458    fn test_should_construct_github_release_provider_from_string() {
459        let repo = String::from("octocat/hello-world");
460        let provider = GitHubReleaseProvider::new(repo);
461        assert_eq!(provider.repo, "octocat/hello-world");
462    }
463
464    #[test]
465    fn test_should_deserialize_release_data_from_gh_output() {
466        // 模拟 `gh release view --json ...` 的实际输出
467        let gh_json = br#"{
468            "id": 1001,
469            "tagName": "v1.0.0",
470            "name": "Version 1.0.0",
471            "body": "Initial stable release",
472            "draft": false,
473            "prerelease": false,
474            "author": {"login": "octocat", "id": "1"},
475            "createdAt": "2026-01-01T00:00:00Z",
476            "publishedAt": "2026-01-15T12:00:00Z",
477            "url": "https://github.com/octocat/hello-world/releases/tag/v1.0.0"
478        }"#;
479
480        let release: ReleaseData = serde_json::from_slice(gh_json).expect("valid ReleaseData JSON");
481        assert_eq!(release.id, 1001);
482        assert_eq!(release.tag_name, "v1.0.0");
483        assert_eq!(release.name.as_deref(), Some("Version 1.0.0"));
484        assert_eq!(release.body.as_deref(), Some("Initial stable release"));
485        assert!(!release.draft);
486        assert!(!release.prerelease);
487        assert_eq!(release.author.as_ref().unwrap().login, "octocat");
488        assert_eq!(release.author.as_ref().unwrap().id, "1");
489        assert_eq!(
490            release.url,
491            "https://github.com/octocat/hello-world/releases/tag/v1.0.0"
492        );
493    }
494
495    #[test]
496    fn test_should_deserialize_empty_release_list_from_gh_output() {
497        let gh_json = b"[]";
498        let releases: Vec<ReleaseData> =
499            serde_json::from_slice(gh_json).expect("valid ReleaseData list");
500        assert!(releases.is_empty());
501    }
502
503    #[test]
504    fn test_should_deserialize_draft_release_from_gh_output() {
505        let gh_json = br#"{
506            "id": 5,
507            "tagName": "v0.1.0-draft",
508            "name": null,
509            "body": null,
510            "draft": true,
511            "prerelease": true,
512            "author": {"login": "dev", "id": "99"},
513            "createdAt": "2026-03-01T00:00:00Z",
514            "publishedAt": null,
515            "url": "https://example.com/releases/5"
516        }"#;
517
518        let release: ReleaseData =
519            serde_json::from_slice(gh_json).expect("valid draft ReleaseData");
520        assert!(release.draft);
521        assert!(release.prerelease);
522        assert!(release.name.is_none());
523        assert!(release.body.is_none());
524        assert!(release.published_at.is_none());
525    }
526
527    #[test]
528    fn test_should_deserialize_release_with_missing_created_at_from_gh_output() {
529        // gh CLI is not known to ever omit createdAt, but ReleaseData.created_at
530        // is now Option<DateTime<Utc>> at the core level (#366) — this pins that
531        // the github path tolerates it gracefully rather than erroring, since
532        // this crate has no intermediate struct or fallback logic of its own.
533        let gh_json = br#"{
534            "id": 8,
535            "tagName": "v0.9.0",
536            "draft": false,
537            "prerelease": false,
538            "url": "https://example.com/releases/8"
539        }"#;
540
541        let release: ReleaseData =
542            serde_json::from_slice(gh_json).expect("missing createdAt must not error");
543        assert!(release.created_at.is_none());
544    }
545
546    #[test]
547    fn test_should_debug_format_provider() {
548        let provider = GitHubReleaseProvider::new("octocat/hello-world");
549        let debug = format!("{provider:?}");
550        assert!(debug.contains("GitHubReleaseProvider"));
551        assert!(debug.contains("octocat/hello-world"));
552    }
553
554    #[test]
555    fn test_should_create_provider_with_different_repos() {
556        let r1 = GitHubReleaseProvider::new("org/repo-a");
557        let r2 = GitHubReleaseProvider::new("org/repo-b");
558        assert_eq!(r1.repo, "org/repo-a");
559        assert_eq!(r2.repo, "org/repo-b");
560    }
561
562    #[test]
563    fn test_should_clone_github_release_provider() {
564        let original = GitHubReleaseProvider::new("owner/repo");
565        let cloned = original.clone();
566        assert_eq!(original.repo, cloned.repo);
567    }
568
569    // --- Failure-path tests using an injected MockCommandRunner ---
570
571    fn sample_create_args() -> CreateReleaseArgs {
572        CreateReleaseArgs {
573            tag_name: "v1.0.0".to_string(),
574            name: Some("Version 1.0.0".to_string()),
575            body: Some("Release notes".to_string()),
576            draft: false,
577            prerelease: false,
578            target_commitish: None,
579        }
580    }
581
582    #[tokio::test]
583    async fn test_should_return_platform_error_when_gh_fails_for_create() {
584        let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
585        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
586
587        let result = provider.create(sample_create_args()).await;
588
589        assert!(result.is_err());
590        assert!(matches!(
591            result.unwrap_err(),
592            gitflow_core::CoreError::Cli(_)
593        ));
594    }
595
596    #[tokio::test]
597    async fn test_should_return_serialization_error_on_invalid_json_for_create() {
598        // `create` succeeds, then re-fetches via `view`, whose invalid JSON fails parsing.
599        let runner = MockCommandRunner::success("invalid json");
600        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
601
602        let result = provider.create(sample_create_args()).await;
603
604        assert!(result.is_err());
605        assert!(matches!(
606            result.unwrap_err(),
607            gitflow_core::CoreError::Serialization(_)
608        ));
609    }
610
611    #[tokio::test]
612    async fn test_should_return_platform_error_when_gh_fails_for_list() {
613        let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
614        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
615
616        let result = provider.list(None).await;
617
618        assert!(result.is_err());
619        assert!(matches!(
620            result.unwrap_err(),
621            gitflow_core::CoreError::Cli(_)
622        ));
623    }
624
625    #[tokio::test]
626    async fn test_should_return_serialization_error_on_invalid_json_for_list() {
627        let runner = MockCommandRunner::success("invalid json");
628        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
629
630        let result = provider.list(None).await;
631
632        assert!(result.is_err());
633        assert!(matches!(
634            result.unwrap_err(),
635            gitflow_core::CoreError::Serialization(_)
636        ));
637    }
638
639    #[tokio::test]
640    async fn test_should_return_platform_error_when_gh_fails_for_view() {
641        let runner = MockCommandRunner::failure(r#"{"message": "Release not found"}"#, 256);
642        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
643
644        let result = provider.view("v1.0.0").await;
645
646        assert!(result.is_err());
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_view() {
655        let runner = MockCommandRunner::success("invalid json");
656        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
657
658        let result = provider.view("v1.0.0").await;
659
660        assert!(result.is_err());
661        assert!(matches!(
662            result.unwrap_err(),
663            gitflow_core::CoreError::Serialization(_)
664        ));
665    }
666
667    #[tokio::test]
668    async fn test_should_return_platform_error_when_gh_fails_for_edit() {
669        let runner = MockCommandRunner::failure(r#"{"message": "Release not found"}"#, 256);
670        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
671
672        let result = provider.edit("v1.0.0", sample_create_args()).await;
673
674        assert!(result.is_err());
675        assert!(matches!(
676            result.unwrap_err(),
677            gitflow_core::CoreError::Cli(_)
678        ));
679    }
680
681    #[tokio::test]
682    async fn test_should_return_serialization_error_on_invalid_json_for_edit() {
683        // `edit` succeeds, then re-fetches via `view`, whose invalid JSON fails parsing.
684        let runner = MockCommandRunner::success("invalid json");
685        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
686
687        let result = provider.edit("v1.0.0", sample_create_args()).await;
688
689        assert!(result.is_err());
690        assert!(matches!(
691            result.unwrap_err(),
692            gitflow_core::CoreError::Serialization(_)
693        ));
694    }
695
696    #[tokio::test]
697    async fn test_should_return_platform_error_when_gh_fails_for_delete() {
698        // Non-"not found" failures must still surface as errors.
699        let runner = MockCommandRunner::failure(r#"{"message": "Not logged in"}"#, 256);
700        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
701
702        let result = provider.delete("v1.0.0").await;
703
704        assert!(result.is_err());
705        assert!(matches!(
706            result.unwrap_err(),
707            gitflow_core::CoreError::Cli(_)
708        ));
709    }
710
711    #[tokio::test]
712    async fn test_should_treat_missing_release_as_idempotent_success() {
713        // gh reports "Release not found" when deleting an already-deleted release.
714        // The delete must treat this as success (idempotent), not an error.
715        let runner = MockCommandRunner::failure(r#"{"message": "Release not found"}"#, 256);
716        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
717
718        let result = provider.delete("v1.0.0").await;
719
720        assert!(result.is_ok(), "expected Ok (idempotent), got {result:?}");
721    }
722
723    #[tokio::test]
724    async fn test_should_treat_text_not_found_as_idempotent_success() {
725        // gh may emit a plain-text "release not found" (non-JSON) stderr.
726        // It must also be treated as idempotent success.
727        let runner = MockCommandRunner::failure("release not found\n", 256);
728        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
729
730        let result = provider.delete("v1.0.0").await;
731
732        assert!(result.is_ok(), "expected Ok (idempotent), got {result:?}");
733    }
734
735    #[tokio::test]
736    async fn test_should_pass_cleanup_tag_flag_on_delete() {
737        // The `gh release delete` invocation must include `--cleanup-tag` so the
738        // underlying git tag is removed alongside the GitHub Release record.
739        let runner = ArgsCapturingRunner::new();
740        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner.clone());
741
742        provider
743            .delete("v1.0.0")
744            .await
745            .expect("delete must succeed");
746
747        let calls = runner.calls.lock().expect("lock calls");
748        let last = calls.last().expect("at least one gh call");
749        assert!(
750            last.contains(&"--cleanup-tag".to_string()),
751            "delete args must include --cleanup-tag, got: {last:?}"
752        );
753    }
754
755    #[tokio::test]
756    async fn test_should_return_platform_error_when_gh_fails_for_upload_asset() {
757        let runner = MockCommandRunner::failure(r#"{"message": "Upload failed"}"#, 256);
758        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
759
760        let result = provider
761            .upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
762            .await;
763
764        assert!(result.is_err());
765        assert!(matches!(
766            result.unwrap_err(),
767            gitflow_core::CoreError::Cli(_)
768        ));
769    }
770
771    #[tokio::test]
772    async fn test_should_return_platform_error_when_gh_fails_for_download_asset() {
773        let runner = MockCommandRunner::failure(r#"{"message": "Asset not found"}"#, 256);
774        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
775
776        let result = provider
777            .download_asset("v1.0.0", "asset.tar.gz", "/tmp/download/asset.tar.gz")
778            .await;
779
780        assert!(result.is_err());
781        assert!(matches!(
782            result.unwrap_err(),
783            gitflow_core::CoreError::Cli(_)
784        ));
785    }
786
787    // --- is_release_not_found unit tests ---
788
789    #[test]
790    fn test_should_detect_json_not_found_code() {
791        let stderr = br#"{"message":"Not Found","code":"NOT_FOUND"}"#;
792        assert!(is_release_not_found(stderr));
793    }
794
795    #[test]
796    fn test_should_detect_json_not_found_message() {
797        let stderr = br#"{"message":"Release not found"}"#;
798        assert!(is_release_not_found(stderr));
799    }
800
801    #[test]
802    fn test_should_not_detect_unrelated_json_error() {
803        let stderr = br#"{"message":"Forbidden","code":"FORBIDDEN"}"#;
804        assert!(!is_release_not_found(stderr));
805    }
806
807    #[test]
808    fn test_should_detect_plain_text_release_not_found() {
809        assert!(is_release_not_found(b"release not found\n"));
810    }
811
812    #[test]
813    fn test_should_detect_not_found_with_tag() {
814        assert!(is_release_not_found(b"tag not found (404)\n"));
815    }
816
817    #[test]
818    fn test_should_not_detect_unrelated_text() {
819        assert!(!is_release_not_found(b"authentication failed\n"));
820    }
821
822    #[test]
823    fn test_should_return_false_for_empty_stderr() {
824        assert!(!is_release_not_found(b""));
825    }
826
827    #[test]
828    fn test_should_handle_invalid_json_as_text() {
829        // Invalid JSON should fall through to plain-text matching without panicking.
830        assert!(!is_release_not_found(b"{invalid json"));
831    }
832
833    #[test]
834    fn test_should_detect_json_not_found_code_case_insensitively() {
835        let stderr = br#"{"message":"not found","code":"not_found"}"#;
836        assert!(is_release_not_found(stderr));
837    }
838
839    // --- with_runner constructor ---
840
841    #[test]
842    fn test_should_create_provider_with_custom_runner() {
843        let runner = MockCommandRunner::success("");
844        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
845        assert_eq!(provider.repo, "owner/repo");
846    }
847
848    // --- Success-path tests ---
849
850    fn valid_release_json() -> &'static str {
851        r#"{
852            "id": 1,
853            "tagName": "v1.0.0",
854            "name": "Version 1.0.0",
855            "body": "Release notes",
856            "draft": false,
857            "prerelease": false,
858            "author": {"login": "octocat", "id": "1"},
859            "createdAt": "2026-01-01T00:00:00Z",
860            "publishedAt": "2026-01-01T00:00:00Z",
861            "url": "https://github.com/owner/repo/releases/tag/v1.0.0"
862        }"#
863    }
864
865    #[tokio::test]
866    async fn test_should_view_release_successfully() {
867        let runner = MockCommandRunner::success(valid_release_json());
868        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
869
870        let release = provider.view("v1.0.0").await.expect("view should succeed");
871        assert_eq!(release.tag_name, "v1.0.0");
872        assert_eq!(release.name.as_deref(), Some("Version 1.0.0"));
873        assert_eq!(release.id, 1);
874    }
875
876    #[tokio::test]
877    async fn test_should_list_releases_successfully() {
878        let json = format!("[{}]", valid_release_json());
879        let runner = MockCommandRunner::success(&json);
880        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
881
882        let paged = provider.list(None).await.expect("list should succeed");
883        assert_eq!(paged.items.len(), 1);
884        assert_eq!(paged.items[0].tag_name, "v1.0.0");
885    }
886
887    #[tokio::test]
888    async fn test_should_list_empty_releases() {
889        let runner = MockCommandRunner::success("[]");
890        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
891
892        let paged = provider.list(None).await.expect("list should succeed");
893        assert!(paged.items.is_empty());
894    }
895
896    #[tokio::test]
897    async fn test_should_request_default_cap_plus_one_for_release_list() {
898        let runner = MockCommandRunner::success("[]");
899        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner.clone());
900        provider.list(None).await.expect("list should succeed");
901        let recorded = &runner.recorded_calls()[0].1;
902        assert!(
903            recorded
904                .windows(2)
905                .any(|w| w[0] == "--limit" && w[1] == "1001"),
906            "release list 此前完全没有 limit 概念,实际 argv: {recorded:?}"
907        );
908    }
909
910    #[tokio::test]
911    async fn test_should_honour_user_release_limit() {
912        let runner = MockCommandRunner::success("[]");
913        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner.clone());
914        provider.list(Some(10)).await.expect("list should succeed");
915        let recorded = &runner.recorded_calls()[0].1;
916        assert!(
917            recorded
918                .windows(2)
919                .any(|w| w[0] == "--limit" && w[1] == "11"),
920            "用户 limit 必须真正抵达底层 CLI,实际 argv: {recorded:?}"
921        );
922    }
923
924    #[tokio::test]
925    async fn test_should_produce_complete_argv_for_release_list_with_default_limit() {
926        let runner = MockCommandRunner::success("[]");
927        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner.clone());
928        provider.list(None).await.expect("list should succeed");
929        let recorded = &runner.recorded_calls()[0];
930        assert_eq!(recorded.0, "gh");
931        assert_eq!(
932            recorded.1,
933            vec![
934                "release",
935                "list",
936                "--repo",
937                "owner/repo",
938                "--json",
939                RELEASE_LIST_FIELDS,
940                "--limit",
941                "1001",
942            ]
943        );
944    }
945
946    #[tokio::test]
947    async fn test_should_create_release_successfully() {
948        // create runs `gh release create` then fetches via `view`.
949        let runner =
950            SequencedMockCommandRunner::from_results(&[(true, ""), (true, valid_release_json())]);
951        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
952
953        let release = provider
954            .create(sample_create_args())
955            .await
956            .expect("create should succeed");
957        assert_eq!(release.tag_name, "v1.0.0");
958    }
959
960    #[tokio::test]
961    async fn test_should_edit_release_successfully() {
962        // edit runs `gh release edit` then fetches via `view`.
963        let runner =
964            SequencedMockCommandRunner::from_results(&[(true, ""), (true, valid_release_json())]);
965        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
966
967        let release = provider
968            .edit("v1.0.0", sample_create_args())
969            .await
970            .expect("edit should succeed");
971        assert_eq!(release.tag_name, "v1.0.0");
972    }
973
974    #[tokio::test]
975    async fn test_should_delete_release_successfully() {
976        let runner = MockCommandRunner::success("");
977        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
978
979        assert!(provider.delete("v1.0.0").await.is_ok());
980    }
981
982    #[tokio::test]
983    async fn test_should_upload_asset_successfully() {
984        let runner = MockCommandRunner::success("");
985        let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
986
987        assert!(
988            provider
989                .upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
990                .await
991                .is_ok()
992        );
993    }
994}