use async_trait::async_trait;
use chrono::{DateTime, Utc};
use gitflow_core::{
CoreError, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, fetch_capped,
release::{CreateReleaseArgs, ReleaseData, ReleaseProvider},
types::UserSummary,
};
use serde::Deserialize;
use tracing::debug;
use crate::{
GITLAB_MAX_PER_PAGE,
error::parse_glab_error,
runner::{CommandRunner, RealCommandRunner},
};
#[derive(Debug, Clone)]
pub struct GitLabReleaseProvider<R: CommandRunner = RealCommandRunner> {
repo: String,
repo_target: String,
runner: R,
}
impl GitLabReleaseProvider<RealCommandRunner> {
#[must_use]
pub fn new(repo: impl Into<String>) -> Self {
let repo = repo.into();
Self {
repo_target: repo.clone(),
repo,
runner: RealCommandRunner,
}
}
#[must_use]
pub fn with_session(session: &gitflow_core::Session) -> Self {
let repo = session.repo.clone();
Self {
repo_target: repo.clone(),
repo,
runner: RealCommandRunner,
}
}
#[must_use]
pub fn with_remote_url(repo: impl Into<String>, remote_url: impl Into<String>) -> Self {
Self {
repo: repo.into(),
repo_target: remote_url.into(),
runner: RealCommandRunner,
}
}
}
impl<R: CommandRunner> GitLabReleaseProvider<R> {
#[must_use]
pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
let repo = repo.into();
Self {
repo_target: repo.clone(),
repo,
runner,
}
}
#[must_use]
pub fn with_runner_and_repo_target(
repo: impl Into<String>,
repo_target: impl Into<String>,
runner: R,
) -> Self {
Self {
repo: repo.into(),
repo_target: repo_target.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 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,
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_target,
];
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 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());
}
self.view(&args.tag_name).await
}
async fn list(&self, limit: Option<u32>) -> Result<Paged<ReleaseData>> {
let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
let repo_target = &self.repo_target;
let runner = &self.runner;
let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
debug!(repo = %self.repo, cap, "spawning `glab release list`");
fetch_capped(
FetchStrategy::Paged { per_page },
cap,
|page, per_page| async move {
let page_str = page.to_string();
let per_page_str = per_page.to_string();
let output = runner
.run(
"glab",
&[
"release",
"list",
"--repo",
repo_target,
"--output",
"json",
"--per-page",
&per_page_str,
"--page",
&page_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 api_responses: Vec<ReleaseApiResponse> =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api_responses.into_iter().map(ReleaseData::from).collect())
},
)
.await
}
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_target,
"--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", "create", tag_name, "--repo", &self.repo_target];
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 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 create` (edit path)"
);
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());
}
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 `glab release upload`"
);
let output = self
.runner
.run(
"glab",
&[
"release",
"upload",
tag_name,
file_path,
"--repo",
&self.repo_target,
],
)
.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_target,
"--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_target,
"--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, SequencedMockCommandRunner};
#[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");
}
#[tokio::test]
async fn test_should_use_explicit_repo_target_for_delete() {
let runner = MockCommandRunner::success("");
let provider = GitLabReleaseProvider::with_runner_and_repo_target(
"owner/repo",
"https://192.168.230.23/iproost/proxy/api-src.git",
runner.clone(),
);
let result = provider.delete("v1.0.0").await;
assert!(result.is_ok(), "expected Ok, got {result:?}");
assert_eq!(
runner.recorded_calls()[0].1,
vec![
"release",
"delete",
"v1.0.0",
"--repo",
"https://192.168.230.23/iproost/proxy/api-src.git",
"--yes",
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[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(None).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(None).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(_)
));
}
#[test]
fn test_should_convert_api_user_to_user_summary() {
let api_user = ApiUser {
username: "admin".into(),
id: 42,
};
let summary: UserSummary = (&api_user).into();
assert_eq!(summary.login, "admin");
assert_eq!(summary.id, "42");
}
#[test]
fn test_should_convert_api_user_with_zero_id() {
let api_user = ApiUser {
username: "bot".into(),
id: 0,
};
let summary: UserSummary = (&api_user).into();
assert_eq!(summary.login, "bot");
assert_eq!(summary.id, "0");
}
#[test]
fn test_should_convert_minimal_api_response_to_release_data() {
let api = ReleaseApiResponse {
tag_name: "v1.0.0".into(),
name: None,
description: None,
draft: false,
prerelease: false,
author: None,
created_at: None,
released_at: None,
url: None,
id: None,
};
let release: ReleaseData = api.into();
assert_eq!(release.tag_name, "v1.0.0");
assert_eq!(release.id, 0); assert!(release.name.is_none());
assert!(release.body.is_none());
assert!(!release.draft);
assert!(!release.prerelease);
assert!(release.author.is_none());
assert!(release.published_at.is_none());
assert_eq!(release.url, ""); assert!(
release.created_at.is_none(),
"missing created_at must stay None, not fall back to Utc::now()"
);
}
#[test]
fn test_should_preserve_all_fields_in_full_api_response_conversion() {
let api = ReleaseApiResponse {
tag_name: "v2.0.0".into(),
name: Some("Major Release".into()),
description: Some("Breaking changes".into()),
draft: true,
prerelease: false,
author: Some(ApiUser {
username: "dev".into(),
id: 7,
}),
created_at: Some("2026-06-01T00:00:00Z".parse().expect("valid datetime")),
released_at: Some("2026-06-15T12:00:00Z".parse().expect("valid datetime")),
url: Some("https://gitlab.com/ns/proj/-/releases/v2.0.0".into()),
id: Some(200),
};
let release: ReleaseData = api.into();
assert_eq!(release.id, 200);
assert_eq!(release.tag_name, "v2.0.0");
assert_eq!(release.name.as_deref(), Some("Major Release"));
assert_eq!(release.body.as_deref(), Some("Breaking changes"));
assert!(release.draft);
assert!(!release.prerelease);
assert_eq!(release.author.as_ref().expect("author").login, "dev");
assert_eq!(release.author.as_ref().expect("author").id, "7");
assert_eq!(release.url, "https://gitlab.com/ns/proj/-/releases/v2.0.0");
}
#[test]
fn test_should_create_provider_with_custom_runner() {
let runner = MockCommandRunner::success("");
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
assert_eq!(provider.repo, "owner/repo");
}
fn valid_release_api_json() -> &'static str {
r#"{
"id": 1,
"tag_name": "v1.0.0",
"name": "Version 1.0.0",
"description": "Release notes",
"draft": false,
"prerelease": false,
"author": {"username": "admin", "id": 1},
"created_at": "2026-01-01T00:00:00Z",
"released_at": "2026-01-01T00:00:00Z",
"url": "https://gitlab.com/owner/repo/-/releases/v1.0.0"
}"#
}
#[tokio::test]
async fn test_should_view_release_successfully() {
let runner = MockCommandRunner::success(valid_release_api_json());
let provider = GitLabReleaseProvider::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_api_json());
let runner = MockCommandRunner::success(&json);
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
let paged = provider.list(None).await.expect("list should succeed");
assert_eq!(paged.items.len(), 1);
assert_eq!(paged.items[0].tag_name, "v1.0.0");
}
#[tokio::test]
async fn test_should_request_max_per_page_for_default_release_list() {
let runner = MockCommandRunner::success("[]");
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
provider.list(None).await.expect("list should succeed");
let recorded = &runner.recorded_calls()[0].1;
assert!(
recorded
.windows(2)
.any(|w| w[0] == "--per-page" && w[1] == "100"),
"实际 argv: {recorded:?}"
);
assert!(
recorded.windows(2).any(|w| w[0] == "--page" && w[1] == "1"),
"实际 argv: {recorded:?}"
);
}
#[tokio::test]
async fn test_should_produce_complete_argv_for_release_list_with_default_limit() {
let runner = MockCommandRunner::success("[]");
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
provider.list(None).await.expect("list should succeed");
let recorded = &runner.recorded_calls()[0];
assert_eq!(recorded.0, "glab");
assert_eq!(
recorded.1,
vec![
"release",
"list",
"--repo",
"owner/repo",
"--output",
"json",
"--per-page",
"100",
"--page",
"1",
]
);
}
#[tokio::test]
async fn test_should_honour_user_release_limit_via_per_page() {
let runner = MockCommandRunner::success("[]");
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
provider.list(Some(10)).await.expect("list should succeed");
let recorded = &runner.recorded_calls()[0].1;
assert!(
recorded
.windows(2)
.any(|w| w[0] == "--per-page" && w[1] == "11"),
"cap+1=11 应作为 per_page 传给 glab,实际 argv: {recorded:?}"
);
}
#[tokio::test]
async fn test_should_create_release_successfully() {
let runner = MockCommandRunner::success(valid_release_api_json());
let provider = GitLabReleaseProvider::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_create_release_without_output_json_and_refetch_via_view() {
let runner = SequencedMockCommandRunner::from_results(&[
(true, ""), (
true,
r#"{"tag_name":"v1.0.0","name":"v1.0.0","description":"notes"}"#,
),
]);
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
let args = CreateReleaseArgs {
tag_name: "v1.0.0".to_string(),
name: None,
body: Some("notes".to_string()),
draft: false,
prerelease: false,
target_commitish: None,
};
let rel = provider.create(args).await.expect("should create");
assert_eq!(rel.tag_name, "v1.0.0");
}
#[tokio::test]
async fn test_should_not_pass_draft_or_prerelease_flags_on_release_create() {
let runner = SequencedMockCommandRunner::from_results(&[
(true, ""), (
true,
r#"{"tag_name":"v1.0.0","name":"Version 1.0.0","description":"notes"}"#,
),
]);
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
let args = CreateReleaseArgs {
tag_name: "v1.0.0".to_string(),
name: Some("Version 1.0.0".to_string()),
body: Some("notes".to_string()),
draft: true,
prerelease: true,
target_commitish: Some("main".to_string()),
};
provider.create(args).await.expect("should create");
assert_eq!(
runner.recorded_calls()[0].1,
[
"release",
"create",
"v1.0.0",
"--repo",
"owner/repo",
"--name",
"Version 1.0.0",
"--notes",
"notes",
"--ref",
"main",
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[tokio::test]
async fn test_should_edit_release_without_output_json_and_refetch_via_view() {
let runner = SequencedMockCommandRunner::from_results(&[
(true, ""), (
true,
r#"{"tag_name":"v1.0.0","name":"v1.0.0","description":"notes"}"#,
),
]);
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
let args = CreateReleaseArgs {
tag_name: "v1.0.0".to_string(),
name: None,
body: Some("notes".to_string()),
draft: false,
prerelease: false,
target_commitish: None,
};
let rel = provider.edit("v1.0.0", args).await.expect("should edit");
assert_eq!(rel.tag_name, "v1.0.0");
}
#[tokio::test]
async fn test_should_edit_release_via_release_create() {
let runner = SequencedMockCommandRunner::from_results(&[
(true, ""), (
true,
r#"{"tag_name":"v1.0.0","name":"Version 1.0.0","description":"notes"}"#,
),
]);
let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
let args = CreateReleaseArgs {
tag_name: "v1.0.0".to_string(),
name: Some("Version 1.0.0".to_string()),
body: Some("notes".to_string()),
draft: true,
prerelease: true,
target_commitish: Some("main".to_string()),
};
provider.edit("v1.0.0", args).await.expect("should edit");
assert_eq!(
runner.recorded_calls()[0].1,
[
"release",
"create",
"v1.0.0",
"--repo",
"owner/repo",
"--name",
"Version 1.0.0",
"--notes",
"notes",
"--ref",
"main",
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[tokio::test]
async fn test_should_edit_release_successfully() {
let runner = MockCommandRunner::success(valid_release_api_json());
let provider = GitLabReleaseProvider::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 = GitLabReleaseProvider::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 = GitLabReleaseProvider::with_runner("owner/repo", runner);
assert!(
provider
.upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
.await
.is_ok()
);
}
}