Skip to main content

gitflow_gitcode/
release.rs

1//! GitCode Release 提供者实现。
2//!
3//! 通过 `gitcode` CLI 实现 [`ReleaseProvider`] trait,支持 Release 的创建、列表、
4//! 查看、编辑、资源上传/下载及删除。
5//! 所有方法通过 `tokio::process::Command` 调用 `gc`,捕获 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_gitcode_error,
16    runner::{CommandRunner, RealCommandRunner},
17};
18
19/// `gc release` 请求的 JSON 字段列表。
20const RELEASE_FIELDS: &str =
21    "id,tagName,name,body,isDraft,isPrerelease,author,createdAt,publishedAt,url";
22
23/// GitCode Release 提供者,通过 `gitcode` CLI 操作。
24///
25/// 该结构体通过调用 `gitcode` CLI 实现 [`ReleaseProvider`] trait 的所有方法,
26/// 使上层命令能够以统一的方式操作 GitCode Release。
27///
28/// 命令执行通过 [`CommandRunner`] 抽象,生产环境默认使用
29/// [`RealCommandRunner`],测试可注入自定义 runner 以模拟成功或失败场景。
30///
31/// # Examples
32///
33/// ```no_run
34/// use gitflow_gitcode::GitCodeReleaseProvider;
35///
36/// let provider = GitCodeReleaseProvider::new("octocat/hello-world");
37/// ```
38#[derive(Debug, Clone)]
39pub struct GitCodeReleaseProvider<R: CommandRunner = RealCommandRunner> {
40    /// GitCode `owner/repo`,如 `"byx-darwin/gitflow-cli"`。
41    repo: String,
42    /// 用于执行 `gitcode` CLI 命令的 runner。
43    runner: R,
44}
45
46impl GitCodeReleaseProvider<RealCommandRunner> {
47    /// 创建新的 GitCode Release 提供者。
48    ///
49    /// `repo` 格式为 `owner/repo`。
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> GitCodeReleaseProvider<R> {
60    /// 使用自定义 [`CommandRunner`] 创建提供者。
61    ///
62    /// 主要用于测试,可注入模拟 runner 以控制 `gitcode` CLI 的输出。
63    /// `repo` 格式为 `owner/repo`。
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#[async_trait]
74impl<R: CommandRunner + 'static> ReleaseProvider for GitCodeReleaseProvider<R> {
75    async fn create(&self, args: CreateReleaseArgs) -> Result<ReleaseData> {
76        let binary = crate::gitcode_binary();
77        let mut cmd_args: Vec<&str> = vec![
78            "release",
79            "create",
80            &args.tag_name,
81            "-R",
82            &self.repo,
83            "--json",
84            RELEASE_FIELDS,
85        ];
86
87        if let Some(ref name) = args.name {
88            cmd_args.push("--title");
89            cmd_args.push(name);
90        }
91
92        if let Some(ref body) = args.body {
93            cmd_args.push("--notes");
94            cmd_args.push(body);
95        }
96
97        if args.draft {
98            cmd_args.push("--draft");
99        }
100
101        if args.prerelease {
102            cmd_args.push("--prerelease");
103        }
104
105        if let Some(ref commitish) = args.target_commitish {
106            cmd_args.push("--target");
107            cmd_args.push(commitish);
108        }
109
110        debug!(
111            repo = %self.repo,
112            tag = %args.tag_name,
113            "spawning `gc release create`"
114        );
115
116        let output = self
117            .runner
118            .run(&binary, &cmd_args)
119            .await
120            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
121
122        if !output.status.success() {
123            return Err(parse_gitcode_error(&output.stderr).into());
124        }
125
126        // If JSON parsing fails, the release was still created successfully
127        // Try to fetch it via view
128        match serde_json::from_slice::<ReleaseData>(&output.stdout) {
129            Ok(release) => Ok(release),
130            Err(_) => self.view(&args.tag_name).await,
131        }
132    }
133
134    async fn list(&self) -> Result<Vec<ReleaseData>> {
135        let binary = crate::gitcode_binary();
136        debug!(repo = %self.repo, "spawning `gc release list`");
137
138        let output = self
139            .runner
140            .run(
141                &binary,
142                &[
143                    "release",
144                    "list",
145                    "-R",
146                    &self.repo,
147                    "--json",
148                    RELEASE_FIELDS,
149                ],
150            )
151            .await
152            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
153
154        if !output.status.success() {
155            return Err(parse_gitcode_error(&output.stderr).into());
156        }
157
158        let releases: Vec<ReleaseData> =
159            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
160
161        Ok(releases)
162    }
163
164    async fn view(&self, tag_name: &str) -> Result<ReleaseData> {
165        let binary = crate::gitcode_binary();
166        debug!(repo = %self.repo, tag = %tag_name, "spawning `gc release view`");
167
168        let output = self
169            .runner
170            .run(
171                &binary,
172                &["release", "view", tag_name, "-R", &self.repo, "--json"],
173            )
174            .await
175            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
176
177        if !output.status.success() {
178            return Err(parse_gitcode_error(&output.stderr).into());
179        }
180
181        let release: ReleaseData =
182            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
183
184        Ok(release)
185    }
186
187    async fn edit(&self, tag_name: &str, args: CreateReleaseArgs) -> Result<ReleaseData> {
188        let binary = crate::gitcode_binary();
189        let mut cmd_args: Vec<&str> = vec![
190            "release",
191            "edit",
192            tag_name,
193            "-R",
194            &self.repo,
195            "--json",
196            RELEASE_FIELDS,
197        ];
198
199        if let Some(ref name) = args.name {
200            cmd_args.push("--title");
201            cmd_args.push(name);
202        }
203
204        if let Some(ref body) = args.body {
205            cmd_args.push("--notes");
206            cmd_args.push(body);
207        }
208
209        if args.draft {
210            cmd_args.push("--draft");
211        }
212
213        if args.prerelease {
214            cmd_args.push("--prerelease");
215        }
216
217        debug!(
218            repo = %self.repo,
219            tag = %tag_name,
220            "spawning `gc release edit`"
221        );
222
223        let output = self
224            .runner
225            .run(&binary, &cmd_args)
226            .await
227            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
228
229        if !output.status.success() {
230            return Err(parse_gitcode_error(&output.stderr).into());
231        }
232
233        // If JSON parsing fails, try to fetch the edited release
234        match serde_json::from_slice::<ReleaseData>(&output.stdout) {
235            Ok(release) => Ok(release),
236            Err(_) => self.view(tag_name).await,
237        }
238    }
239
240    async fn delete(&self, tag_name: &str) -> Result<()> {
241        let binary = crate::gitcode_binary();
242        debug!(repo = %self.repo, tag = %tag_name, "spawning `gc release delete`");
243
244        let output = self
245            .runner
246            .run(&binary, &["release", "delete", tag_name, "-R", &self.repo])
247            .await
248            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
249
250        if !output.status.success() {
251            return Err(parse_gitcode_error(&output.stderr).into());
252        }
253
254        Ok(())
255    }
256
257    async fn upload_asset(&self, tag_name: &str, file_path: &str, _asset_name: &str) -> Result<()> {
258        let binary = crate::gitcode_binary();
259        debug!(
260            repo = %self.repo,
261            tag = %tag_name,
262            file = %file_path,
263            "spawning `gc release upload`"
264        );
265
266        let output = self
267            .runner
268            .run(
269                &binary,
270                &["release", "upload", tag_name, file_path, "-R", &self.repo],
271            )
272            .await
273            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
274
275        if !output.status.success() {
276            return Err(parse_gitcode_error(&output.stderr).into());
277        }
278
279        Ok(())
280    }
281
282    async fn download_asset(
283        &self,
284        tag_name: &str,
285        asset_name: &str,
286        output_path: &str,
287    ) -> Result<()> {
288        let binary = crate::gitcode_binary();
289        debug!(
290            repo = %self.repo,
291            tag = %tag_name,
292            asset = %asset_name,
293            output = %output_path,
294            "spawning `gc release download`"
295        );
296
297        let output = self
298            .runner
299            .run(
300                &binary,
301                &[
302                    "release",
303                    "download",
304                    tag_name,
305                    "-R",
306                    &self.repo,
307                    "--asset",
308                    asset_name,
309                    "--output",
310                    output_path,
311                ],
312            )
313            .await
314            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
315
316        if !output.status.success() {
317            return Err(parse_gitcode_error(&output.stderr).into());
318        }
319
320        Ok(())
321    }
322}
323
324#[cfg(test)]
325mod tests {
326    use super::*;
327    use crate::runner::MockCommandRunner;
328
329    #[test]
330    fn test_should_construct_gitcode_release_provider() {
331        let provider = GitCodeReleaseProvider::new("octocat/hello-world");
332        assert_eq!(provider.repo, "octocat/hello-world");
333    }
334
335    #[test]
336    fn test_should_construct_gitcode_release_provider_from_string() {
337        let repo = String::from("octocat/hello-world");
338        let provider = GitCodeReleaseProvider::new(repo);
339        assert_eq!(provider.repo, "octocat/hello-world");
340    }
341
342    #[test]
343    fn test_should_debug_format_provider() {
344        let provider = GitCodeReleaseProvider::new("octocat/hello-world");
345        let debug = format!("{provider:?}");
346        assert!(debug.contains("GitCodeReleaseProvider"));
347        assert!(debug.contains("octocat/hello-world"));
348    }
349
350    #[test]
351    fn test_should_clone_gitcode_release_provider() {
352        let original = GitCodeReleaseProvider::new("owner/repo");
353        let cloned = original.clone();
354        assert_eq!(original.repo, cloned.repo);
355    }
356
357    // --- Failure-path tests using an injected MockCommandRunner ---
358
359    fn sample_release_args() -> CreateReleaseArgs {
360        CreateReleaseArgs {
361            tag_name: "v1.0.0".to_string(),
362            name: Some("Release 1.0.0".to_string()),
363            body: Some("First stable release".to_string()),
364            draft: false,
365            prerelease: false,
366            target_commitish: None,
367        }
368    }
369
370    #[tokio::test]
371    async fn test_should_return_platform_error_when_gc_fails_for_create() {
372        let runner = MockCommandRunner::failure("tag already exists", 256);
373        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
374
375        let result = provider.create(sample_release_args()).await;
376
377        assert!(matches!(
378            result.unwrap_err(),
379            gitflow_core::CoreError::Cli(_)
380        ));
381    }
382
383    #[tokio::test]
384    async fn test_should_return_serialization_error_on_invalid_json_for_create() {
385        // create parses ReleaseData; on failure it falls back to view, which
386        // receives the same non-JSON stdout and fails to deserialize.
387        let runner = MockCommandRunner::success("not valid json");
388        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
389
390        let result = provider.create(sample_release_args()).await;
391
392        assert!(matches!(
393            result.unwrap_err(),
394            gitflow_core::CoreError::Serialization(_)
395        ));
396    }
397
398    #[tokio::test]
399    async fn test_should_return_platform_error_when_gc_fails_for_list() {
400        let runner = MockCommandRunner::failure("forbidden", 256);
401        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
402
403        let result = provider.list().await;
404
405        assert!(matches!(
406            result.unwrap_err(),
407            gitflow_core::CoreError::Cli(_)
408        ));
409    }
410
411    #[tokio::test]
412    async fn test_should_return_serialization_error_on_invalid_json_for_list() {
413        let runner = MockCommandRunner::success("invalid");
414        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
415
416        let result = provider.list().await;
417
418        assert!(matches!(
419            result.unwrap_err(),
420            gitflow_core::CoreError::Serialization(_)
421        ));
422    }
423
424    #[tokio::test]
425    async fn test_should_return_platform_error_when_gc_fails_for_view() {
426        let runner = MockCommandRunner::failure("release not found", 256);
427        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
428
429        let result = provider.view("v1.0.0").await;
430
431        assert!(matches!(
432            result.unwrap_err(),
433            gitflow_core::CoreError::Cli(_)
434        ));
435    }
436
437    #[tokio::test]
438    async fn test_should_return_serialization_error_on_invalid_json_for_view() {
439        let runner = MockCommandRunner::success("not valid json");
440        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
441
442        let result = provider.view("v1.0.0").await;
443
444        assert!(matches!(
445            result.unwrap_err(),
446            gitflow_core::CoreError::Serialization(_)
447        ));
448    }
449
450    #[tokio::test]
451    async fn test_should_return_platform_error_when_gc_fails_for_edit() {
452        let runner = MockCommandRunner::failure("release not found", 256);
453        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
454
455        let result = provider.edit("v1.0.0", sample_release_args()).await;
456
457        assert!(matches!(
458            result.unwrap_err(),
459            gitflow_core::CoreError::Cli(_)
460        ));
461    }
462
463    #[tokio::test]
464    async fn test_should_return_serialization_error_on_invalid_json_for_edit() {
465        // edit parses ReleaseData; on failure it falls back to view, which
466        // receives the same non-JSON stdout and fails to deserialize.
467        let runner = MockCommandRunner::success("not valid json");
468        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
469
470        let result = provider.edit("v1.0.0", sample_release_args()).await;
471
472        assert!(matches!(
473            result.unwrap_err(),
474            gitflow_core::CoreError::Serialization(_)
475        ));
476    }
477
478    #[tokio::test]
479    async fn test_should_return_platform_error_when_gc_fails_for_delete() {
480        let runner = MockCommandRunner::failure("release not found", 256);
481        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
482
483        let result = provider.delete("v1.0.0").await;
484
485        assert!(matches!(
486            result.unwrap_err(),
487            gitflow_core::CoreError::Cli(_)
488        ));
489    }
490
491    #[tokio::test]
492    async fn test_should_return_platform_error_when_gc_fails_for_upload_asset() {
493        let runner = MockCommandRunner::failure("upload failed", 256);
494        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
495
496        let result = provider
497            .upload_asset("v1.0.0", "/tmp/artifact.tar.gz", "artifact.tar.gz")
498            .await;
499
500        assert!(matches!(
501            result.unwrap_err(),
502            gitflow_core::CoreError::Cli(_)
503        ));
504    }
505
506    #[tokio::test]
507    async fn test_should_return_platform_error_when_gc_fails_for_download_asset() {
508        let runner = MockCommandRunner::failure("asset not found", 256);
509        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
510
511        let result = provider
512            .download_asset("v1.0.0", "artifact.tar.gz", "/tmp/out.tar.gz")
513            .await;
514
515        assert!(matches!(
516            result.unwrap_err(),
517            gitflow_core::CoreError::Cli(_)
518        ));
519    }
520
521    // --- Deserialization tests ---
522
523    #[test]
524    fn test_should_deserialize_release_data_from_gitcode_output() {
525        let json = br#"{
526            "id": 100,
527            "tagName": "v2.0.0",
528            "name": "GitCode Release",
529            "body": "Changelog here",
530            "draft": false,
531            "prerelease": false,
532            "author": {"login": "dev", "id": "42"},
533            "createdAt": "2026-02-01T00:00:00Z",
534            "publishedAt": "2026-02-01T12:00:00Z",
535            "url": "https://gitcode.com/owner/repo/releases/tag/v2.0.0"
536        }"#;
537
538        let release: ReleaseData = serde_json::from_slice(json).expect("valid ReleaseData JSON");
539        assert_eq!(release.id, 100);
540        assert_eq!(release.tag_name, "v2.0.0");
541        assert_eq!(release.name.as_deref(), Some("GitCode Release"));
542        assert_eq!(release.body.as_deref(), Some("Changelog here"));
543        assert!(!release.draft);
544        assert!(!release.prerelease);
545        assert_eq!(release.author.as_ref().expect("author").login, "dev");
546        assert_eq!(release.author.as_ref().expect("author").id, "42");
547    }
548
549    #[test]
550    fn test_should_deserialize_empty_release_list_from_gitcode_output() {
551        let json = b"[]";
552        let releases: Vec<ReleaseData> = serde_json::from_slice(json).expect("valid empty list");
553        assert!(releases.is_empty());
554    }
555
556    #[test]
557    fn test_should_deserialize_draft_release_from_gitcode_output() {
558        let json = br#"{
559            "id": 7,
560            "tagName": "v0.1.0-rc1",
561            "name": null,
562            "body": null,
563            "draft": true,
564            "prerelease": true,
565            "author": {"login": "bot", "id": "0"},
566            "createdAt": "2026-03-01T00:00:00Z",
567            "publishedAt": null,
568            "url": "https://gitcode.com/owner/repo/releases/tag/v0.1.0-rc1"
569        }"#;
570
571        let release: ReleaseData = serde_json::from_slice(json).expect("valid draft ReleaseData");
572        assert!(release.draft);
573        assert!(release.prerelease);
574        assert!(release.name.is_none());
575        assert!(release.body.is_none());
576        assert!(release.published_at.is_none());
577    }
578
579    // --- with_runner constructor ---
580
581    #[test]
582    fn test_should_create_provider_with_custom_runner() {
583        let runner = MockCommandRunner::success("");
584        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
585        assert_eq!(provider.repo, "owner/repo");
586    }
587
588    // --- Success-path tests ---
589
590    fn valid_release_json() -> &'static str {
591        r#"{
592            "id": 1,
593            "tagName": "v1.0.0",
594            "name": "Release 1.0.0",
595            "body": "First stable release",
596            "draft": false,
597            "prerelease": false,
598            "author": {"login": "dev", "id": "1"},
599            "createdAt": "2026-01-01T00:00:00Z",
600            "publishedAt": "2026-01-01T00:00:00Z",
601            "url": "https://gitcode.com/owner/repo/releases/tag/v1.0.0"
602        }"#
603    }
604
605    #[tokio::test]
606    async fn test_should_view_release_successfully() {
607        let runner = MockCommandRunner::success(valid_release_json());
608        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
609
610        let release = provider.view("v1.0.0").await.expect("view should succeed");
611        assert_eq!(release.tag_name, "v1.0.0");
612        assert_eq!(release.name.as_deref(), Some("Release 1.0.0"));
613        assert_eq!(release.id, 1);
614    }
615
616    #[tokio::test]
617    async fn test_should_list_releases_successfully() {
618        let json = format!("[{}]", valid_release_json());
619        let runner = MockCommandRunner::success(&json);
620        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
621
622        let releases = provider.list().await.expect("list should succeed");
623        assert_eq!(releases.len(), 1);
624        assert_eq!(releases[0].tag_name, "v1.0.0");
625    }
626
627    #[tokio::test]
628    async fn test_should_create_release_successfully() {
629        let runner = MockCommandRunner::success(valid_release_json());
630        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
631
632        let release = provider
633            .create(sample_release_args())
634            .await
635            .expect("create should succeed");
636        assert_eq!(release.tag_name, "v1.0.0");
637    }
638
639    #[tokio::test]
640    async fn test_should_edit_release_successfully() {
641        let runner = MockCommandRunner::success(valid_release_json());
642        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
643
644        let release = provider
645            .edit("v1.0.0", sample_release_args())
646            .await
647            .expect("edit should succeed");
648        assert_eq!(release.tag_name, "v1.0.0");
649    }
650
651    #[tokio::test]
652    async fn test_should_delete_release_successfully() {
653        let runner = MockCommandRunner::success("");
654        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
655
656        assert!(provider.delete("v1.0.0").await.is_ok());
657    }
658
659    #[tokio::test]
660    async fn test_should_upload_asset_successfully() {
661        let runner = MockCommandRunner::success("");
662        let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
663
664        assert!(
665            provider
666                .upload_asset("v1.0.0", "/tmp/artifact.tar.gz", "artifact.tar.gz")
667                .await
668                .is_ok()
669        );
670    }
671}