1use async_trait::async_trait;
8use chrono::{DateTime, Utc};
9use serde::{Deserialize, Serialize};
10
11use crate::{Result, types::UserSummary};
12
13#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(rename_all = "camelCase")]
19pub struct ReleaseData {
20 #[serde(default, alias = "databaseId")]
22 pub id: u64,
23 pub tag_name: String,
25 #[serde(skip_serializing_if = "Option::is_none")]
27 pub name: Option<String>,
28 #[serde(skip_serializing_if = "Option::is_none")]
30 pub body: Option<String>,
31 #[serde(alias = "isDraft")]
33 pub draft: bool,
34 #[serde(alias = "isPrerelease")]
36 pub prerelease: bool,
37 #[serde(skip_serializing_if = "Option::is_none")]
39 pub author: Option<UserSummary>,
40 pub created_at: DateTime<Utc>,
42 #[serde(skip_serializing_if = "Option::is_none")]
44 pub published_at: Option<DateTime<Utc>>,
45 #[serde(default)]
47 pub url: String,
48}
49
50#[derive(Debug, Clone)]
52pub struct CreateReleaseArgs {
53 pub tag_name: String,
55 pub name: Option<String>,
57 pub body: Option<String>,
59 pub draft: bool,
61 pub prerelease: bool,
63 pub target_commitish: Option<String>,
65}
66
67#[async_trait]
80pub trait ReleaseProvider: std::fmt::Debug + Send + Sync {
81 async fn create(&self, args: CreateReleaseArgs) -> Result<ReleaseData>;
87
88 async fn list(&self) -> Result<Vec<ReleaseData>>;
94
95 async fn view(&self, tag_name: &str) -> Result<ReleaseData>;
101
102 async fn edit(&self, tag_name: &str, args: CreateReleaseArgs) -> Result<ReleaseData>;
108
109 async fn upload_asset(&self, tag_name: &str, file_path: &str, asset_name: &str) -> Result<()>;
118
119 async fn download_asset(&self, tag_name: &str, asset_name: &str, dest_path: &str)
125 -> Result<()>;
126
127 async fn delete(&self, tag_name: &str) -> Result<()>;
133}
134
135#[cfg(test)]
136mod tests {
137 use super::*;
138
139 fn sample_release_json() -> &'static str {
140 r#"{
141 "id": 1001,
142 "tagName": "v1.0.0",
143 "name": "Version 1.0.0",
144 "body": "Initial stable release",
145 "draft": false,
146 "prerelease": false,
147 "author": {"login": "octocat", "id": "1"},
148 "createdAt": "2026-01-01T00:00:00Z",
149 "publishedAt": "2026-01-15T12:00:00Z",
150 "url": "https://github.com/octocat/hello-world/releases/tag/v1.0.0"
151 }"#
152 }
153
154 #[test]
155 fn test_should_deserialize_release_data_from_json() {
156 let json = sample_release_json();
157 let release: ReleaseData = serde_json::from_str(json).expect("valid ReleaseData JSON");
158
159 assert_eq!(release.id, 1001);
160 assert_eq!(release.tag_name, "v1.0.0");
161 assert_eq!(release.name.as_deref(), Some("Version 1.0.0"));
162 assert_eq!(release.body.as_deref(), Some("Initial stable release"));
163 assert!(!release.draft);
164 assert!(!release.prerelease);
165 assert_eq!(release.author.as_ref().unwrap().login, "octocat");
166 assert_eq!(release.author.as_ref().unwrap().id, "1");
167 assert_eq!(
168 release.url,
169 "https://github.com/octocat/hello-world/releases/tag/v1.0.0"
170 );
171 }
172
173 #[test]
174 fn test_should_roundtrip_release_data_via_serde() {
175 let json = sample_release_json();
176 let release: ReleaseData = serde_json::from_str(json).expect("deserialize");
177 let re_serialized = serde_json::to_string(&release).expect("serialize");
178 let round_tripped: ReleaseData =
179 serde_json::from_str(&re_serialized).expect("re-deserialize");
180
181 assert_eq!(round_tripped.id, release.id);
182 assert_eq!(round_tripped.tag_name, release.tag_name);
183 assert_eq!(round_tripped.name, release.name);
184 assert_eq!(round_tripped.body, release.body);
185 assert_eq!(round_tripped.draft, release.draft);
186 assert_eq!(round_tripped.prerelease, release.prerelease);
187 assert_eq!(round_tripped.created_at, release.created_at);
188 assert_eq!(round_tripped.published_at, release.published_at);
189 assert_eq!(round_tripped.url, release.url);
190 }
191
192 #[test]
193 fn test_should_deserialize_draft_release_with_null_optional_fields() {
194 let json = r#"{
195 "id": 5,
196 "tagName": "v0.1.0-draft",
197 "name": null,
198 "body": null,
199 "draft": true,
200 "prerelease": true,
201 "author": {"login": "dev", "id": "99"},
202 "createdAt": "2026-03-01T00:00:00Z",
203 "publishedAt": null,
204 "url": "https://example.com/releases/5"
205 }"#;
206 let release: ReleaseData = serde_json::from_str(json).expect("deserialize");
207 assert!(release.draft);
208 assert!(release.prerelease);
209 assert!(release.name.is_none());
210 assert!(release.body.is_none());
211 assert!(release.published_at.is_none());
212 }
213
214 #[test]
215 fn test_should_omit_none_fields_on_serialize() {
216 let json = sample_release_json();
217 let mut release: ReleaseData = serde_json::from_str(json).expect("deserialize");
218 release.name = None;
219 release.body = None;
220 release.published_at = None;
221 let serialized = serde_json::to_string(&release).expect("serialize");
222 assert!(!serialized.contains("null"));
223 assert!(!serialized.contains("\"name\":"));
224 assert!(!serialized.contains("\"body\":"));
225 assert!(!serialized.contains("\"publishedAt\":"));
226 }
227
228 #[test]
229 fn test_should_serialize_camel_case_fields() {
230 let json = sample_release_json();
231 let release: ReleaseData = serde_json::from_str(json).expect("deserialize");
232 let serialized = serde_json::to_string(&release).expect("serialize");
233 assert!(serialized.contains("\"tagName\""));
234 assert!(serialized.contains("\"createdAt\""));
235 assert!(serialized.contains("\"publishedAt\""));
236 assert!(!serialized.contains("\"tag_name\""));
237 assert!(!serialized.contains("\"created_at\""));
238 assert!(!serialized.contains("\"published_at\""));
239 }
240
241 #[test]
242 fn test_create_release_args_debug_derive() {
243 let args = CreateReleaseArgs {
244 tag_name: "v1.0.0".into(),
245 name: Some("v1".into()),
246 body: None,
247 draft: false,
248 prerelease: false,
249 target_commitish: Some("abc123".into()),
250 };
251 let debug = format!("{args:?}");
252 assert!(debug.contains("CreateReleaseArgs"));
253 assert!(debug.contains("v1.0.0"));
254 }
255}