1use async_trait::async_trait;
12use chrono::{DateTime, Utc};
13use gitflow_core::{
14 CoreError, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, fetch_capped,
15 release::{CreateReleaseArgs, ReleaseData, ReleaseProvider},
16 types::UserSummary,
17};
18use serde::Deserialize;
19use tracing::debug;
20
21use crate::{
22 GITLAB_MAX_PER_PAGE,
23 error::parse_glab_error,
24 runner::{CommandRunner, RealCommandRunner},
25};
26
27#[derive(Debug, Clone)]
40pub struct GitLabReleaseProvider<R: CommandRunner = RealCommandRunner> {
41 repo: String,
43 repo_target: String,
47 runner: R,
49}
50
51impl GitLabReleaseProvider<RealCommandRunner> {
52 #[must_use]
56 pub fn new(repo: impl Into<String>) -> Self {
57 let repo = repo.into();
58 Self {
59 repo_target: repo.clone(),
60 repo,
61 runner: RealCommandRunner,
62 }
63 }
64
65 #[must_use]
69 pub fn with_session(session: &gitflow_core::Session) -> Self {
70 let repo = session.repo.clone();
71 Self {
72 repo_target: repo.clone(),
73 repo,
74 runner: RealCommandRunner,
75 }
76 }
77
78 #[must_use]
80 pub fn with_remote_url(repo: impl Into<String>, remote_url: impl Into<String>) -> Self {
81 Self {
82 repo: repo.into(),
83 repo_target: remote_url.into(),
84 runner: RealCommandRunner,
85 }
86 }
87}
88
89impl<R: CommandRunner> GitLabReleaseProvider<R> {
90 #[must_use]
95 pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
96 let repo = repo.into();
97 Self {
98 repo_target: repo.clone(),
99 repo,
100 runner,
101 }
102 }
103
104 #[must_use]
108 pub fn with_runner_and_repo_target(
109 repo: impl Into<String>,
110 repo_target: impl Into<String>,
111 runner: R,
112 ) -> Self {
113 Self {
114 repo: repo.into(),
115 repo_target: repo_target.into(),
116 runner,
117 }
118 }
119}
120
121#[derive(Debug, Clone, Deserialize)]
125struct ApiUser {
126 username: String,
127 #[serde(default)]
128 id: u64,
129}
130
131impl From<&ApiUser> for UserSummary {
132 fn from(u: &ApiUser) -> Self {
133 Self {
134 login: u.username.clone(),
135 id: u.id.to_string(),
136 }
137 }
138}
139
140#[derive(Debug, Clone, Deserialize)]
142struct ReleaseApiResponse {
143 #[serde(default)]
144 tag_name: String,
145 #[serde(default)]
146 name: Option<String>,
147 #[serde(default)]
148 description: Option<String>,
149 #[serde(default)]
150 draft: bool,
151 #[serde(default)]
152 prerelease: bool,
153 #[serde(default)]
154 author: Option<ApiUser>,
155 #[serde(default)]
156 created_at: Option<DateTime<Utc>>,
157 #[serde(default)]
158 released_at: Option<DateTime<Utc>>,
159 #[serde(default)]
160 url: Option<String>,
161 #[serde(default)]
163 id: Option<u64>,
164}
165
166impl From<ReleaseApiResponse> for ReleaseData {
167 fn from(api: ReleaseApiResponse) -> Self {
168 let author = api.author.as_ref().map(UserSummary::from);
169
170 Self {
171 id: api.id.unwrap_or(0),
172 tag_name: api.tag_name,
173 name: api.name,
174 body: api.description,
175 draft: api.draft,
176 prerelease: api.prerelease,
177 author,
178 created_at: api.created_at,
179 published_at: api.released_at,
180 url: api.url.unwrap_or_default(),
181 }
182 }
183}
184
185#[async_trait]
188impl<R: CommandRunner + 'static> ReleaseProvider for GitLabReleaseProvider<R> {
189 async fn create(&self, args: CreateReleaseArgs) -> Result<ReleaseData> {
190 let mut cmd_args: Vec<&str> = vec![
191 "release",
192 "create",
193 &args.tag_name,
194 "--repo",
195 &self.repo_target,
196 ];
197
198 if let Some(ref name) = args.name {
199 cmd_args.push("--name");
200 cmd_args.push(name);
201 }
202
203 if let Some(ref body) = args.body {
204 cmd_args.push("--notes");
205 cmd_args.push(body);
206 }
207
208 if let Some(ref commitish) = args.target_commitish {
213 cmd_args.push("--ref");
214 cmd_args.push(commitish);
215 }
216
217 debug!(
218 repo = %self.repo,
219 tag = %args.tag_name,
220 "spawning `glab release create`"
221 );
222
223 let output = self
224 .runner
225 .run("glab", &cmd_args)
226 .await
227 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
228
229 if !output.status.success() {
230 return Err(parse_glab_error(&output.stderr).into());
231 }
232
233 self.view(&args.tag_name).await
234 }
235
236 async fn list(&self, limit: Option<u32>) -> Result<Paged<ReleaseData>> {
237 let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
238 let repo_target = &self.repo_target;
239 let runner = &self.runner;
240 let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
243
244 debug!(repo = %self.repo, cap, "spawning `glab release list`");
245
246 fetch_capped(
247 FetchStrategy::Paged { per_page },
248 cap,
249 |page, per_page| async move {
250 let page_str = page.to_string();
251 let per_page_str = per_page.to_string();
252
253 let output = runner
254 .run(
255 "glab",
256 &[
257 "release",
258 "list",
259 "--repo",
260 repo_target,
261 "--output",
262 "json",
263 "--per-page",
264 &per_page_str,
265 "--page",
266 &page_str,
267 ],
268 )
269 .await
270 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
271
272 if !output.status.success() {
273 return Err(parse_glab_error(&output.stderr).into());
274 }
275
276 let api_responses: Vec<ReleaseApiResponse> =
277 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
278
279 Ok(api_responses.into_iter().map(ReleaseData::from).collect())
280 },
281 )
282 .await
283 }
284
285 async fn view(&self, tag_name: &str) -> Result<ReleaseData> {
286 debug!(repo = %self.repo, tag = %tag_name, "spawning `glab release view`");
287
288 let output = self
289 .runner
290 .run(
291 "glab",
292 &[
293 "release",
294 "view",
295 tag_name,
296 "--repo",
297 &self.repo_target,
298 "--output",
299 "json",
300 ],
301 )
302 .await
303 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
304
305 if !output.status.success() {
306 return Err(parse_glab_error(&output.stderr).into());
307 }
308
309 let api_response: ReleaseApiResponse =
310 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
311
312 Ok(api_response.into())
313 }
314
315 async fn edit(&self, tag_name: &str, args: CreateReleaseArgs) -> Result<ReleaseData> {
316 let mut cmd_args: Vec<&str> =
320 vec!["release", "create", tag_name, "--repo", &self.repo_target];
321
322 if let Some(ref name) = args.name {
323 cmd_args.push("--name");
324 cmd_args.push(name);
325 }
326
327 if let Some(ref body) = args.body {
328 cmd_args.push("--notes");
329 cmd_args.push(body);
330 }
331
332 if let Some(ref commitish) = args.target_commitish {
337 cmd_args.push("--ref");
338 cmd_args.push(commitish);
339 }
340
341 debug!(
342 repo = %self.repo,
343 tag = %tag_name,
344 "spawning `glab release create` (edit path)"
345 );
346
347 let output = self
348 .runner
349 .run("glab", &cmd_args)
350 .await
351 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
352
353 if !output.status.success() {
354 return Err(parse_glab_error(&output.stderr).into());
355 }
356
357 self.view(tag_name).await
358 }
359
360 async fn upload_asset(&self, tag_name: &str, file_path: &str, _asset_name: &str) -> Result<()> {
361 debug!(
362 repo = %self.repo,
363 tag = %tag_name,
364 file = %file_path,
365 "spawning `glab release upload`"
366 );
367
368 let output = self
369 .runner
370 .run(
371 "glab",
372 &[
373 "release",
374 "upload",
375 tag_name,
376 file_path,
377 "--repo",
378 &self.repo_target,
379 ],
380 )
381 .await
382 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
383
384 if !output.status.success() {
385 return Err(parse_glab_error(&output.stderr).into());
386 }
387
388 Ok(())
389 }
390
391 #[allow(
392 clippy::disallowed_methods,
393 reason = "Path parent extraction required for download"
394 )]
395 async fn download_asset(
396 &self,
397 tag_name: &str,
398 asset_name: &str,
399 dest_path: &str,
400 ) -> Result<()> {
401 debug!(
402 repo = %self.repo,
403 tag = %tag_name,
404 asset = %asset_name,
405 dest = %dest_path,
406 "spawning `glab release download`"
407 );
408
409 let dest = std::path::PathBuf::from(dest_path);
410 let parent = dest.parent().unwrap_or_else(|| std::path::Path::new("."));
411 let parent_str = parent.to_string_lossy();
412
413 let output = self
414 .runner
415 .run(
416 "glab",
417 &[
418 "release",
419 "download",
420 tag_name,
421 "--repo",
422 &self.repo_target,
423 "--pattern",
424 asset_name,
425 "--dir",
426 &parent_str,
427 ],
428 )
429 .await
430 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
431
432 if !output.status.success() {
433 return Err(parse_glab_error(&output.stderr).into());
434 }
435
436 let downloaded = parent.join(asset_name);
437 if downloaded != dest && downloaded.exists() {
438 std::fs::rename(&downloaded, &dest).map_err(|e| {
439 CoreError::Platform(format!(
440 "Failed to move downloaded asset to {dest_path}: {e}"
441 ))
442 })?;
443 }
444
445 Ok(())
446 }
447
448 async fn delete(&self, tag_name: &str) -> Result<()> {
449 debug!(repo = %self.repo, tag = %tag_name, "spawning `glab release delete`");
450
451 let output = self
452 .runner
453 .run(
454 "glab",
455 &[
456 "release",
457 "delete",
458 tag_name,
459 "--repo",
460 &self.repo_target,
461 "--yes",
462 ],
463 )
464 .await
465 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
466
467 if !output.status.success() {
468 return Err(parse_glab_error(&output.stderr).into());
469 }
470
471 Ok(())
472 }
473}
474
475#[cfg(test)]
476mod tests {
477 use super::*;
478 use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
479
480 #[test]
481 fn test_should_construct_gitlab_release_provider() {
482 let provider = GitLabReleaseProvider::new("gitlab-org/gitlab");
483 assert_eq!(provider.repo, "gitlab-org/gitlab");
484 }
485
486 #[test]
487 fn test_should_construct_gitlab_release_provider_from_string() {
488 let repo = String::from("gitlab-org/gitlab");
489 let provider = GitLabReleaseProvider::new(repo);
490 assert_eq!(provider.repo, "gitlab-org/gitlab");
491 }
492
493 #[tokio::test]
494 async fn test_should_use_explicit_repo_target_for_delete() {
495 let runner = MockCommandRunner::success("");
496 let provider = GitLabReleaseProvider::with_runner_and_repo_target(
497 "owner/repo",
498 "https://192.168.230.23/iproost/proxy/api-src.git",
499 runner.clone(),
500 );
501
502 let result = provider.delete("v1.0.0").await;
503
504 assert!(result.is_ok(), "expected Ok, got {result:?}");
505 assert_eq!(
506 runner.recorded_calls()[0].1,
507 vec![
508 "release",
509 "delete",
510 "v1.0.0",
511 "--repo",
512 "https://192.168.230.23/iproost/proxy/api-src.git",
513 "--yes",
514 ]
515 .into_iter()
516 .map(String::from)
517 .collect::<Vec<_>>()
518 );
519 }
520
521 #[test]
522 fn test_should_deserialize_release_api_response() {
523 let json = br#"{
524 "id": 1001,
525 "tag_name": "v1.0.0",
526 "name": "Version 1.0.0",
527 "description": "Initial stable release",
528 "draft": false,
529 "prerelease": false,
530 "author": {"username": "admin", "id": 1},
531 "created_at": "2026-01-01T00:00:00Z",
532 "released_at": "2026-01-15T12:00:00Z",
533 "url": "https://gitlab.com/gitlab-org/gitlab/-/releases/v1.0.0"
534 }"#;
535
536 let api: ReleaseApiResponse =
537 serde_json::from_slice(json).expect("valid ReleaseApiResponse");
538 let release: ReleaseData = api.into();
539
540 assert_eq!(release.id, 1001);
541 assert_eq!(release.tag_name, "v1.0.0");
542 assert_eq!(release.name.as_deref(), Some("Version 1.0.0"));
543 assert_eq!(release.body.as_deref(), Some("Initial stable release"));
544 assert!(!release.draft);
545 assert!(!release.prerelease);
546 assert_eq!(
547 release.author.as_ref().expect("author present").login,
548 "admin"
549 );
550 assert_eq!(
551 release.url,
552 "https://gitlab.com/gitlab-org/gitlab/-/releases/v1.0.0"
553 );
554 }
555
556 #[test]
557 fn test_should_deserialize_draft_release() {
558 let json = br#"{
559 "tag_name": "v0.1.0-draft",
560 "name": null,
561 "description": null,
562 "draft": true,
563 "prerelease": true,
564 "author": {"username": "dev", "id": 99},
565 "created_at": "2026-03-01T00:00:00Z",
566 "released_at": null,
567 "url": null
568 }"#;
569
570 let api: ReleaseApiResponse =
571 serde_json::from_slice(json).expect("valid ReleaseApiResponse");
572 let release: ReleaseData = api.into();
573 assert!(release.draft);
574 assert!(release.prerelease);
575 assert!(release.name.is_none());
576 assert!(release.published_at.is_none());
577 }
578
579 #[test]
580 fn test_should_deserialize_empty_release_list() {
581 let json = b"[]";
582 let list: Vec<ReleaseApiResponse> = serde_json::from_slice(json).expect("valid empty list");
583 assert!(list.is_empty());
584 }
585
586 #[test]
587 fn test_should_debug_format_provider() {
588 let provider = GitLabReleaseProvider::new("gitlab-org/gitlab");
589 let debug = format!("{provider:?}");
590 assert!(debug.contains("GitLabReleaseProvider"));
591 assert!(debug.contains("gitlab-org/gitlab"));
592 }
593
594 #[test]
595 fn test_should_clone_gitlab_release_provider() {
596 let original = GitLabReleaseProvider::new("owner/repo");
597 let cloned = original.clone();
598 assert_eq!(original.repo, cloned.repo);
599 }
600
601 fn sample_create_args() -> CreateReleaseArgs {
604 CreateReleaseArgs {
605 tag_name: "v1.0.0".to_string(),
606 name: Some("Version 1.0.0".to_string()),
607 body: Some("Release notes".to_string()),
608 draft: false,
609 prerelease: false,
610 target_commitish: None,
611 }
612 }
613
614 #[tokio::test]
615 async fn test_should_return_platform_error_when_glab_fails_for_create() {
616 let runner = MockCommandRunner::failure(r#"{"message": "Tag exists"}"#, 256);
617 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
618
619 let result = provider.create(sample_create_args()).await;
620
621 assert!(matches!(
622 result.unwrap_err(),
623 gitflow_core::CoreError::Cli(_)
624 ));
625 }
626
627 #[tokio::test]
628 async fn test_should_return_serialization_error_on_invalid_json_for_create() {
629 let runner = MockCommandRunner::success("not valid json");
630 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
631
632 let result = provider.create(sample_create_args()).await;
633
634 assert!(matches!(
635 result.unwrap_err(),
636 gitflow_core::CoreError::Serialization(_)
637 ));
638 }
639
640 #[tokio::test]
641 async fn test_should_return_platform_error_when_glab_fails_for_list() {
642 let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
643 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
644
645 let result = provider.list(None).await;
646
647 assert!(matches!(
648 result.unwrap_err(),
649 gitflow_core::CoreError::Cli(_)
650 ));
651 }
652
653 #[tokio::test]
654 async fn test_should_return_serialization_error_on_invalid_json_for_list() {
655 let runner = MockCommandRunner::success("invalid");
656 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
657
658 let result = provider.list(None).await;
659
660 assert!(matches!(
661 result.unwrap_err(),
662 gitflow_core::CoreError::Serialization(_)
663 ));
664 }
665
666 #[tokio::test]
667 async fn test_should_return_platform_error_when_glab_fails_for_view() {
668 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
669 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
670
671 let result = provider.view("v1.0.0").await;
672
673 assert!(matches!(
674 result.unwrap_err(),
675 gitflow_core::CoreError::Cli(_)
676 ));
677 }
678
679 #[tokio::test]
680 async fn test_should_return_serialization_error_on_invalid_json_for_view() {
681 let runner = MockCommandRunner::success("invalid");
682 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
683
684 let result = provider.view("v1.0.0").await;
685
686 assert!(matches!(
687 result.unwrap_err(),
688 gitflow_core::CoreError::Serialization(_)
689 ));
690 }
691
692 #[tokio::test]
693 async fn test_should_return_platform_error_when_glab_fails_for_edit() {
694 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
695 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
696
697 let result = provider.edit("v1.0.0", sample_create_args()).await;
698
699 assert!(matches!(
700 result.unwrap_err(),
701 gitflow_core::CoreError::Cli(_)
702 ));
703 }
704
705 #[tokio::test]
706 async fn test_should_return_serialization_error_on_invalid_json_for_edit() {
707 let runner = MockCommandRunner::success("invalid");
708 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
709
710 let result = provider.edit("v1.0.0", sample_create_args()).await;
711
712 assert!(matches!(
713 result.unwrap_err(),
714 gitflow_core::CoreError::Serialization(_)
715 ));
716 }
717
718 #[tokio::test]
719 async fn test_should_return_platform_error_when_glab_fails_for_delete() {
720 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
721 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
722
723 let result = provider.delete("v1.0.0").await;
724
725 assert!(matches!(
726 result.unwrap_err(),
727 gitflow_core::CoreError::Cli(_)
728 ));
729 }
730
731 #[tokio::test]
732 async fn test_should_return_platform_error_when_glab_fails_for_upload_asset() {
733 let runner = MockCommandRunner::failure(r#"{"message": "Upload failed"}"#, 256);
734 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
735
736 let result = provider
737 .upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
738 .await;
739
740 assert!(matches!(
741 result.unwrap_err(),
742 gitflow_core::CoreError::Cli(_)
743 ));
744 }
745
746 #[tokio::test]
747 async fn test_should_return_platform_error_when_glab_fails_for_download_asset() {
748 let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
749 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
750
751 let result = provider
752 .download_asset("v1.0.0", "asset.tar.gz", "/tmp/asset.tar.gz")
753 .await;
754
755 assert!(matches!(
756 result.unwrap_err(),
757 gitflow_core::CoreError::Cli(_)
758 ));
759 }
760
761 #[test]
764 fn test_should_convert_api_user_to_user_summary() {
765 let api_user = ApiUser {
766 username: "admin".into(),
767 id: 42,
768 };
769 let summary: UserSummary = (&api_user).into();
770 assert_eq!(summary.login, "admin");
771 assert_eq!(summary.id, "42");
772 }
773
774 #[test]
775 fn test_should_convert_api_user_with_zero_id() {
776 let api_user = ApiUser {
777 username: "bot".into(),
778 id: 0,
779 };
780 let summary: UserSummary = (&api_user).into();
781 assert_eq!(summary.login, "bot");
782 assert_eq!(summary.id, "0");
783 }
784
785 #[test]
788 fn test_should_convert_minimal_api_response_to_release_data() {
789 let api = ReleaseApiResponse {
790 tag_name: "v1.0.0".into(),
791 name: None,
792 description: None,
793 draft: false,
794 prerelease: false,
795 author: None,
796 created_at: None,
797 released_at: None,
798 url: None,
799 id: None,
800 };
801 let release: ReleaseData = api.into();
802 assert_eq!(release.tag_name, "v1.0.0");
803 assert_eq!(release.id, 0); assert!(release.name.is_none());
805 assert!(release.body.is_none());
806 assert!(!release.draft);
807 assert!(!release.prerelease);
808 assert!(release.author.is_none());
809 assert!(release.published_at.is_none());
810 assert_eq!(release.url, ""); assert!(
812 release.created_at.is_none(),
813 "missing created_at must stay None, not fall back to Utc::now()"
814 );
815 }
816
817 #[test]
818 fn test_should_preserve_all_fields_in_full_api_response_conversion() {
819 let api = ReleaseApiResponse {
820 tag_name: "v2.0.0".into(),
821 name: Some("Major Release".into()),
822 description: Some("Breaking changes".into()),
823 draft: true,
824 prerelease: false,
825 author: Some(ApiUser {
826 username: "dev".into(),
827 id: 7,
828 }),
829 created_at: Some("2026-06-01T00:00:00Z".parse().expect("valid datetime")),
830 released_at: Some("2026-06-15T12:00:00Z".parse().expect("valid datetime")),
831 url: Some("https://gitlab.com/ns/proj/-/releases/v2.0.0".into()),
832 id: Some(200),
833 };
834 let release: ReleaseData = api.into();
835 assert_eq!(release.id, 200);
836 assert_eq!(release.tag_name, "v2.0.0");
837 assert_eq!(release.name.as_deref(), Some("Major Release"));
838 assert_eq!(release.body.as_deref(), Some("Breaking changes"));
839 assert!(release.draft);
840 assert!(!release.prerelease);
841 assert_eq!(release.author.as_ref().expect("author").login, "dev");
842 assert_eq!(release.author.as_ref().expect("author").id, "7");
843 assert_eq!(release.url, "https://gitlab.com/ns/proj/-/releases/v2.0.0");
844 }
845
846 #[test]
849 fn test_should_create_provider_with_custom_runner() {
850 let runner = MockCommandRunner::success("");
851 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
852 assert_eq!(provider.repo, "owner/repo");
853 }
854
855 fn valid_release_api_json() -> &'static str {
858 r#"{
859 "id": 1,
860 "tag_name": "v1.0.0",
861 "name": "Version 1.0.0",
862 "description": "Release notes",
863 "draft": false,
864 "prerelease": false,
865 "author": {"username": "admin", "id": 1},
866 "created_at": "2026-01-01T00:00:00Z",
867 "released_at": "2026-01-01T00:00:00Z",
868 "url": "https://gitlab.com/owner/repo/-/releases/v1.0.0"
869 }"#
870 }
871
872 #[tokio::test]
873 async fn test_should_view_release_successfully() {
874 let runner = MockCommandRunner::success(valid_release_api_json());
875 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
876
877 let release = provider.view("v1.0.0").await.expect("view should succeed");
878 assert_eq!(release.tag_name, "v1.0.0");
879 assert_eq!(release.name.as_deref(), Some("Version 1.0.0"));
880 assert_eq!(release.id, 1);
881 }
882
883 #[tokio::test]
884 async fn test_should_list_releases_successfully() {
885 let json = format!("[{}]", valid_release_api_json());
886 let runner = MockCommandRunner::success(&json);
887 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
888
889 let paged = provider.list(None).await.expect("list should succeed");
890 assert_eq!(paged.items.len(), 1);
891 assert_eq!(paged.items[0].tag_name, "v1.0.0");
892 }
893
894 #[tokio::test]
895 async fn test_should_request_max_per_page_for_default_release_list() {
896 let runner = MockCommandRunner::success("[]");
897 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
898 provider.list(None).await.expect("list should succeed");
899 let recorded = &runner.recorded_calls()[0].1;
900 assert!(
901 recorded
902 .windows(2)
903 .any(|w| w[0] == "--per-page" && w[1] == "100"),
904 "实际 argv: {recorded:?}"
905 );
906 assert!(
907 recorded.windows(2).any(|w| w[0] == "--page" && w[1] == "1"),
908 "实际 argv: {recorded:?}"
909 );
910 }
911
912 #[tokio::test]
913 async fn test_should_produce_complete_argv_for_release_list_with_default_limit() {
914 let runner = MockCommandRunner::success("[]");
915 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
916 provider.list(None).await.expect("list should succeed");
917 let recorded = &runner.recorded_calls()[0];
918 assert_eq!(recorded.0, "glab");
919 assert_eq!(
920 recorded.1,
921 vec![
922 "release",
923 "list",
924 "--repo",
925 "owner/repo",
926 "--output",
927 "json",
928 "--per-page",
929 "100",
930 "--page",
931 "1",
932 ]
933 );
934 }
935
936 #[tokio::test]
937 async fn test_should_honour_user_release_limit_via_per_page() {
938 let runner = MockCommandRunner::success("[]");
939 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
940 provider.list(Some(10)).await.expect("list should succeed");
941 let recorded = &runner.recorded_calls()[0].1;
942 assert!(
943 recorded
944 .windows(2)
945 .any(|w| w[0] == "--per-page" && w[1] == "11"),
946 "cap+1=11 应作为 per_page 传给 glab,实际 argv: {recorded:?}"
947 );
948 }
949
950 #[tokio::test]
951 async fn test_should_create_release_successfully() {
952 let runner = MockCommandRunner::success(valid_release_api_json());
953 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
954
955 let release = provider
956 .create(sample_create_args())
957 .await
958 .expect("create should succeed");
959 assert_eq!(release.tag_name, "v1.0.0");
960 }
961
962 #[tokio::test]
963 async fn test_should_create_release_without_output_json_and_refetch_via_view() {
964 let runner = SequencedMockCommandRunner::from_results(&[
965 (true, ""), (
967 true,
968 r#"{"tag_name":"v1.0.0","name":"v1.0.0","description":"notes"}"#,
969 ),
970 ]);
971 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
972
973 let args = CreateReleaseArgs {
974 tag_name: "v1.0.0".to_string(),
975 name: None,
976 body: Some("notes".to_string()),
977 draft: false,
978 prerelease: false,
979 target_commitish: None,
980 };
981
982 let rel = provider.create(args).await.expect("should create");
983
984 assert_eq!(rel.tag_name, "v1.0.0");
985 }
986
987 #[tokio::test]
988 async fn test_should_not_pass_draft_or_prerelease_flags_on_release_create() {
989 let runner = SequencedMockCommandRunner::from_results(&[
992 (true, ""), (
994 true,
995 r#"{"tag_name":"v1.0.0","name":"Version 1.0.0","description":"notes"}"#,
996 ),
997 ]);
998 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
999
1000 let args = CreateReleaseArgs {
1001 tag_name: "v1.0.0".to_string(),
1002 name: Some("Version 1.0.0".to_string()),
1003 body: Some("notes".to_string()),
1004 draft: true,
1005 prerelease: true,
1006 target_commitish: Some("main".to_string()),
1007 };
1008
1009 provider.create(args).await.expect("should create");
1010
1011 assert_eq!(
1012 runner.recorded_calls()[0].1,
1013 [
1014 "release",
1015 "create",
1016 "v1.0.0",
1017 "--repo",
1018 "owner/repo",
1019 "--name",
1020 "Version 1.0.0",
1021 "--notes",
1022 "notes",
1023 "--ref",
1024 "main",
1025 ]
1026 .into_iter()
1027 .map(String::from)
1028 .collect::<Vec<_>>()
1029 );
1030 }
1031
1032 #[tokio::test]
1033 async fn test_should_edit_release_without_output_json_and_refetch_via_view() {
1034 let runner = SequencedMockCommandRunner::from_results(&[
1035 (true, ""), (
1037 true,
1038 r#"{"tag_name":"v1.0.0","name":"v1.0.0","description":"notes"}"#,
1039 ),
1040 ]);
1041 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
1042
1043 let args = CreateReleaseArgs {
1044 tag_name: "v1.0.0".to_string(),
1045 name: None,
1046 body: Some("notes".to_string()),
1047 draft: false,
1048 prerelease: false,
1049 target_commitish: None,
1050 };
1051
1052 let rel = provider.edit("v1.0.0", args).await.expect("should edit");
1053
1054 assert_eq!(rel.tag_name, "v1.0.0");
1055 }
1056
1057 #[tokio::test]
1058 async fn test_should_edit_release_via_release_create() {
1059 let runner = SequencedMockCommandRunner::from_results(&[
1063 (true, ""), (
1065 true,
1066 r#"{"tag_name":"v1.0.0","name":"Version 1.0.0","description":"notes"}"#,
1067 ),
1068 ]);
1069 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner.clone());
1070
1071 let args = CreateReleaseArgs {
1072 tag_name: "v1.0.0".to_string(),
1073 name: Some("Version 1.0.0".to_string()),
1074 body: Some("notes".to_string()),
1075 draft: true,
1076 prerelease: true,
1077 target_commitish: Some("main".to_string()),
1078 };
1079
1080 provider.edit("v1.0.0", args).await.expect("should edit");
1081
1082 assert_eq!(
1083 runner.recorded_calls()[0].1,
1084 [
1085 "release",
1086 "create",
1087 "v1.0.0",
1088 "--repo",
1089 "owner/repo",
1090 "--name",
1091 "Version 1.0.0",
1092 "--notes",
1093 "notes",
1094 "--ref",
1095 "main",
1096 ]
1097 .into_iter()
1098 .map(String::from)
1099 .collect::<Vec<_>>()
1100 );
1101 }
1102
1103 #[tokio::test]
1104 async fn test_should_edit_release_successfully() {
1105 let runner = MockCommandRunner::success(valid_release_api_json());
1106 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
1107
1108 let release = provider
1109 .edit("v1.0.0", sample_create_args())
1110 .await
1111 .expect("edit should succeed");
1112 assert_eq!(release.tag_name, "v1.0.0");
1113 }
1114
1115 #[tokio::test]
1116 async fn test_should_delete_release_successfully() {
1117 let runner = MockCommandRunner::success("");
1118 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
1119
1120 assert!(provider.delete("v1.0.0").await.is_ok());
1121 }
1122
1123 #[tokio::test]
1124 async fn test_should_upload_asset_successfully() {
1125 let runner = MockCommandRunner::success("");
1126 let provider = GitLabReleaseProvider::with_runner("owner/repo", runner);
1127
1128 assert!(
1129 provider
1130 .upload_asset("v1.0.0", "/tmp/asset.tar.gz", "asset.tar.gz")
1131 .await
1132 .is_ok()
1133 );
1134 }
1135}