1use async_trait::async_trait;
12use chrono::{DateTime, Utc};
13use gitflow_core::{
14 CoreError, Result,
15 release::{CreateReleaseArgs, ReleaseData, ReleaseProvider},
16 types::UserSummary,
17};
18use serde::Deserialize;
19use tracing::debug;
20
21use crate::{
22 error::parse_glab_error,
23 runner::{CommandRunner, RealCommandRunner},
24};
25
26#[derive(Debug, Clone)]
39pub struct GitLabReleaseProvider<R: CommandRunner = RealCommandRunner> {
40 repo: String,
42 runner: R,
44}
45
46impl GitLabReleaseProvider<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> GitLabReleaseProvider<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#[derive(Debug, Clone, Deserialize)]
77struct ApiUser {
78 username: String,
79 #[serde(default)]
80 id: u64,
81}
82
83impl From<&ApiUser> for UserSummary {
84 fn from(u: &ApiUser) -> Self {
85 Self {
86 login: u.username.clone(),
87 id: u.id.to_string(),
88 }
89 }
90}
91
92#[derive(Debug, Clone, Deserialize)]
94struct ReleaseApiResponse {
95 #[serde(default)]
96 tag_name: String,
97 #[serde(default)]
98 name: Option<String>,
99 #[serde(default)]
100 description: Option<String>,
101 #[serde(default)]
102 draft: bool,
103 #[serde(default)]
104 prerelease: bool,
105 #[serde(default)]
106 author: Option<ApiUser>,
107 #[serde(default)]
108 created_at: Option<DateTime<Utc>>,
109 #[serde(default)]
110 released_at: Option<DateTime<Utc>>,
111 #[serde(default)]
112 url: Option<String>,
113 #[serde(default)]
115 id: Option<u64>,
116}
117
118impl From<ReleaseApiResponse> for ReleaseData {
119 fn from(api: ReleaseApiResponse) -> Self {
120 let now = Utc::now();
121 let author = api.author.as_ref().map(UserSummary::from);
122
123 Self {
124 id: api.id.unwrap_or(0),
125 tag_name: api.tag_name,
126 name: api.name,
127 body: api.description,
128 draft: api.draft,
129 prerelease: api.prerelease,
130 author,
131 created_at: api.created_at.unwrap_or(now),
132 published_at: api.released_at,
133 url: api.url.unwrap_or_default(),
134 }
135 }
136}
137
138#[async_trait]
141impl<R: CommandRunner + 'static> ReleaseProvider for GitLabReleaseProvider<R> {
142 async fn create(&self, args: CreateReleaseArgs) -> Result<ReleaseData> {
143 let mut cmd_args: Vec<&str> = vec![
144 "release",
145 "create",
146 &args.tag_name,
147 "--repo",
148 &self.repo,
149 "--output",
150 "json",
151 ];
152
153 if let Some(ref name) = args.name {
154 cmd_args.push("--name");
155 cmd_args.push(name);
156 }
157
158 if let Some(ref body) = args.body {
159 cmd_args.push("--notes");
160 cmd_args.push(body);
161 }
162
163 if args.draft {
164 cmd_args.push("--draft");
165 }
166
167 if args.prerelease {
168 cmd_args.push("--prerelease");
169 }
170
171 if let Some(ref commitish) = args.target_commitish {
172 cmd_args.push("--ref");
173 cmd_args.push(commitish);
174 }
175
176 debug!(
177 repo = %self.repo,
178 tag = %args.tag_name,
179 "spawning `glab release create`"
180 );
181
182 let output = self
183 .runner
184 .run("glab", &cmd_args)
185 .await
186 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
187
188 if !output.status.success() {
189 return Err(parse_glab_error(&output.stderr).into());
190 }
191
192 let api_response: ReleaseApiResponse =
193 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
194
195 Ok(api_response.into())
196 }
197
198 async fn list(&self) -> Result<Vec<ReleaseData>> {
199 debug!(repo = %self.repo, "spawning `glab release list`");
200
201 let output = self
202 .runner
203 .run(
204 "glab",
205 &["release", "list", "--repo", &self.repo, "--output", "json"],
206 )
207 .await
208 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
209
210 if !output.status.success() {
211 return Err(parse_glab_error(&output.stderr).into());
212 }
213
214 let api_responses: Vec<ReleaseApiResponse> =
215 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
216
217 Ok(api_responses.into_iter().map(ReleaseData::from).collect())
218 }
219
220 async fn view(&self, tag_name: &str) -> Result<ReleaseData> {
221 debug!(repo = %self.repo, tag = %tag_name, "spawning `glab release view`");
222
223 let output = self
224 .runner
225 .run(
226 "glab",
227 &[
228 "release", "view", tag_name, "--repo", &self.repo, "--output", "json",
229 ],
230 )
231 .await
232 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
233
234 if !output.status.success() {
235 return Err(parse_glab_error(&output.stderr).into());
236 }
237
238 let api_response: ReleaseApiResponse =
239 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
240
241 Ok(api_response.into())
242 }
243
244 async fn edit(&self, tag_name: &str, args: CreateReleaseArgs) -> Result<ReleaseData> {
245 let mut cmd_args: Vec<&str> = vec![
246 "release", "edit", tag_name, "--repo", &self.repo, "--output", "json",
247 ];
248
249 if let Some(ref name) = args.name {
250 cmd_args.push("--name");
251 cmd_args.push(name);
252 }
253
254 if let Some(ref body) = args.body {
255 cmd_args.push("--notes");
256 cmd_args.push(body);
257 }
258
259 if args.draft {
260 cmd_args.push("--draft");
261 }
262
263 if args.prerelease {
264 cmd_args.push("--prerelease");
265 }
266
267 if let Some(ref commitish) = args.target_commitish {
268 cmd_args.push("--ref");
269 cmd_args.push(commitish);
270 }
271
272 debug!(
273 repo = %self.repo,
274 tag = %tag_name,
275 "spawning `glab release edit`"
276 );
277
278 let output = self
279 .runner
280 .run("glab", &cmd_args)
281 .await
282 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
283
284 if !output.status.success() {
285 return Err(parse_glab_error(&output.stderr).into());
286 }
287
288 let api_response: ReleaseApiResponse =
289 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
290
291 Ok(api_response.into())
292 }
293
294 async fn upload_asset(&self, tag_name: &str, file_path: &str, _asset_name: &str) -> Result<()> {
295 debug!(
296 repo = %self.repo,
297 tag = %tag_name,
298 file = %file_path,
299 "spawning `glab release upload`"
300 );
301
302 let output = self
303 .runner
304 .run(
305 "glab",
306 &[
307 "release", "upload", tag_name, file_path, "--repo", &self.repo,
308 ],
309 )
310 .await
311 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
312
313 if !output.status.success() {
314 return Err(parse_glab_error(&output.stderr).into());
315 }
316
317 Ok(())
318 }
319
320 #[allow(
321 clippy::disallowed_methods,
322 reason = "Path parent extraction required for download"
323 )]
324 async fn download_asset(
325 &self,
326 tag_name: &str,
327 asset_name: &str,
328 dest_path: &str,
329 ) -> Result<()> {
330 debug!(
331 repo = %self.repo,
332 tag = %tag_name,
333 asset = %asset_name,
334 dest = %dest_path,
335 "spawning `glab release download`"
336 );
337
338 let dest = std::path::PathBuf::from(dest_path);
339 let parent = dest.parent().unwrap_or_else(|| std::path::Path::new("."));
340 let parent_str = parent.to_string_lossy();
341
342 let output = self
343 .runner
344 .run(
345 "glab",
346 &[
347 "release",
348 "download",
349 tag_name,
350 "--repo",
351 &self.repo,
352 "--pattern",
353 asset_name,
354 "--dir",
355 &parent_str,
356 ],
357 )
358 .await
359 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
360
361 if !output.status.success() {
362 return Err(parse_glab_error(&output.stderr).into());
363 }
364
365 let downloaded = parent.join(asset_name);
366 if downloaded != dest && downloaded.exists() {
367 std::fs::rename(&downloaded, &dest).map_err(|e| {
368 CoreError::Platform(format!(
369 "Failed to move downloaded asset to {dest_path}: {e}"
370 ))
371 })?;
372 }
373
374 Ok(())
375 }
376
377 async fn delete(&self, tag_name: &str) -> Result<()> {
378 debug!(repo = %self.repo, tag = %tag_name, "spawning `glab release delete`");
379
380 let output = self
381 .runner
382 .run(
383 "glab",
384 &["release", "delete", tag_name, "--repo", &self.repo, "--yes"],
385 )
386 .await
387 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
388
389 if !output.status.success() {
390 return Err(parse_glab_error(&output.stderr).into());
391 }
392
393 Ok(())
394 }
395}
396
397#[cfg(test)]
398mod tests {
399 use super::*;
400 use crate::runner::MockCommandRunner;
401
402 #[test]
403 fn test_should_construct_gitlab_release_provider() {
404 let provider = GitLabReleaseProvider::new("gitlab-org/gitlab");
405 assert_eq!(provider.repo, "gitlab-org/gitlab");
406 }
407
408 #[test]
409 fn test_should_construct_gitlab_release_provider_from_string() {
410 let repo = String::from("gitlab-org/gitlab");
411 let provider = GitLabReleaseProvider::new(repo);
412 assert_eq!(provider.repo, "gitlab-org/gitlab");
413 }
414
415 #[test]
416 fn test_should_deserialize_release_api_response() {
417 let json = br#"{
418 "id": 1001,
419 "tag_name": "v1.0.0",
420 "name": "Version 1.0.0",
421 "description": "Initial stable release",
422 "draft": false,
423 "prerelease": false,
424 "author": {"username": "admin", "id": 1},
425 "created_at": "2026-01-01T00:00:00Z",
426 "released_at": "2026-01-15T12:00:00Z",
427 "url": "https://gitlab.com/gitlab-org/gitlab/-/releases/v1.0.0"
428 }"#;
429
430 let api: ReleaseApiResponse =
431 serde_json::from_slice(json).expect("valid ReleaseApiResponse");
432 let release: ReleaseData = api.into();
433
434 assert_eq!(release.id, 1001);
435 assert_eq!(release.tag_name, "v1.0.0");
436 assert_eq!(release.name.as_deref(), Some("Version 1.0.0"));
437 assert_eq!(release.body.as_deref(), Some("Initial stable release"));
438 assert!(!release.draft);
439 assert!(!release.prerelease);
440 assert_eq!(
441 release.author.as_ref().expect("author present").login,
442 "admin"
443 );
444 assert_eq!(
445 release.url,
446 "https://gitlab.com/gitlab-org/gitlab/-/releases/v1.0.0"
447 );
448 }
449
450 #[test]
451 fn test_should_deserialize_draft_release() {
452 let json = br#"{
453 "tag_name": "v0.1.0-draft",
454 "name": null,
455 "description": null,
456 "draft": true,
457 "prerelease": true,
458 "author": {"username": "dev", "id": 99},
459 "created_at": "2026-03-01T00:00:00Z",
460 "released_at": null,
461 "url": null
462 }"#;
463
464 let api: ReleaseApiResponse =
465 serde_json::from_slice(json).expect("valid ReleaseApiResponse");
466 let release: ReleaseData = api.into();
467 assert!(release.draft);
468 assert!(release.prerelease);
469 assert!(release.name.is_none());
470 assert!(release.published_at.is_none());
471 }
472
473 #[test]
474 fn test_should_deserialize_empty_release_list() {
475 let json = b"[]";
476 let list: Vec<ReleaseApiResponse> = serde_json::from_slice(json).expect("valid empty list");
477 assert!(list.is_empty());
478 }
479
480 #[test]
481 fn test_should_debug_format_provider() {
482 let provider = GitLabReleaseProvider::new("gitlab-org/gitlab");
483 let debug = format!("{provider:?}");
484 assert!(debug.contains("GitLabReleaseProvider"));
485 assert!(debug.contains("gitlab-org/gitlab"));
486 }
487
488 #[test]
489 fn test_should_clone_gitlab_release_provider() {
490 let original = GitLabReleaseProvider::new("owner/repo");
491 let cloned = original.clone();
492 assert_eq!(original.repo, cloned.repo);
493 }
494
495 fn sample_create_args() -> CreateReleaseArgs {
498 CreateReleaseArgs {
499 tag_name: "v1.0.0".to_string(),
500 name: Some("Version 1.0.0".to_string()),
501 body: Some("Release notes".to_string()),
502 draft: false,
503 prerelease: false,
504 target_commitish: None,
505 }
506 }
507
508 #[tokio::test]
509 async fn test_should_return_platform_error_when_glab_fails_for_create() {
510 let runner = MockCommandRunner::failure(r#"{"message": "Tag exists"}"#, 256);
511 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
512
513 let result = provider.create(sample_create_args()).await;
514
515 assert!(matches!(
516 result.unwrap_err(),
517 gitflow_core::CoreError::Cli(_)
518 ));
519 }
520
521 #[tokio::test]
522 async fn test_should_return_serialization_error_on_invalid_json_for_create() {
523 let runner = MockCommandRunner::success("not valid json");
524 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
525
526 let result = provider.create(sample_create_args()).await;
527
528 assert!(matches!(
529 result.unwrap_err(),
530 gitflow_core::CoreError::Serialization(_)
531 ));
532 }
533
534 #[tokio::test]
535 async fn test_should_return_platform_error_when_glab_fails_for_list() {
536 let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
537 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
538
539 let result = provider.list().await;
540
541 assert!(matches!(
542 result.unwrap_err(),
543 gitflow_core::CoreError::Cli(_)
544 ));
545 }
546
547 #[tokio::test]
548 async fn test_should_return_serialization_error_on_invalid_json_for_list() {
549 let runner = MockCommandRunner::success("invalid");
550 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
551
552 let result = provider.list().await;
553
554 assert!(matches!(
555 result.unwrap_err(),
556 gitflow_core::CoreError::Serialization(_)
557 ));
558 }
559
560 #[tokio::test]
561 async fn test_should_return_platform_error_when_glab_fails_for_view() {
562 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
563 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
564
565 let result = provider.view("v1.0.0").await;
566
567 assert!(matches!(
568 result.unwrap_err(),
569 gitflow_core::CoreError::Cli(_)
570 ));
571 }
572
573 #[tokio::test]
574 async fn test_should_return_serialization_error_on_invalid_json_for_view() {
575 let runner = MockCommandRunner::success("invalid");
576 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
577
578 let result = provider.view("v1.0.0").await;
579
580 assert!(matches!(
581 result.unwrap_err(),
582 gitflow_core::CoreError::Serialization(_)
583 ));
584 }
585
586 #[tokio::test]
587 async fn test_should_return_platform_error_when_glab_fails_for_edit() {
588 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
589 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
590
591 let result = provider.edit("v1.0.0", sample_create_args()).await;
592
593 assert!(matches!(
594 result.unwrap_err(),
595 gitflow_core::CoreError::Cli(_)
596 ));
597 }
598
599 #[tokio::test]
600 async fn test_should_return_serialization_error_on_invalid_json_for_edit() {
601 let runner = MockCommandRunner::success("invalid");
602 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
603
604 let result = provider.edit("v1.0.0", sample_create_args()).await;
605
606 assert!(matches!(
607 result.unwrap_err(),
608 gitflow_core::CoreError::Serialization(_)
609 ));
610 }
611
612 #[tokio::test]
613 async fn test_should_return_platform_error_when_glab_fails_for_delete() {
614 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
615 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
616
617 let result = provider.delete("v1.0.0").await;
618
619 assert!(matches!(
620 result.unwrap_err(),
621 gitflow_core::CoreError::Cli(_)
622 ));
623 }
624
625 #[tokio::test]
626 async fn test_should_return_platform_error_when_glab_fails_for_upload_asset() {
627 let runner = MockCommandRunner::failure(r#"{"message": "Upload failed"}"#, 256);
628 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
629
630 let result = provider
631 .upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
632 .await;
633
634 assert!(matches!(
635 result.unwrap_err(),
636 gitflow_core::CoreError::Cli(_)
637 ));
638 }
639
640 #[tokio::test]
641 async fn test_should_return_platform_error_when_glab_fails_for_download_asset() {
642 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
643 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
644
645 let result = provider
646 .download_asset("v1.0.0", "asset.tar.gz", "/tmp/asset.tar.gz")
647 .await;
648
649 assert!(matches!(
650 result.unwrap_err(),
651 gitflow_core::CoreError::Cli(_)
652 ));
653 }
654}