1use async_trait::async_trait;
8use gitflow_core::{
9 CoreError, Result,
10 release::{CreateReleaseArgs, ReleaseData, ReleaseProvider},
11};
12use tracing::debug;
13
14use crate::{
15 error::parse_gitcode_error,
16 runner::{CommandRunner, RealCommandRunner},
17};
18
19const RELEASE_FIELDS: &str =
21 "id,tagName,name,body,isDraft,isPrerelease,author,createdAt,publishedAt,url";
22
23#[derive(Debug, Clone)]
39pub struct GitCodeReleaseProvider<R: CommandRunner = RealCommandRunner> {
40 repo: String,
42 runner: R,
44}
45
46impl GitCodeReleaseProvider<RealCommandRunner> {
47 #[must_use]
51 pub fn new(repo: impl Into<String>) -> Self {
52 Self {
53 repo: repo.into(),
54 runner: RealCommandRunner,
55 }
56 }
57}
58
59impl<R: CommandRunner> GitCodeReleaseProvider<R> {
60 #[must_use]
65 pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
66 Self {
67 repo: repo.into(),
68 runner,
69 }
70 }
71}
72
73#[async_trait]
74impl<R: CommandRunner + 'static> ReleaseProvider for GitCodeReleaseProvider<R> {
75 async fn create(&self, args: CreateReleaseArgs) -> Result<ReleaseData> {
76 let binary = crate::gitcode_binary();
77 let mut cmd_args: Vec<&str> = vec![
78 "release",
79 "create",
80 &args.tag_name,
81 "-R",
82 &self.repo,
83 "--json",
84 RELEASE_FIELDS,
85 ];
86
87 if let Some(ref name) = args.name {
88 cmd_args.push("--title");
89 cmd_args.push(name);
90 }
91
92 if let Some(ref body) = args.body {
93 cmd_args.push("--notes");
94 cmd_args.push(body);
95 }
96
97 if args.draft {
98 cmd_args.push("--draft");
99 }
100
101 if args.prerelease {
102 cmd_args.push("--prerelease");
103 }
104
105 if let Some(ref commitish) = args.target_commitish {
106 cmd_args.push("--target");
107 cmd_args.push(commitish);
108 }
109
110 debug!(
111 repo = %self.repo,
112 tag = %args.tag_name,
113 "spawning `gc release create`"
114 );
115
116 let output = self
117 .runner
118 .run(&binary, &cmd_args)
119 .await
120 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
121
122 if !output.status.success() {
123 return Err(parse_gitcode_error(&output.stderr).into());
124 }
125
126 match serde_json::from_slice::<ReleaseData>(&output.stdout) {
129 Ok(release) => Ok(release),
130 Err(_) => self.view(&args.tag_name).await,
131 }
132 }
133
134 async fn list(&self) -> Result<Vec<ReleaseData>> {
135 let binary = crate::gitcode_binary();
136 debug!(repo = %self.repo, "spawning `gc release list`");
137
138 let output = self
139 .runner
140 .run(
141 &binary,
142 &[
143 "release",
144 "list",
145 "-R",
146 &self.repo,
147 "--json",
148 RELEASE_FIELDS,
149 ],
150 )
151 .await
152 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
153
154 if !output.status.success() {
155 return Err(parse_gitcode_error(&output.stderr).into());
156 }
157
158 let releases: Vec<ReleaseData> =
159 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
160
161 Ok(releases)
162 }
163
164 async fn view(&self, tag_name: &str) -> Result<ReleaseData> {
165 let binary = crate::gitcode_binary();
166 debug!(repo = %self.repo, tag = %tag_name, "spawning `gc release view`");
167
168 let output = self
169 .runner
170 .run(
171 &binary,
172 &["release", "view", tag_name, "-R", &self.repo, "--json"],
173 )
174 .await
175 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
176
177 if !output.status.success() {
178 return Err(parse_gitcode_error(&output.stderr).into());
179 }
180
181 let release: ReleaseData =
182 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
183
184 Ok(release)
185 }
186
187 async fn edit(&self, tag_name: &str, args: CreateReleaseArgs) -> Result<ReleaseData> {
188 let binary = crate::gitcode_binary();
189 let mut cmd_args: Vec<&str> = vec![
190 "release",
191 "edit",
192 tag_name,
193 "-R",
194 &self.repo,
195 "--json",
196 RELEASE_FIELDS,
197 ];
198
199 if let Some(ref name) = args.name {
200 cmd_args.push("--title");
201 cmd_args.push(name);
202 }
203
204 if let Some(ref body) = args.body {
205 cmd_args.push("--notes");
206 cmd_args.push(body);
207 }
208
209 if args.draft {
210 cmd_args.push("--draft");
211 }
212
213 if args.prerelease {
214 cmd_args.push("--prerelease");
215 }
216
217 debug!(
218 repo = %self.repo,
219 tag = %tag_name,
220 "spawning `gc release edit`"
221 );
222
223 let output = self
224 .runner
225 .run(&binary, &cmd_args)
226 .await
227 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
228
229 if !output.status.success() {
230 return Err(parse_gitcode_error(&output.stderr).into());
231 }
232
233 match serde_json::from_slice::<ReleaseData>(&output.stdout) {
235 Ok(release) => Ok(release),
236 Err(_) => self.view(tag_name).await,
237 }
238 }
239
240 async fn delete(&self, tag_name: &str) -> Result<()> {
241 let binary = crate::gitcode_binary();
242 debug!(repo = %self.repo, tag = %tag_name, "spawning `gc release delete`");
243
244 let output = self
245 .runner
246 .run(&binary, &["release", "delete", tag_name, "-R", &self.repo])
247 .await
248 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
249
250 if !output.status.success() {
251 return Err(parse_gitcode_error(&output.stderr).into());
252 }
253
254 Ok(())
255 }
256
257 async fn upload_asset(&self, tag_name: &str, file_path: &str, _asset_name: &str) -> Result<()> {
258 let binary = crate::gitcode_binary();
259 debug!(
260 repo = %self.repo,
261 tag = %tag_name,
262 file = %file_path,
263 "spawning `gc release upload`"
264 );
265
266 let output = self
267 .runner
268 .run(
269 &binary,
270 &["release", "upload", tag_name, file_path, "-R", &self.repo],
271 )
272 .await
273 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
274
275 if !output.status.success() {
276 return Err(parse_gitcode_error(&output.stderr).into());
277 }
278
279 Ok(())
280 }
281
282 async fn download_asset(
283 &self,
284 tag_name: &str,
285 asset_name: &str,
286 output_path: &str,
287 ) -> Result<()> {
288 let binary = crate::gitcode_binary();
289 debug!(
290 repo = %self.repo,
291 tag = %tag_name,
292 asset = %asset_name,
293 output = %output_path,
294 "spawning `gc release download`"
295 );
296
297 let output = self
298 .runner
299 .run(
300 &binary,
301 &[
302 "release",
303 "download",
304 tag_name,
305 "-R",
306 &self.repo,
307 "--asset",
308 asset_name,
309 "--output",
310 output_path,
311 ],
312 )
313 .await
314 .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
315
316 if !output.status.success() {
317 return Err(parse_gitcode_error(&output.stderr).into());
318 }
319
320 Ok(())
321 }
322}
323
324#[cfg(test)]
325mod tests {
326 use super::*;
327 use crate::runner::MockCommandRunner;
328
329 #[test]
330 fn test_should_construct_gitcode_release_provider() {
331 let provider = GitCodeReleaseProvider::new("octocat/hello-world");
332 assert_eq!(provider.repo, "octocat/hello-world");
333 }
334
335 #[test]
336 fn test_should_construct_gitcode_release_provider_from_string() {
337 let repo = String::from("octocat/hello-world");
338 let provider = GitCodeReleaseProvider::new(repo);
339 assert_eq!(provider.repo, "octocat/hello-world");
340 }
341
342 #[test]
343 fn test_should_debug_format_provider() {
344 let provider = GitCodeReleaseProvider::new("octocat/hello-world");
345 let debug = format!("{provider:?}");
346 assert!(debug.contains("GitCodeReleaseProvider"));
347 assert!(debug.contains("octocat/hello-world"));
348 }
349
350 #[test]
351 fn test_should_clone_gitcode_release_provider() {
352 let original = GitCodeReleaseProvider::new("owner/repo");
353 let cloned = original.clone();
354 assert_eq!(original.repo, cloned.repo);
355 }
356
357 fn sample_release_args() -> CreateReleaseArgs {
360 CreateReleaseArgs {
361 tag_name: "v1.0.0".to_string(),
362 name: Some("Release 1.0.0".to_string()),
363 body: Some("First stable release".to_string()),
364 draft: false,
365 prerelease: false,
366 target_commitish: None,
367 }
368 }
369
370 #[tokio::test]
371 async fn test_should_return_platform_error_when_gc_fails_for_create() {
372 let runner = MockCommandRunner::failure("tag already exists", 256);
373 let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
374
375 let result = provider.create(sample_release_args()).await;
376
377 assert!(matches!(
378 result.unwrap_err(),
379 gitflow_core::CoreError::Cli(_)
380 ));
381 }
382
383 #[tokio::test]
384 async fn test_should_return_serialization_error_on_invalid_json_for_create() {
385 let runner = MockCommandRunner::success("not valid json");
388 let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
389
390 let result = provider.create(sample_release_args()).await;
391
392 assert!(matches!(
393 result.unwrap_err(),
394 gitflow_core::CoreError::Serialization(_)
395 ));
396 }
397
398 #[tokio::test]
399 async fn test_should_return_platform_error_when_gc_fails_for_list() {
400 let runner = MockCommandRunner::failure("forbidden", 256);
401 let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
402
403 let result = provider.list().await;
404
405 assert!(matches!(
406 result.unwrap_err(),
407 gitflow_core::CoreError::Cli(_)
408 ));
409 }
410
411 #[tokio::test]
412 async fn test_should_return_serialization_error_on_invalid_json_for_list() {
413 let runner = MockCommandRunner::success("invalid");
414 let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
415
416 let result = provider.list().await;
417
418 assert!(matches!(
419 result.unwrap_err(),
420 gitflow_core::CoreError::Serialization(_)
421 ));
422 }
423
424 #[tokio::test]
425 async fn test_should_return_platform_error_when_gc_fails_for_view() {
426 let runner = MockCommandRunner::failure("release not found", 256);
427 let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
428
429 let result = provider.view("v1.0.0").await;
430
431 assert!(matches!(
432 result.unwrap_err(),
433 gitflow_core::CoreError::Cli(_)
434 ));
435 }
436
437 #[tokio::test]
438 async fn test_should_return_serialization_error_on_invalid_json_for_view() {
439 let runner = MockCommandRunner::success("not valid json");
440 let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
441
442 let result = provider.view("v1.0.0").await;
443
444 assert!(matches!(
445 result.unwrap_err(),
446 gitflow_core::CoreError::Serialization(_)
447 ));
448 }
449
450 #[tokio::test]
451 async fn test_should_return_platform_error_when_gc_fails_for_edit() {
452 let runner = MockCommandRunner::failure("release not found", 256);
453 let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
454
455 let result = provider.edit("v1.0.0", sample_release_args()).await;
456
457 assert!(matches!(
458 result.unwrap_err(),
459 gitflow_core::CoreError::Cli(_)
460 ));
461 }
462
463 #[tokio::test]
464 async fn test_should_return_serialization_error_on_invalid_json_for_edit() {
465 let runner = MockCommandRunner::success("not valid json");
468 let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
469
470 let result = provider.edit("v1.0.0", sample_release_args()).await;
471
472 assert!(matches!(
473 result.unwrap_err(),
474 gitflow_core::CoreError::Serialization(_)
475 ));
476 }
477
478 #[tokio::test]
479 async fn test_should_return_platform_error_when_gc_fails_for_delete() {
480 let runner = MockCommandRunner::failure("release not found", 256);
481 let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
482
483 let result = provider.delete("v1.0.0").await;
484
485 assert!(matches!(
486 result.unwrap_err(),
487 gitflow_core::CoreError::Cli(_)
488 ));
489 }
490
491 #[tokio::test]
492 async fn test_should_return_platform_error_when_gc_fails_for_upload_asset() {
493 let runner = MockCommandRunner::failure("upload failed", 256);
494 let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
495
496 let result = provider
497 .upload_asset("v1.0.0", "/tmp/artifact.tar.gz", "artifact.tar.gz")
498 .await;
499
500 assert!(matches!(
501 result.unwrap_err(),
502 gitflow_core::CoreError::Cli(_)
503 ));
504 }
505
506 #[tokio::test]
507 async fn test_should_return_platform_error_when_gc_fails_for_download_asset() {
508 let runner = MockCommandRunner::failure("asset not found", 256);
509 let provider = GitCodeReleaseProvider::with_runner("owner/repo", runner);
510
511 let result = provider
512 .download_asset("v1.0.0", "artifact.tar.gz", "/tmp/out.tar.gz")
513 .await;
514
515 assert!(matches!(
516 result.unwrap_err(),
517 gitflow_core::CoreError::Cli(_)
518 ));
519 }
520}