1use 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
19const RELEASE_LIST_FIELDS: &str = "tagName,name,isDraft,isPrerelease,createdAt,publishedAt";
21
22const RELEASE_VIEW_FIELDS: &str =
24 "databaseId,tagName,name,body,isDraft,isPrerelease,author,createdAt,publishedAt,url";
25
26#[derive(Debug, Clone)]
42pub struct GitHubReleaseProvider<R: CommandRunner = RealCommandRunner> {
43 repo: String,
45 runner: R,
47}
48
49impl GitHubReleaseProvider<RealCommandRunner> {
50 #[must_use]
54 pub fn new(repo: impl Into<String>) -> Self {
55 Self {
56 repo: repo.into(),
57 runner: RealCommandRunner,
58 }
59 }
60
61 #[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 #[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 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 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 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 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 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#[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 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 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 #[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 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 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 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 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 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 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 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 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 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 #[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 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 #[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 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 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 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}