use async_trait::async_trait;
use gitflow_core::{
CoreError, Result,
release::{CreateReleaseArgs, ReleaseData, ReleaseProvider},
};
use tracing::debug;
use crate::{
error::parse_gh_error,
runner::{CommandRunner, RealCommandRunner},
};
const RELEASE_LIST_FIELDS: &str = "tagName,name,isDraft,isPrerelease,createdAt,publishedAt";
const RELEASE_VIEW_FIELDS: &str =
"databaseId,tagName,name,body,isDraft,isPrerelease,author,createdAt,publishedAt,url";
#[derive(Debug, Clone)]
pub struct GitHubReleaseProvider<R: CommandRunner = RealCommandRunner> {
repo: String,
runner: R,
}
impl GitHubReleaseProvider<RealCommandRunner> {
#[must_use]
pub fn new(repo: impl Into<String>) -> Self {
Self {
repo: repo.into(),
runner: RealCommandRunner,
}
}
}
impl<R: CommandRunner> GitHubReleaseProvider<R> {
#[must_use]
pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
Self {
repo: repo.into(),
runner,
}
}
}
#[async_trait]
impl<R: CommandRunner + 'static> ReleaseProvider for GitHubReleaseProvider<R> {
async fn create(&self, args: CreateReleaseArgs) -> Result<ReleaseData> {
let mut cmd_args: Vec<&str> =
vec!["release", "create", &args.tag_name, "--repo", &self.repo];
if let Some(name) = &args.name {
cmd_args.push("--title");
cmd_args.push(name);
}
if let Some(body) = &args.body {
cmd_args.push("--notes");
cmd_args.push(body);
}
if args.draft {
cmd_args.push("--draft");
}
if args.prerelease {
cmd_args.push("--prerelease");
}
if let Some(commitish) = &args.target_commitish {
cmd_args.push("--target");
cmd_args.push(commitish);
}
debug!(
repo = %self.repo,
tag = %args.tag_name,
"spawning `gh release create`"
);
let output = self
.runner
.run("gh", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
self.view(&args.tag_name).await
}
async fn list(&self) -> Result<Vec<ReleaseData>> {
debug!(repo = %self.repo, "spawning `gh release list`");
let output = self
.runner
.run(
"gh",
&[
"release",
"list",
"--repo",
&self.repo,
"--json",
RELEASE_LIST_FIELDS,
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
let releases: Vec<ReleaseData> =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(releases)
}
async fn view(&self, tag_name: &str) -> Result<ReleaseData> {
debug!(repo = %self.repo, tag = %tag_name, "spawning `gh release view`");
let output = self
.runner
.run(
"gh",
&[
"release",
"view",
tag_name,
"--repo",
&self.repo,
"--json",
RELEASE_VIEW_FIELDS,
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
let release: ReleaseData =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(release)
}
async fn edit(&self, tag_name: &str, args: CreateReleaseArgs) -> Result<ReleaseData> {
let mut cmd_args: Vec<&str> = vec!["release", "edit", tag_name, "--repo", &self.repo];
if let Some(name) = &args.name {
cmd_args.push("--title");
cmd_args.push(name);
}
if let Some(body) = &args.body {
cmd_args.push("--notes");
cmd_args.push(body);
}
if args.draft {
cmd_args.push("--draft");
}
if args.prerelease {
cmd_args.push("--prerelease");
}
if let Some(commitish) = &args.target_commitish {
cmd_args.push("--target");
cmd_args.push(commitish);
}
debug!(
repo = %self.repo,
tag = %tag_name,
"spawning `gh release edit`"
);
let output = self
.runner
.run("gh", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
self.view(tag_name).await
}
async fn upload_asset(&self, tag_name: &str, file_path: &str, _asset_name: &str) -> Result<()> {
debug!(
repo = %self.repo,
tag = %tag_name,
file = %file_path,
"spawning `gh release upload`"
);
let output = self
.runner
.run(
"gh",
&[
"release", "upload", tag_name, file_path, "--repo", &self.repo,
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
Ok(())
}
#[allow(clippy::disallowed_methods)]
async fn download_asset(
&self,
tag_name: &str,
asset_name: &str,
dest_path: &str,
) -> Result<()> {
debug!(
repo = %self.repo,
tag = %tag_name,
asset = %asset_name,
dest = %dest_path,
"spawning `gh release download`"
);
let dest = std::path::PathBuf::from(dest_path);
let parent = dest.parent().unwrap_or_else(|| std::path::Path::new("."));
let parent_str = parent.to_str().ok_or_else(|| {
CoreError::Platform(format!(
"Destination directory is not valid UTF-8: {dest_path}"
))
})?;
let output = self
.runner
.run(
"gh",
&[
"release",
"download",
tag_name,
"--repo",
&self.repo,
"--pattern",
asset_name,
"--dir",
parent_str,
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
let downloaded = parent.join(asset_name);
if downloaded != dest && downloaded.exists() {
std::fs::rename(&downloaded, &dest).map_err(|e| {
CoreError::Platform(format!(
"Failed to move downloaded asset to {dest_path}: {e}"
))
})?;
}
Ok(())
}
async fn delete(&self, tag_name: &str) -> Result<()> {
debug!(repo = %self.repo, tag = %tag_name, "spawning `gh release delete`");
let output = self
.runner
.run(
"gh",
&[
"release",
"delete",
tag_name,
"--repo",
&self.repo,
"--yes",
"--cleanup-tag",
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
if is_release_not_found(&output.stderr) {
debug!(repo = %self.repo, tag = %tag_name, "release already deleted, treating as success");
return Ok(());
}
return Err(parse_gh_error(&output.stderr).into());
}
Ok(())
}
}
#[must_use]
fn is_release_not_found(stderr: &[u8]) -> bool {
let text = String::from_utf8_lossy(stderr);
let lower = text.to_ascii_lowercase();
if let Ok(json) = serde_json::from_slice::<serde_json::Value>(stderr) {
let code_matches = json
.get("code")
.and_then(serde_json::Value::as_str)
.is_some_and(|c| c == "NOT_FOUND");
let msg_matches = json
.get("message")
.and_then(serde_json::Value::as_str)
.is_some_and(|m| m.to_ascii_lowercase().contains("not found"));
if code_matches || msg_matches {
return true;
}
}
lower.contains("release not found")
|| (lower.contains("not found")
&& (lower.contains("release") || lower.contains("tag") || lower.contains("404")))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::runner::{CommandOutput, MockCommandRunner, SequencedMockCommandRunner};
#[derive(Debug, Clone)]
struct ArgsCapturingRunner {
calls: std::sync::Arc<std::sync::Mutex<Vec<Vec<String>>>>,
}
impl ArgsCapturingRunner {
fn new() -> Self {
Self {
calls: std::sync::Arc::new(std::sync::Mutex::new(Vec::new())),
}
}
}
#[async_trait::async_trait]
impl CommandRunner for ArgsCapturingRunner {
async fn run(&self, _program: &str, args: &[&str]) -> std::io::Result<CommandOutput> {
self.calls
.lock()
.expect("lock calls")
.push(args.iter().map(ToString::to_string).collect());
Ok(CommandOutput {
status: MockCommandRunner::make_exit_status(0),
stdout: Vec::new(),
stderr: Vec::new(),
})
}
async fn run_with_stdin(
&self,
program: &str,
args: &[&str],
_stdin_data: &[u8],
) -> std::io::Result<CommandOutput> {
self.run(program, args).await
}
}
#[test]
fn test_should_construct_github_release_provider() {
let provider = GitHubReleaseProvider::new("octocat/hello-world");
assert_eq!(provider.repo, "octocat/hello-world");
}
#[test]
fn test_should_construct_github_release_provider_from_string() {
let repo = String::from("octocat/hello-world");
let provider = GitHubReleaseProvider::new(repo);
assert_eq!(provider.repo, "octocat/hello-world");
}
#[test]
fn test_should_deserialize_release_data_from_gh_output() {
let gh_json = br#"{
"id": 1001,
"tagName": "v1.0.0",
"name": "Version 1.0.0",
"body": "Initial stable release",
"draft": false,
"prerelease": false,
"author": {"login": "octocat", "id": "1"},
"createdAt": "2026-01-01T00:00:00Z",
"publishedAt": "2026-01-15T12:00:00Z",
"url": "https://github.com/octocat/hello-world/releases/tag/v1.0.0"
}"#;
let release: ReleaseData = serde_json::from_slice(gh_json).expect("valid ReleaseData JSON");
assert_eq!(release.id, 1001);
assert_eq!(release.tag_name, "v1.0.0");
assert_eq!(release.name.as_deref(), Some("Version 1.0.0"));
assert_eq!(release.body.as_deref(), Some("Initial stable release"));
assert!(!release.draft);
assert!(!release.prerelease);
assert_eq!(release.author.as_ref().unwrap().login, "octocat");
assert_eq!(release.author.as_ref().unwrap().id, "1");
assert_eq!(
release.url,
"https://github.com/octocat/hello-world/releases/tag/v1.0.0"
);
}
#[test]
fn test_should_deserialize_empty_release_list_from_gh_output() {
let gh_json = b"[]";
let releases: Vec<ReleaseData> =
serde_json::from_slice(gh_json).expect("valid ReleaseData list");
assert!(releases.is_empty());
}
#[test]
fn test_should_deserialize_draft_release_from_gh_output() {
let gh_json = br#"{
"id": 5,
"tagName": "v0.1.0-draft",
"name": null,
"body": null,
"draft": true,
"prerelease": true,
"author": {"login": "dev", "id": "99"},
"createdAt": "2026-03-01T00:00:00Z",
"publishedAt": null,
"url": "https://example.com/releases/5"
}"#;
let release: ReleaseData =
serde_json::from_slice(gh_json).expect("valid draft ReleaseData");
assert!(release.draft);
assert!(release.prerelease);
assert!(release.name.is_none());
assert!(release.body.is_none());
assert!(release.published_at.is_none());
}
#[test]
fn test_should_debug_format_provider() {
let provider = GitHubReleaseProvider::new("octocat/hello-world");
let debug = format!("{provider:?}");
assert!(debug.contains("GitHubReleaseProvider"));
assert!(debug.contains("octocat/hello-world"));
}
#[test]
fn test_should_create_provider_with_different_repos() {
let r1 = GitHubReleaseProvider::new("org/repo-a");
let r2 = GitHubReleaseProvider::new("org/repo-b");
assert_eq!(r1.repo, "org/repo-a");
assert_eq!(r2.repo, "org/repo-b");
}
#[test]
fn test_should_clone_github_release_provider() {
let original = GitHubReleaseProvider::new("owner/repo");
let cloned = original.clone();
assert_eq!(original.repo, cloned.repo);
}
fn sample_create_args() -> CreateReleaseArgs {
CreateReleaseArgs {
tag_name: "v1.0.0".to_string(),
name: Some("Version 1.0.0".to_string()),
body: Some("Release notes".to_string()),
draft: false,
prerelease: false,
target_commitish: None,
}
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_create() {
let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let result = provider.create(sample_create_args()).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_create() {
let runner = MockCommandRunner::success("invalid json");
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let result = provider.create(sample_create_args()).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_list() {
let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let result = provider.list().await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_list() {
let runner = MockCommandRunner::success("invalid json");
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let result = provider.list().await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_view() {
let runner = MockCommandRunner::failure(r#"{"message": "Release not found"}"#, 256);
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let result = provider.view("v1.0.0").await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_view() {
let runner = MockCommandRunner::success("invalid json");
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let result = provider.view("v1.0.0").await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_edit() {
let runner = MockCommandRunner::failure(r#"{"message": "Release not found"}"#, 256);
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let result = provider.edit("v1.0.0", sample_create_args()).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_edit() {
let runner = MockCommandRunner::success("invalid json");
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let result = provider.edit("v1.0.0", sample_create_args()).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_delete() {
let runner = MockCommandRunner::failure(r#"{"message": "Not logged in"}"#, 256);
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let result = provider.delete("v1.0.0").await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_treat_missing_release_as_idempotent_success() {
let runner = MockCommandRunner::failure(r#"{"message": "Release not found"}"#, 256);
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let result = provider.delete("v1.0.0").await;
assert!(result.is_ok(), "expected Ok (idempotent), got {result:?}");
}
#[tokio::test]
async fn test_should_treat_text_not_found_as_idempotent_success() {
let runner = MockCommandRunner::failure("release not found\n", 256);
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let result = provider.delete("v1.0.0").await;
assert!(result.is_ok(), "expected Ok (idempotent), got {result:?}");
}
#[tokio::test]
async fn test_should_pass_cleanup_tag_flag_on_delete() {
let runner = ArgsCapturingRunner::new();
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner.clone());
provider
.delete("v1.0.0")
.await
.expect("delete must succeed");
let calls = runner.calls.lock().expect("lock calls");
let last = calls.last().expect("at least one gh call");
assert!(
last.contains(&"--cleanup-tag".to_string()),
"delete args must include --cleanup-tag, got: {last:?}"
);
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_upload_asset() {
let runner = MockCommandRunner::failure(r#"{"message": "Upload failed"}"#, 256);
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let result = provider
.upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
.await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_download_asset() {
let runner = MockCommandRunner::failure(r#"{"message": "Asset not found"}"#, 256);
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let result = provider
.download_asset("v1.0.0", "asset.tar.gz", "/tmp/download/asset.tar.gz")
.await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[test]
fn test_should_detect_json_not_found_code() {
let stderr = br#"{"message":"Not Found","code":"NOT_FOUND"}"#;
assert!(is_release_not_found(stderr));
}
#[test]
fn test_should_detect_json_not_found_message() {
let stderr = br#"{"message":"Release not found"}"#;
assert!(is_release_not_found(stderr));
}
#[test]
fn test_should_not_detect_unrelated_json_error() {
let stderr = br#"{"message":"Forbidden","code":"FORBIDDEN"}"#;
assert!(!is_release_not_found(stderr));
}
#[test]
fn test_should_detect_plain_text_release_not_found() {
assert!(is_release_not_found(b"release not found\n"));
}
#[test]
fn test_should_detect_not_found_with_tag() {
assert!(is_release_not_found(b"tag not found (404)\n"));
}
#[test]
fn test_should_not_detect_unrelated_text() {
assert!(!is_release_not_found(b"authentication failed\n"));
}
#[test]
fn test_should_return_false_for_empty_stderr() {
assert!(!is_release_not_found(b""));
}
#[test]
fn test_should_handle_invalid_json_as_text() {
assert!(!is_release_not_found(b"{invalid json"));
}
#[test]
fn test_should_detect_json_not_found_code_case_insensitively() {
let stderr = br#"{"message":"not found","code":"not_found"}"#;
assert!(is_release_not_found(stderr));
}
#[test]
fn test_should_create_provider_with_custom_runner() {
let runner = MockCommandRunner::success("");
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
assert_eq!(provider.repo, "owner/repo");
}
fn valid_release_json() -> &'static str {
r#"{
"id": 1,
"tagName": "v1.0.0",
"name": "Version 1.0.0",
"body": "Release notes",
"draft": false,
"prerelease": false,
"author": {"login": "octocat", "id": "1"},
"createdAt": "2026-01-01T00:00:00Z",
"publishedAt": "2026-01-01T00:00:00Z",
"url": "https://github.com/owner/repo/releases/tag/v1.0.0"
}"#
}
#[tokio::test]
async fn test_should_view_release_successfully() {
let runner = MockCommandRunner::success(valid_release_json());
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let release = provider.view("v1.0.0").await.expect("view should succeed");
assert_eq!(release.tag_name, "v1.0.0");
assert_eq!(release.name.as_deref(), Some("Version 1.0.0"));
assert_eq!(release.id, 1);
}
#[tokio::test]
async fn test_should_list_releases_successfully() {
let json = format!("[{}]", valid_release_json());
let runner = MockCommandRunner::success(&json);
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let releases = provider.list().await.expect("list should succeed");
assert_eq!(releases.len(), 1);
assert_eq!(releases[0].tag_name, "v1.0.0");
}
#[tokio::test]
async fn test_should_list_empty_releases() {
let runner = MockCommandRunner::success("[]");
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let releases = provider.list().await.expect("list should succeed");
assert!(releases.is_empty());
}
#[tokio::test]
async fn test_should_create_release_successfully() {
let runner =
SequencedMockCommandRunner::from_results(&[(true, ""), (true, valid_release_json())]);
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let release = provider
.create(sample_create_args())
.await
.expect("create should succeed");
assert_eq!(release.tag_name, "v1.0.0");
}
#[tokio::test]
async fn test_should_edit_release_successfully() {
let runner =
SequencedMockCommandRunner::from_results(&[(true, ""), (true, valid_release_json())]);
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
let release = provider
.edit("v1.0.0", sample_create_args())
.await
.expect("edit should succeed");
assert_eq!(release.tag_name, "v1.0.0");
}
#[tokio::test]
async fn test_should_delete_release_successfully() {
let runner = MockCommandRunner::success("");
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
assert!(provider.delete("v1.0.0").await.is_ok());
}
#[tokio::test]
async fn test_should_upload_asset_successfully() {
let runner = MockCommandRunner::success("");
let provider = GitHubReleaseProvider::with_runner("owner/repo", runner);
assert!(
provider
.upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
.await
.is_ok()
);
}
}