use async_trait::async_trait;
use chrono::{DateTime, Utc};
use gitflow_core::{
CoreError, Result,
release::{CreateReleaseArgs, ReleaseData, ReleaseProvider},
types::UserSummary,
};
use serde::Deserialize;
use tracing::debug;
use crate::{
error::parse_glab_error,
runner::{CommandRunner, RealCommandRunner},
};
#[derive(Debug, Clone)]
pub struct GitLabReleaseProvider<R: CommandRunner = RealCommandRunner> {
repo: String,
runner: R,
}
impl GitLabReleaseProvider<RealCommandRunner> {
#[must_use]
pub fn new(repo: impl Into<String>) -> Self {
Self {
repo: repo.into(),
runner: RealCommandRunner,
}
}
}
impl<R: CommandRunner> GitLabReleaseProvider<R> {
#[must_use]
pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
Self {
repo: repo.into(),
runner,
}
}
}
#[derive(Debug, Clone, Deserialize)]
struct ApiUser {
username: String,
#[serde(default)]
id: u64,
}
impl From<&ApiUser> for UserSummary {
fn from(u: &ApiUser) -> Self {
Self {
login: u.username.clone(),
id: u.id.to_string(),
}
}
}
#[derive(Debug, Clone, Deserialize)]
struct ReleaseApiResponse {
#[serde(default)]
tag_name: String,
#[serde(default)]
name: Option<String>,
#[serde(default)]
description: Option<String>,
#[serde(default)]
draft: bool,
#[serde(default)]
prerelease: bool,
#[serde(default)]
author: Option<ApiUser>,
#[serde(default)]
created_at: Option<DateTime<Utc>>,
#[serde(default)]
released_at: Option<DateTime<Utc>>,
#[serde(default)]
url: Option<String>,
#[serde(default)]
id: Option<u64>,
}
impl From<ReleaseApiResponse> for ReleaseData {
fn from(api: ReleaseApiResponse) -> Self {
let now = Utc::now();
let author = api.author.as_ref().map(UserSummary::from);
Self {
id: api.id.unwrap_or(0),
tag_name: api.tag_name,
name: api.name,
body: api.description,
draft: api.draft,
prerelease: api.prerelease,
author,
created_at: api.created_at.unwrap_or(now),
published_at: api.released_at,
url: api.url.unwrap_or_default(),
}
}
}
#[async_trait]
impl<R: CommandRunner + 'static> ReleaseProvider for GitLabReleaseProvider<R> {
async fn create(&self, args: CreateReleaseArgs) -> Result<ReleaseData> {
let mut cmd_args: Vec<&str> = vec![
"release",
"create",
&args.tag_name,
"--repo",
&self.repo,
"--output",
"json",
];
if let Some(ref name) = args.name {
cmd_args.push("--name");
cmd_args.push(name);
}
if let Some(ref 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(ref commitish) = args.target_commitish {
cmd_args.push("--ref");
cmd_args.push(commitish);
}
debug!(
repo = %self.repo,
tag = %args.tag_name,
"spawning `glab release create`"
);
let output = self
.runner
.run("glab", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
let api_response: ReleaseApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api_response.into())
}
async fn list(&self) -> Result<Vec<ReleaseData>> {
debug!(repo = %self.repo, "spawning `glab release list`");
let output = self
.runner
.run(
"glab",
&["release", "list", "--repo", &self.repo, "--output", "json"],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
let api_responses: Vec<ReleaseApiResponse> =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api_responses.into_iter().map(ReleaseData::from).collect())
}
async fn view(&self, tag_name: &str) -> Result<ReleaseData> {
debug!(repo = %self.repo, tag = %tag_name, "spawning `glab release view`");
let output = self
.runner
.run(
"glab",
&[
"release", "view", tag_name, "--repo", &self.repo, "--output", "json",
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
let api_response: ReleaseApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api_response.into())
}
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, "--output", "json",
];
if let Some(ref name) = args.name {
cmd_args.push("--name");
cmd_args.push(name);
}
if let Some(ref 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(ref commitish) = args.target_commitish {
cmd_args.push("--ref");
cmd_args.push(commitish);
}
debug!(
repo = %self.repo,
tag = %tag_name,
"spawning `glab release edit`"
);
let output = self
.runner
.run("glab", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
let api_response: ReleaseApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api_response.into())
}
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 `glab release upload`"
);
let output = self
.runner
.run(
"glab",
&[
"release", "upload", tag_name, file_path, "--repo", &self.repo,
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
Ok(())
}
#[allow(
clippy::disallowed_methods,
reason = "Path parent extraction required for download"
)]
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 `glab 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_string_lossy();
let output = self
.runner
.run(
"glab",
&[
"release",
"download",
tag_name,
"--repo",
&self.repo,
"--pattern",
asset_name,
"--dir",
&parent_str,
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_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 `glab release delete`");
let output = self
.runner
.run(
"glab",
&["release", "delete", tag_name, "--repo", &self.repo, "--yes"],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::runner::MockCommandRunner;
#[test]
fn test_should_construct_gitlab_release_provider() {
let provider = GitLabReleaseProvider::new("gitlab-org/gitlab");
assert_eq!(provider.repo, "gitlab-org/gitlab");
}
#[test]
fn test_should_construct_gitlab_release_provider_from_string() {
let repo = String::from("gitlab-org/gitlab");
let provider = GitLabReleaseProvider::new(repo);
assert_eq!(provider.repo, "gitlab-org/gitlab");
}
#[test]
fn test_should_deserialize_release_api_response() {
let json = br#"{
"id": 1001,
"tag_name": "v1.0.0",
"name": "Version 1.0.0",
"description": "Initial stable release",
"draft": false,
"prerelease": false,
"author": {"username": "admin", "id": 1},
"created_at": "2026-01-01T00:00:00Z",
"released_at": "2026-01-15T12:00:00Z",
"url": "https://gitlab.com/gitlab-org/gitlab/-/releases/v1.0.0"
}"#;
let api: ReleaseApiResponse =
serde_json::from_slice(json).expect("valid ReleaseApiResponse");
let release: ReleaseData = api.into();
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().expect("author present").login,
"admin"
);
assert_eq!(
release.url,
"https://gitlab.com/gitlab-org/gitlab/-/releases/v1.0.0"
);
}
#[test]
fn test_should_deserialize_draft_release() {
let json = br#"{
"tag_name": "v0.1.0-draft",
"name": null,
"description": null,
"draft": true,
"prerelease": true,
"author": {"username": "dev", "id": 99},
"created_at": "2026-03-01T00:00:00Z",
"released_at": null,
"url": null
}"#;
let api: ReleaseApiResponse =
serde_json::from_slice(json).expect("valid ReleaseApiResponse");
let release: ReleaseData = api.into();
assert!(release.draft);
assert!(release.prerelease);
assert!(release.name.is_none());
assert!(release.published_at.is_none());
}
#[test]
fn test_should_deserialize_empty_release_list() {
let json = b"[]";
let list: Vec<ReleaseApiResponse> = serde_json::from_slice(json).expect("valid empty list");
assert!(list.is_empty());
}
#[test]
fn test_should_debug_format_provider() {
let provider = GitLabReleaseProvider::new("gitlab-org/gitlab");
let debug = format!("{provider:?}");
assert!(debug.contains("GitLabReleaseProvider"));
assert!(debug.contains("gitlab-org/gitlab"));
}
#[test]
fn test_should_clone_gitlab_release_provider() {
let original = GitLabReleaseProvider::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_glab_fails_for_create() {
let runner = MockCommandRunner::failure(r#"{"message": "Tag exists"}"#, 256);
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
let result = provider.create(sample_create_args()).await;
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("not valid json");
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
let result = provider.create(sample_create_args()).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_list() {
let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
let result = provider.list().await;
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");
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
let result = provider.list().await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_view() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
let result = provider.view("v1.0.0").await;
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");
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
let result = provider.view("v1.0.0").await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_edit() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
let result = provider.edit("v1.0.0", sample_create_args()).await;
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");
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
let result = provider.edit("v1.0.0", sample_create_args()).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_delete() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
let result = provider.delete("v1.0.0").await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_upload_asset() {
let runner = MockCommandRunner::failure(r#"{"message": "Upload failed"}"#, 256);
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
let result = provider
.upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
.await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_download_asset() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
let result = provider
.download_asset("v1.0.0", "asset.tar.gz", "/tmp/asset.tar.gz")
.await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
}