use async_trait::async_trait;
use chrono::{DateTime, Utc};
use gitflow_core::{
CoreError, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, Session, fetch_capped,
release::{CreateReleaseArgs, ReleaseData, ReleaseProvider},
types::{UserSummary, deserialize_u64_or_string_to_string},
};
use serde::Deserialize;
use tracing::debug;
use crate::{
error::parse_gitcode_error,
runner::{CommandRunner, RealCommandRunner},
};
const RELEASE_FIELDS: &str =
"id,tagName,name,body,isDraft,isPrerelease,author,createdAt,publishedAt,url";
fn deserialize_u64_or_string_or_null_to_string<'de, D>(
deserializer: D,
) -> std::result::Result<Option<String>, D::Error>
where
D: serde::Deserializer<'de>,
{
use serde::de;
struct U64OrStringOrNullToString;
impl de::Visitor<'_> for U64OrStringOrNullToString {
type Value = Option<String>;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("a u64 integer, a string, or null")
}
fn visit_u64<E: de::Error>(self, v: u64) -> std::result::Result<Option<String>, E> {
Ok(Some(v.to_string()))
}
fn visit_str<E: de::Error>(self, v: &str) -> std::result::Result<Option<String>, E> {
Ok(Some(v.to_string()))
}
fn visit_unit<E: de::Error>(self) -> std::result::Result<Option<String>, E> {
Ok(None)
}
fn visit_none<E: de::Error>(self) -> std::result::Result<Option<String>, E> {
Ok(None)
}
}
deserializer.deserialize_any(U64OrStringOrNullToString)
}
#[derive(Debug, Clone, Deserialize)]
struct ReleaseUserApi {
#[serde(default)]
login: Option<String>,
#[serde(default, deserialize_with = "deserialize_u64_or_string_to_string")]
id: String,
}
impl From<ReleaseUserApi> for UserSummary {
fn from(u: ReleaseUserApi) -> Self {
Self {
login: u.login.unwrap_or_default(),
id: u.id,
}
}
}
#[derive(Debug, Clone, Deserialize)]
struct ReleaseApiResponse {
#[serde(
default,
deserialize_with = "deserialize_u64_or_string_or_null_to_string"
)]
id: Option<String>,
#[serde(default)]
tag_name: Option<String>,
#[serde(default)]
name: Option<String>,
#[serde(default)]
body: Option<String>,
#[serde(default)]
draft: Option<bool>,
#[serde(default)]
prerelease: Option<bool>,
#[serde(default)]
author: Option<ReleaseUserApi>,
#[serde(default)]
created_at: Option<DateTime<Utc>>,
#[serde(default)]
published_at: Option<DateTime<Utc>>,
#[serde(default)]
html_url: Option<String>,
#[serde(default)]
url: Option<String>,
}
impl From<ReleaseApiResponse> for ReleaseData {
fn from(api: ReleaseApiResponse) -> Self {
Self {
id: api.id.and_then(|s| s.parse().ok()).unwrap_or(0),
tag_name: api.tag_name.unwrap_or_default(),
name: api.name,
body: api.body,
draft: api.draft.unwrap_or_default(),
prerelease: api.prerelease.unwrap_or_default(),
author: api.author.map(UserSummary::from),
created_at: api.created_at,
published_at: api.published_at,
url: api.html_url.or(api.url).unwrap_or_default(),
}
}
}
#[derive(Debug, Clone)]
pub struct GitCodeReleaseProvider<R: CommandRunner = RealCommandRunner> {
repo: String,
runner: R,
}
impl GitCodeReleaseProvider<RealCommandRunner> {
#[must_use]
pub fn new(repo: impl Into<String>) -> Self {
Self {
repo: repo.into(),
runner: RealCommandRunner,
}
}
#[must_use]
pub fn with_session(session: &Session) -> Self {
Self {
repo: session.repo.clone(),
runner: RealCommandRunner,
}
}
}
impl<R: CommandRunner> GitCodeReleaseProvider<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 GitCodeReleaseProvider<R> {
async fn create(&self, args: CreateReleaseArgs) -> Result<ReleaseData> {
let binary = crate::gitcode_binary();
let mut cmd_args: Vec<&str> = vec![
"release",
"create",
&args.tag_name,
"-R",
&self.repo,
"--json",
RELEASE_FIELDS,
];
if let Some(ref name) = args.name {
cmd_args.push("--title");
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("--target");
cmd_args.push(commitish);
}
debug!(
repo = %self.repo,
tag = %args.tag_name,
"spawning `gc release create`"
);
let output = self
.runner
.run(&binary, &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
match serde_json::from_slice::<ReleaseData>(&output.stdout) {
Ok(release) => Ok(release),
Err(_) => self.view(&args.tag_name).await,
}
}
async fn list(&self, limit: Option<u32>) -> Result<Paged<ReleaseData>> {
let binary = crate::gitcode_binary();
let binary = &binary;
let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
let repo = &self.repo;
let runner = &self.runner;
let per_page = cap.saturating_add(1).min(crate::GITCODE_API_MAX_PER_PAGE);
debug!(repo = %self.repo, cap, per_page, "spawning `gitcode api` GET releases");
fetch_capped(
FetchStrategy::Paged { per_page },
cap,
|page, per_page| async move {
let api_path = format!("/repos/{repo}/releases?per_page={per_page}&page={page}");
let output = runner.run(binary, &["api", &api_path]).await.map_err(|e| {
CoreError::Platform(format!("Failed to spawn gitcode api: {e}"))
})?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
let releases: Vec<ReleaseApiResponse> =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(releases.into_iter().map(ReleaseData::from).collect())
},
)
.await
}
async fn view(&self, tag_name: &str) -> Result<ReleaseData> {
let binary = crate::gitcode_binary();
debug!(repo = %self.repo, tag = %tag_name, "spawning `gc release view`");
let output = self
.runner
.run(
&binary,
&["release", "view", tag_name, "-R", &self.repo, "--json"],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_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 binary = crate::gitcode_binary();
let mut cmd_args: Vec<&str> = vec![
"release",
"edit",
tag_name,
"-R",
&self.repo,
"--json",
RELEASE_FIELDS,
];
if let Some(ref name) = args.name {
cmd_args.push("--title");
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");
}
debug!(
repo = %self.repo,
tag = %tag_name,
"spawning `gc release edit`"
);
let output = self
.runner
.run(&binary, &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
match serde_json::from_slice::<ReleaseData>(&output.stdout) {
Ok(release) => Ok(release),
Err(_) => self.view(tag_name).await,
}
}
async fn delete(&self, tag_name: &str) -> Result<()> {
let binary = crate::gitcode_binary();
debug!(repo = %self.repo, tag = %tag_name, "spawning `gc release delete`");
let output = self
.runner
.run(&binary, &["release", "delete", tag_name, "-R", &self.repo])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
Ok(())
}
async fn upload_asset(&self, tag_name: &str, file_path: &str, _asset_name: &str) -> Result<()> {
let binary = crate::gitcode_binary();
debug!(
repo = %self.repo,
tag = %tag_name,
file = %file_path,
"spawning `gc release upload`"
);
let output = self
.runner
.run(
&binary,
&["release", "upload", tag_name, file_path, "-R", &self.repo],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
Ok(())
}
async fn download_asset(
&self,
tag_name: &str,
asset_name: &str,
output_path: &str,
) -> Result<()> {
let binary = crate::gitcode_binary();
debug!(
repo = %self.repo,
tag = %tag_name,
asset = %asset_name,
output = %output_path,
"spawning `gc release download`"
);
let output = self
.runner
.run(
&binary,
&[
"release",
"download",
tag_name,
"-R",
&self.repo,
"--asset",
asset_name,
"--output",
output_path,
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
if !output.status.success() {
return Err(parse_gitcode_error(&output.stderr).into());
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
#[test]
fn test_should_construct_gitcode_release_provider() {
let provider = GitCodeReleaseProvider::new("octocat/hello-world");
assert_eq!(provider.repo, "octocat/hello-world");
}
#[test]
fn test_should_construct_gitcode_release_provider_from_string() {
let repo = String::from("octocat/hello-world");
let provider = GitCodeReleaseProvider::new(repo);
assert_eq!(provider.repo, "octocat/hello-world");
}
#[test]
fn test_should_debug_format_provider() {
let provider = GitCodeReleaseProvider::new("octocat/hello-world");
let debug = format!("{provider:?}");
assert!(debug.contains("GitCodeReleaseProvider"));
assert!(debug.contains("octocat/hello-world"));
}
#[test]
fn test_should_clone_gitcode_release_provider() {
let original = GitCodeReleaseProvider::new("owner/repo");
let cloned = original.clone();
assert_eq!(original.repo, cloned.repo);
}
fn sample_release_args() -> CreateReleaseArgs {
CreateReleaseArgs {
tag_name: "v1.0.0".to_string(),
name: Some("Release 1.0.0".to_string()),
body: Some("First stable release".to_string()),
draft: false,
prerelease: false,
target_commitish: None,
}
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_create() {
let runner = MockCommandRunner::failure("tag already exists", 256);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let result = provider.create(sample_release_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 = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let result = provider.create(sample_release_args()).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_list() {
let runner = MockCommandRunner::failure("forbidden", 256);
let provider = GitCodeReleaseProvider::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 = GitCodeReleaseProvider::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_gc_fails_for_view() {
let runner = MockCommandRunner::failure("release not found", 256);
let provider = GitCodeReleaseProvider::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("not valid json");
let provider = GitCodeReleaseProvider::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_gc_fails_for_edit() {
let runner = MockCommandRunner::failure("release not found", 256);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let result = provider.edit("v1.0.0", sample_release_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("not valid json");
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let result = provider.edit("v1.0.0", sample_release_args()).await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_delete() {
let runner = MockCommandRunner::failure("release not found", 256);
let provider = GitCodeReleaseProvider::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_gc_fails_for_upload_asset() {
let runner = MockCommandRunner::failure("upload failed", 256);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let result = provider
.upload_asset("v1.0.0", "/tmp/artifact.tar.gz", "artifact.tar.gz")
.await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gc_fails_for_download_asset() {
let runner = MockCommandRunner::failure("asset not found", 256);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let result = provider
.download_asset("v1.0.0", "artifact.tar.gz", "/tmp/out.tar.gz")
.await;
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[test]
fn test_should_deserialize_release_data_from_gitcode_output() {
let json = br#"{
"id": 100,
"tagName": "v2.0.0",
"name": "GitCode Release",
"body": "Changelog here",
"draft": false,
"prerelease": false,
"author": {"login": "dev", "id": "42"},
"createdAt": "2026-02-01T00:00:00Z",
"publishedAt": "2026-02-01T12:00:00Z",
"url": "https://gitcode.com/owner/repo/releases/tag/v2.0.0"
}"#;
let release: ReleaseData = serde_json::from_slice(json).expect("valid ReleaseData JSON");
assert_eq!(release.id, 100);
assert_eq!(release.tag_name, "v2.0.0");
assert_eq!(release.name.as_deref(), Some("GitCode Release"));
assert_eq!(release.body.as_deref(), Some("Changelog here"));
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, "42");
}
#[test]
fn test_should_deserialize_empty_release_list_from_gitcode_output() {
let json = b"[]";
let releases: Vec<ReleaseData> = serde_json::from_slice(json).expect("valid empty list");
assert!(releases.is_empty());
}
#[test]
fn test_should_deserialize_draft_release_from_gitcode_output() {
let json = br#"{
"id": 7,
"tagName": "v0.1.0-rc1",
"name": null,
"body": null,
"draft": true,
"prerelease": true,
"author": {"login": "bot", "id": "0"},
"createdAt": "2026-03-01T00:00:00Z",
"publishedAt": null,
"url": "https://gitcode.com/owner/repo/releases/tag/v0.1.0-rc1"
}"#;
let release: ReleaseData = serde_json::from_slice(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_create_provider_with_custom_runner() {
let runner = MockCommandRunner::success("");
let provider = GitCodeReleaseProvider::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": "Release 1.0.0",
"body": "First stable release",
"draft": false,
"prerelease": false,
"author": {"login": "dev", "id": "1"},
"createdAt": "2026-01-01T00:00:00Z",
"publishedAt": "2026-01-01T00:00:00Z",
"url": "https://gitcode.com/owner/repo/releases/tag/v1.0.0"
}"#
}
fn valid_release_api_json() -> &'static str {
r#"{
"id": 1,
"tag_name": "v1.0.0",
"name": "Release 1.0.0",
"body": "First stable release",
"draft": false,
"prerelease": false,
"author": {"login": "dev", "id": 1},
"created_at": "2026-01-01T00:00:00Z",
"published_at": "2026-01-01T00:00:00Z",
"html_url": "https://gitcode.com/owner/repo/releases/tag/v1.0.0",
"url": "https://api.gitcode.com/repos/owner/repo/releases/1"
}"#
}
#[tokio::test]
async fn test_should_view_release_successfully() {
let runner = MockCommandRunner::success(valid_release_json());
let provider = GitCodeReleaseProvider::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("Release 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 = GitCodeReleaseProvider::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_fetch_gitcode_releases_via_api_with_pagination() {
let one = valid_release_api_json();
let page = format!("[{}]", vec![one; 100].join(","));
let runner = SequencedMockCommandRunner::from_results(&[(true, &page), (true, &page)]);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner.clone());
let paged = provider.list(Some(100)).await.expect("list should succeed");
assert_eq!(paged.items.len(), 100);
assert!(paged.truncated);
let calls = runner.recorded_calls();
assert_eq!(
calls.len(),
2,
"必须真的翻到第二页,实际调用数: {}",
calls.len()
);
assert_eq!(
calls[0].1,
vec!["api", "/repos/owner/repo/releases?per_page=100&page=1"]
);
assert_eq!(
calls[1].1,
vec!["api", "/repos/owner/repo/releases?per_page=100&page=2"]
);
}
#[tokio::test]
async fn test_should_deserialize_release_from_gitcode_api_response() {
let runner = MockCommandRunner::success(&format!("[{}]", valid_release_api_json()));
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let paged = provider.list(None).await.expect("list should succeed");
assert_eq!(paged.items.len(), 1);
let release = &paged.items[0];
assert_eq!(release.id, 1);
assert_eq!(release.tag_name, "v1.0.0");
assert_eq!(release.name.as_deref(), Some("Release 1.0.0"));
assert_eq!(release.body.as_deref(), Some("First stable release"));
assert!(!release.draft);
assert!(!release.prerelease);
let author = release.author.as_ref().expect("author");
assert_eq!(author.login, "dev");
assert_eq!(author.id, "1");
assert_eq!(
release.created_at.map(|dt| dt.to_rfc3339()),
Some("2026-01-01T00:00:00+00:00".to_string())
);
assert!(release.published_at.is_some());
assert_eq!(
release.url,
"https://gitcode.com/owner/repo/releases/tag/v1.0.0"
);
}
#[test]
fn test_should_reject_snake_case_api_payload_when_using_core_release_data() {
let no_author = r#"{
"tag_name": "v1.0.0",
"draft": false,
"prerelease": false,
"created_at": "2026-01-01T00:00:00Z"
}"#;
let err = serde_json::from_str::<ReleaseData>(no_author)
.expect_err("ReleaseData must not accept a snake_case api payload");
assert!(err.to_string().contains("tagName"), "实际错误: {err}");
let err = serde_json::from_str::<ReleaseData>(valid_release_api_json())
.expect_err("ReleaseData must not accept the full api payload either");
assert!(
err.to_string().contains("invalid type: integer"),
"实际错误: {err}"
);
}
#[tokio::test]
async fn test_should_prefer_html_url_over_api_self_link_for_release_url() {
let json = r#"[{
"tag_name": "v2.0.0",
"url": "https://api.gitcode.com/repos/owner/repo/releases/9",
"html_url": "https://gitcode.com/owner/repo/releases/tag/v2.0.0"
}]"#;
let runner = MockCommandRunner::success(json);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let paged = provider.list(None).await.expect("list should succeed");
assert_eq!(
paged.items[0].url,
"https://gitcode.com/owner/repo/releases/tag/v2.0.0"
);
}
#[tokio::test]
async fn test_should_fall_back_to_url_when_api_omits_html_url() {
let json = r#"[{
"tag_name": "v2.0.0",
"url": "https://gitcode.com/owner/repo/releases/tag/v2.0.0"
}]"#;
let runner = MockCommandRunner::success(json);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let paged = provider.list(None).await.expect("list should succeed");
assert_eq!(
paged.items[0].url,
"https://gitcode.com/owner/repo/releases/tag/v2.0.0"
);
}
#[tokio::test]
async fn test_should_degrade_predictably_for_minimal_api_release_object() {
let runner = MockCommandRunner::success(r#"[{"tag_name": "v0.0.1"}]"#);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let paged = provider.list(None).await.expect("list should succeed");
let release = &paged.items[0];
assert_eq!(release.tag_name, "v0.0.1");
assert_eq!(release.id, 0);
assert!(!release.draft);
assert!(!release.prerelease);
assert!(release.author.is_none());
assert!(release.published_at.is_none());
assert!(release.url.is_empty());
assert!(
release.created_at.is_none(),
"missing created_at must stay None, not fall back to Utc::now()"
);
}
#[tokio::test]
async fn test_should_accept_string_author_id_from_api() {
let json = r#"[{
"tag_name": "v1.0.0",
"author": {"login": "dev", "id": "42"}
}]"#;
let runner = MockCommandRunner::success(json);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let paged = provider.list(None).await.expect("list should succeed");
assert_eq!(paged.items[0].author.as_ref().expect("author").id, "42");
}
#[tokio::test]
async fn test_should_deserialize_real_gitcode_release_api_response() {
let json = r#"[{
"tag_name": "v0.1.0-test-issue368",
"target_commitish": "223bb9d0d96331abc9d97074c0644097fd68d96f",
"prerelease": false,
"name": "Test release for Issue #368 verification",
"body": "临时测试 release,用于实测 gitcode release list API 响应形状(Issue #368),验证完成后会删除。",
"author": {
"id": "812276",
"login": "byx-darwin",
"name": "baoyx",
"avatar_url": "https://cdn-img.gitcode.com/example.png",
"html_url": "https://gitcode.com/byx-darwin",
"type": "User",
"url": "https://api.gitcode.com/api/v5/users/byx-darwin"
},
"created_at": "2026-09-20T22:22:44+08:00",
"assets": [
{
"browser_download_url": "https://raw.gitcode.com/byx-darwin/NexaTrade/archive/refs/heads/v0.1.0-test-issue368.zip",
"name": "v0.1.0-test-issue368.zip",
"type": "source"
}
],
"release_status": "none"
}]"#;
let runner = MockCommandRunner::success(json);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let paged = provider
.list(None)
.await
.expect("real response shape should not fail list");
let release = &paged.items[0];
assert_eq!(release.tag_name, "v0.1.0-test-issue368");
assert_eq!(release.id, 0, "缺失的 id 应退化为 0");
assert!(!release.draft, "缺失的 draft 应退化为 false");
assert!(!release.prerelease);
assert_eq!(
release.name.as_deref(),
Some("Test release for Issue #368 verification")
);
assert!(
release.url.is_empty(),
"缺失的 html_url/url 应退化为空字符串"
);
assert!(
release.published_at.is_none(),
"缺失的 published_at 应退化为 None"
);
let author = release.author.as_ref().expect("author present");
assert_eq!(author.id, "812276");
assert_eq!(author.login, "byx-darwin");
assert_eq!(
release.created_at,
Some(
chrono::DateTime::parse_from_rfc3339("2026-09-20T22:22:44+08:00")
.expect("valid rfc3339")
.with_timezone(&Utc)
)
);
}
#[tokio::test]
async fn test_should_accept_string_release_id_from_api() {
let json = r#"[{
"id": "12",
"tag_name": "v1.0.0"
}]"#;
let runner = MockCommandRunner::success(json);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let paged = provider.list(None).await.expect("list should succeed");
assert_eq!(paged.items[0].id, 12);
}
#[tokio::test]
async fn test_should_degrade_release_flags_when_null_in_api_response() {
let json = r#"[{
"id": 1,
"tag_name": null,
"draft": null,
"prerelease": null
}]"#;
let runner = MockCommandRunner::success(json);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let paged = provider.list(None).await.expect("list should succeed");
let release = &paged.items[0];
assert_eq!(release.tag_name, "");
assert!(!release.draft);
assert!(!release.prerelease);
}
#[tokio::test]
async fn test_should_degrade_release_id_to_zero_when_null_in_api_response() {
let json = r#"[{
"id": null,
"tag_name": "v1.0.0"
}]"#;
let runner = MockCommandRunner::success(json);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let paged = provider.list(None).await.expect("list should succeed");
assert_eq!(paged.items[0].id, 0);
}
#[tokio::test]
async fn test_should_degrade_author_login_to_empty_when_null_in_api_response() {
let json = r#"[{
"id": 1,
"tag_name": "v1.0.0",
"author": {"login": null, "id": 42}
}]"#;
let runner = MockCommandRunner::success(json);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let paged = provider.list(None).await.expect("list should succeed");
let author = paged.items[0].author.as_ref().expect("author");
assert_eq!(author.login, "");
assert_eq!(author.id, "42");
}
#[tokio::test]
async fn test_should_fail_list_when_created_at_is_not_rfc3339() {
let json = r#"[{
"id": 1,
"tag_name": "v1.0.0",
"created_at": "2026-01-01 00:00:00"
}]"#;
let runner = MockCommandRunner::success(json);
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let err = provider
.list(None)
.await
.expect_err("malformed created_at must still fail the whole list");
assert!(
err.to_string().contains("premature end of input"),
"实际错误: {err}"
);
}
#[tokio::test]
async fn test_should_cap_gitcode_release_per_page_at_api_maximum() {
let runner = MockCommandRunner::success("[]");
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner.clone());
provider.list(None).await.expect("list should succeed");
assert_eq!(
runner.recorded_calls()[0].1,
vec!["api", "/repos/owner/repo/releases?per_page=100&page=1"],
"默认 cap={DEFAULT_LIST_LIMIT} 时 per_page 必须被 API 上限 100 钳住"
);
}
#[tokio::test]
async fn test_should_create_release_successfully() {
let runner = MockCommandRunner::success(valid_release_json());
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let release = provider
.create(sample_release_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 = MockCommandRunner::success(valid_release_json());
let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
let release = provider
.edit("v1.0.0", sample_release_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 = GitCodeReleaseProvider::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 = GitCodeReleaseProvider::with_runner("owner/repo", runner);
assert!(
provider
.upload_asset("v1.0.0", "/tmp/artifact.tar.gz", "artifact.tar.gz")
.await
.is_ok()
);
}
}