1use 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
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
62impl<R: CommandRunner> GitHubReleaseProvider<R> {
63 #[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 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 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 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 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 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#[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 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 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, SequencedMockCommandRunner};
390
391 #[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 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 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 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 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 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 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 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 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
749 #[test]
752 fn test_should_detect_json_not_found_code() {
753 let stderr = br#"{"message":"Not Found","code":"NOT_FOUND"}"#;
754 assert!(is_release_not_found(stderr));
755 }
756
757 #[test]
758 fn test_should_detect_json_not_found_message() {
759 let stderr = br#"{"message":"Release not found"}"#;
760 assert!(is_release_not_found(stderr));
761 }
762
763 #[test]
764 fn test_should_not_detect_unrelated_json_error() {
765 let stderr = br#"{"message":"Forbidden","code":"FORBIDDEN"}"#;
766 assert!(!is_release_not_found(stderr));
767 }
768
769 #[test]
770 fn test_should_detect_plain_text_release_not_found() {
771 assert!(is_release_not_found(b"release not found\n"));
772 }
773
774 #[test]
775 fn test_should_detect_not_found_with_tag() {
776 assert!(is_release_not_found(b"tag not found (404)\n"));
777 }
778
779 #[test]
780 fn test_should_not_detect_unrelated_text() {
781 assert!(!is_release_not_found(b"authentication failed\n"));
782 }
783
784 #[test]
785 fn test_should_return_false_for_empty_stderr() {
786 assert!(!is_release_not_found(b""));
787 }
788
789 #[test]
790 fn test_should_handle_invalid_json_as_text() {
791 assert!(!is_release_not_found(b"{invalid json"));
793 }
794
795 #[test]
796 fn test_should_detect_json_not_found_code_case_insensitively() {
797 let stderr = br#"{"message":"not found","code":"not_found"}"#;
798 assert!(is_release_not_found(stderr));
799 }
800
801 #[test]
804 fn test_should_create_provider_with_custom_runner() {
805 let runner = MockCommandRunner::success("");
806 let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
807 assert_eq!(provider.repo, "owner/repo");
808 }
809
810 fn valid_release_json() -> &'static str {
813 r#"{
814 "id": 1,
815 "tagName": "v1.0.0",
816 "name": "Version 1.0.0",
817 "body": "Release notes",
818 "draft": false,
819 "prerelease": false,
820 "author": {"login": "octocat", "id": "1"},
821 "createdAt": "2026-01-01T00:00:00Z",
822 "publishedAt": "2026-01-01T00:00:00Z",
823 "url": "https://github.com/owner/repo/releases/tag/v1.0.0"
824 }"#
825 }
826
827 #[tokio::test]
828 async fn test_should_view_release_successfully() {
829 let runner = MockCommandRunner::success(valid_release_json());
830 let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
831
832 let release = provider.view("v1.0.0").await.expect("view should succeed");
833 assert_eq!(release.tag_name, "v1.0.0");
834 assert_eq!(release.name.as_deref(), Some("Version 1.0.0"));
835 assert_eq!(release.id, 1);
836 }
837
838 #[tokio::test]
839 async fn test_should_list_releases_successfully() {
840 let json = format!("[{}]", valid_release_json());
841 let runner = MockCommandRunner::success(&json);
842 let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
843
844 let releases = provider.list().await.expect("list should succeed");
845 assert_eq!(releases.len(), 1);
846 assert_eq!(releases[0].tag_name, "v1.0.0");
847 }
848
849 #[tokio::test]
850 async fn test_should_list_empty_releases() {
851 let runner = MockCommandRunner::success("[]");
852 let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
853
854 let releases = provider.list().await.expect("list should succeed");
855 assert!(releases.is_empty());
856 }
857
858 #[tokio::test]
859 async fn test_should_create_release_successfully() {
860 let runner =
862 SequencedMockCommandRunner::from_results(&[(true, ""), (true, valid_release_json())]);
863 let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
864
865 let release = provider
866 .create(sample_create_args())
867 .await
868 .expect("create should succeed");
869 assert_eq!(release.tag_name, "v1.0.0");
870 }
871
872 #[tokio::test]
873 async fn test_should_edit_release_successfully() {
874 let runner =
876 SequencedMockCommandRunner::from_results(&[(true, ""), (true, valid_release_json())]);
877 let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
878
879 let release = provider
880 .edit("v1.0.0", sample_create_args())
881 .await
882 .expect("edit should succeed");
883 assert_eq!(release.tag_name, "v1.0.0");
884 }
885
886 #[tokio::test]
887 async fn test_should_delete_release_successfully() {
888 let runner = MockCommandRunner::success("");
889 let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
890
891 assert!(provider.delete("v1.0.0").await.is_ok());
892 }
893
894 #[tokio::test]
895 async fn test_should_upload_asset_successfully() {
896 let runner = MockCommandRunner::success("");
897 let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
898
899 assert!(
900 provider
901 .upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
902 .await
903 .is_ok()
904 );
905 }
906}