1use async_trait::async_trait;
7use chrono::{DateTime, Utc};
8use gitflow_core::{
9 CoreError, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, fetch_capped,
10 label::{
11 CreateLabelArgs, CreateMilestoneArgs, LabelData, LabelProvider, MilestoneData,
12 MilestoneProvider,
13 },
14 types::State,
15};
16use serde::Deserialize;
17use tracing::debug;
18
19use crate::{
20 GITLAB_MAX_PER_PAGE,
21 error::parse_glab_error,
22 runner::{CommandRunner, RealCommandRunner},
23};
24
25fn resolve_after_mutation<T>(
37 paged: Paged<T>,
38 predicate: impl Fn(&T) -> bool,
39 truncated_msg: &str,
40 not_found_msg: String,
41) -> Result<T> {
42 if paged.truncated {
43 return Err(CoreError::Platform(truncated_msg.to_string()));
44 }
45 paged
46 .items
47 .into_iter()
48 .find(predicate)
49 .ok_or(CoreError::Platform(not_found_msg))
50}
51
52fn normalize_label_color(color: &str) -> String {
57 let trimmed = color.trim();
58 if trimmed.starts_with('#') {
59 trimmed.to_string()
60 } else {
61 format!("#{trimmed}")
62 }
63}
64
65#[derive(Debug, Clone)]
75pub struct GitLabLabelProvider<R: CommandRunner = RealCommandRunner> {
76 repo: String,
78 repo_target: String,
82 runner: R,
84}
85
86impl GitLabLabelProvider<RealCommandRunner> {
87 #[must_use]
91 pub fn new(repo: impl Into<String>) -> GitLabLabelProvider<RealCommandRunner> {
92 let repo = repo.into();
93 GitLabLabelProvider {
94 repo_target: repo.clone(),
95 repo,
96 runner: RealCommandRunner,
97 }
98 }
99
100 #[must_use]
104 pub fn with_session(session: &gitflow_core::Session) -> Self {
105 let repo = session.repo.clone();
106 Self {
107 repo_target: repo.clone(),
108 repo,
109 runner: RealCommandRunner,
110 }
111 }
112
113 #[must_use]
115 pub fn with_remote_url(repo: impl Into<String>, remote_url: impl Into<String>) -> Self {
116 Self {
117 repo: repo.into(),
118 repo_target: remote_url.into(),
119 runner: RealCommandRunner,
120 }
121 }
122}
123
124impl<R: CommandRunner> GitLabLabelProvider<R> {
125 #[must_use]
130 pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
131 let repo = repo.into();
132 Self {
133 repo_target: repo.clone(),
134 repo,
135 runner,
136 }
137 }
138
139 #[must_use]
143 pub fn with_runner_and_repo_target(
144 repo: impl Into<String>,
145 repo_target: impl Into<String>,
146 runner: R,
147 ) -> Self {
148 Self {
149 repo: repo.into(),
150 repo_target: repo_target.into(),
151 runner,
152 }
153 }
154}
155
156async fn fetch_label_page<R: CommandRunner>(
166 runner: &R,
167 repo_target: &str,
168 page: u32,
169 per_page: u32,
170) -> Result<Vec<LabelApiResponse>> {
171 let page_str = page.to_string();
172 let per_page_str = per_page.to_string();
173
174 let output = runner
175 .run(
176 "glab",
177 &[
178 "label",
179 "list",
180 "--repo",
181 repo_target,
182 "--output",
183 "json",
184 "--per-page",
185 &per_page_str,
186 "--page",
187 &page_str,
188 ],
189 )
190 .await
191 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab label list: {e}")))?;
192
193 if !output.status.success() {
194 return Err(parse_glab_error(&output.stderr).into());
195 }
196
197 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)
198}
199
200#[derive(Debug, Clone, Deserialize)]
202struct LabelApiResponse {
203 #[serde(default)]
204 id: u64,
205 #[serde(default)]
206 name: String,
207 #[serde(default)]
208 color: Option<String>,
209 #[serde(default)]
210 description: Option<String>,
211}
212
213impl From<LabelApiResponse> for LabelData {
214 fn from(api: LabelApiResponse) -> Self {
215 Self {
216 name: api.name,
217 color: api.color,
218 description: api.description,
219 }
220 }
221}
222
223#[async_trait]
224impl<R: CommandRunner + 'static> LabelProvider for GitLabLabelProvider<R> {
225 async fn create(&self, args: CreateLabelArgs) -> Result<LabelData> {
226 let color = normalize_label_color(&args.color);
227
228 debug!(
229 repo = %self.repo,
230 name = %args.name,
231 color = %color,
232 "spawning `glab label create`"
233 );
234
235 let mut cmd_args: Vec<&str> = vec![
236 "label",
237 "create",
238 "--name",
239 &args.name,
240 "--color",
241 &color,
242 "--repo",
243 &self.repo_target,
244 ];
245
246 if let Some(ref desc) = args.description {
247 cmd_args.push("--description");
248 cmd_args.push(desc);
249 }
250
251 let output =
252 self.runner.run("glab", &cmd_args).await.map_err(|e| {
253 CoreError::Platform(format!("Failed to spawn glab label create: {e}"))
254 })?;
255
256 if !output.status.success() {
257 return Err(parse_glab_error(&output.stderr).into());
258 }
259
260 let paged = self.list(None).await?;
261 resolve_after_mutation(
262 paged,
263 |l| l.name == args.name,
264 "label lookup truncated after create; too many labels to confirm the write landed",
265 format!("Label '{}' not found after create", args.name),
266 )
267 }
268
269 async fn list(&self, limit: Option<u32>) -> Result<Paged<LabelData>> {
270 let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
271 let repo_target = &self.repo_target;
272 let runner = &self.runner;
273 let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
274
275 debug!(repo = %self.repo, cap, "spawning `glab label list`");
276
277 fetch_capped(
278 FetchStrategy::Paged { per_page },
279 cap,
280 |page, per_page| async move {
281 let api_responses = fetch_label_page(runner, repo_target, page, per_page).await?;
282 Ok(api_responses.into_iter().map(LabelData::from).collect())
283 },
284 )
285 .await
286 }
287
288 async fn edit(&self, name: &str, args: CreateLabelArgs) -> Result<LabelData> {
289 let cap = DEFAULT_LIST_LIMIT;
294 let repo_target = &self.repo_target;
295 let runner = &self.runner;
296 let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
297
298 let paged =
299 fetch_capped(
300 FetchStrategy::Paged { per_page },
301 cap,
302 |page, per_page| async move {
303 fetch_label_page(runner, repo_target, page, per_page).await
304 },
305 )
306 .await?;
307
308 if paged.truncated {
309 return Err(CoreError::Platform(
310 "label lookup truncated; too many labels to resolve by name".into(),
311 ));
312 }
313
314 let label_id = paged
315 .items
316 .iter()
317 .find(|l| l.name == name)
318 .map(|l| l.id)
319 .ok_or_else(|| CoreError::Platform(format!("Label '{name}' not found")))?;
320
321 debug!(
322 repo = %self.repo,
323 name,
324 label_id,
325 new_name = %args.name,
326 "spawning `glab label edit --label-id`"
327 );
328
329 let id_str = label_id.to_string();
330 let color = normalize_label_color(&args.color);
331 let mut cmd_args: Vec<&str> = vec![
332 "label",
333 "edit",
334 "--label-id",
335 &id_str,
336 "--repo",
337 &self.repo_target,
338 "--new-name",
339 &args.name,
340 "--color",
341 &color,
342 ];
343 if let Some(ref desc) = args.description {
344 cmd_args.push("--description");
345 cmd_args.push(desc);
346 }
347 let output =
348 self.runner.run("glab", &cmd_args).await.map_err(|e| {
349 CoreError::Platform(format!("Failed to spawn glab label edit: {e}"))
350 })?;
351 if !output.status.success() {
352 return Err(parse_glab_error(&output.stderr).into());
353 }
354
355 let paged = self.list(None).await?;
356 resolve_after_mutation(
357 paged,
358 |l| l.name == args.name,
359 "label lookup truncated after edit; too many labels to confirm the write landed",
360 format!("Label '{}' not found after edit", args.name),
361 )
362 }
363
364 async fn delete(&self, name: &str) -> Result<()> {
365 debug!(repo = %self.repo, name, "spawning `glab label delete`");
366
367 let output = self
368 .runner
369 .run(
370 "glab",
371 &["label", "delete", name, "--repo", &self.repo_target],
372 )
373 .await
374 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab label delete: {e}")))?;
375
376 if !output.status.success() {
377 return Err(parse_glab_error(&output.stderr).into());
378 }
379
380 Ok(())
381 }
382}
383
384#[derive(Debug, Clone)]
396pub struct GitLabMilestoneProvider<R: CommandRunner = RealCommandRunner> {
397 repo: String,
399 project_target: String,
403 runner: R,
405}
406
407impl GitLabMilestoneProvider<RealCommandRunner> {
408 #[must_use]
412 pub fn new(repo: impl Into<String>) -> GitLabMilestoneProvider<RealCommandRunner> {
413 let repo = repo.into();
414 GitLabMilestoneProvider {
415 project_target: repo.clone(),
416 repo,
417 runner: RealCommandRunner,
418 }
419 }
420
421 #[must_use]
425 pub fn with_session(session: &gitflow_core::Session) -> Self {
426 let repo = session.repo.clone();
427 Self {
428 project_target: repo.clone(),
429 repo,
430 runner: RealCommandRunner,
431 }
432 }
433}
434
435impl<R: CommandRunner> GitLabMilestoneProvider<R> {
436 #[must_use]
441 pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
442 let repo = repo.into();
443 Self {
444 project_target: repo.clone(),
445 repo,
446 runner,
447 }
448 }
449
450 #[must_use]
454 pub fn with_runner_and_project_target(
455 repo: impl Into<String>,
456 project_target: impl Into<String>,
457 runner: R,
458 ) -> Self {
459 Self {
460 repo: repo.into(),
461 project_target: project_target.into(),
462 runner,
463 }
464 }
465}
466
467#[derive(Debug, Clone, Deserialize)]
469#[allow(
470 dead_code,
471 reason = "Used for deserialization; not all fields are read"
472)]
473struct MilestoneApiResponse {
474 id: u64,
475 #[serde(default)]
476 iid: Option<u64>,
477 title: String,
478 #[serde(default)]
479 description: Option<String>,
480 state: String,
481 #[serde(default)]
482 due_date: Option<String>,
483 #[serde(default)]
484 start_date: Option<String>,
485 #[serde(default)]
486 created_at: Option<DateTime<Utc>>,
487 #[serde(default)]
488 updated_at: Option<DateTime<Utc>>,
489}
490
491impl From<MilestoneApiResponse> for MilestoneData {
492 fn from(api: MilestoneApiResponse) -> Self {
493 let state = if api.state == "closed" {
494 State::Closed
495 } else {
496 State::Open
497 };
498 let due_on = api.due_date.and_then(|s| {
499 if let Ok(dt) = DateTime::parse_from_rfc3339(&s) {
501 return Some(dt.with_timezone(&Utc));
502 }
503 chrono::NaiveDate::parse_from_str(&s, "%Y-%m-%d")
504 .ok()
505 .map(|d| {
506 let naive_dt = d
507 .and_hms_opt(0, 0, 0)
508 .unwrap_or_else(|| d.and_hms_opt(12, 0, 0).unwrap_or_default());
509 DateTime::<Utc>::from_naive_utc_and_offset(naive_dt, Utc)
510 })
511 });
512
513 Self {
514 number: api.iid.unwrap_or(api.id),
515 title: api.title,
516 description: api.description,
517 state,
518 due_on,
519 closed_issues: 0,
520 open_issues: 0,
521 }
522 }
523}
524
525async fn fetch_milestone_page<R: CommandRunner>(
533 runner: &R,
534 project_target: &str,
535 page: u32,
536 per_page: u32,
537) -> Result<Vec<MilestoneApiResponse>> {
538 let page_str = page.to_string();
539 let per_page_str = per_page.to_string();
540
541 let output = runner
542 .run(
543 "glab",
544 &[
545 "milestone",
546 "list",
547 "--project",
548 project_target,
549 "--output",
550 "json",
551 "--per-page",
552 &per_page_str,
553 "--page",
554 &page_str,
555 ],
556 )
557 .await
558 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab milestone list: {e}")))?;
559
560 if !output.status.success() {
561 return Err(parse_glab_error(&output.stderr).into());
562 }
563
564 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)
565}
566
567#[async_trait]
568impl<R: CommandRunner + 'static> MilestoneProvider for GitLabMilestoneProvider<R> {
569 async fn create(&self, args: CreateMilestoneArgs) -> Result<MilestoneData> {
570 debug!(repo = %self.repo, title = %args.title, "spawning `glab milestone create`");
571
572 let due_arg = args
573 .due_on
574 .as_ref()
575 .map(|due| due.format("%Y-%m-%d").to_string());
576
577 let mut cmd_args: Vec<&str> = vec![
578 "milestone",
579 "create",
580 "--title",
581 &args.title,
582 "--project",
583 &self.project_target,
584 ];
585
586 if let Some(ref desc) = args.description {
587 cmd_args.push("--description");
588 cmd_args.push(desc);
589 }
590
591 if let Some(ref due_str) = due_arg {
592 cmd_args.push("--due-date");
593 cmd_args.push(due_str);
594 }
595
596 let output = self.runner.run("glab", &cmd_args).await.map_err(|e| {
597 CoreError::Platform(format!("Failed to spawn glab milestone create: {e}"))
598 })?;
599
600 if !output.status.success() {
601 return Err(parse_glab_error(&output.stderr).into());
602 }
603
604 let paged = self.list(None).await?;
605 resolve_after_mutation(
606 paged,
607 |m| m.title == args.title,
608 "milestone lookup truncated after create; too many milestones to confirm the write \
609 landed",
610 "Milestone not found after create".into(),
611 )
612 }
613
614 async fn list(&self, limit: Option<u32>) -> Result<Paged<MilestoneData>> {
615 let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
616 let project_target = &self.project_target;
617 let runner = &self.runner;
618 let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
619
620 debug!(repo = %self.repo, cap, "spawning `glab milestone list`");
621
622 fetch_capped(
623 FetchStrategy::Paged { per_page },
624 cap,
625 |page, per_page| async move {
626 let api_responses =
627 fetch_milestone_page(runner, project_target, page, per_page).await?;
628 Ok(api_responses.into_iter().map(MilestoneData::from).collect())
629 },
630 )
631 .await
632 }
633
634 async fn edit(&self, number: u64, args: CreateMilestoneArgs) -> Result<MilestoneData> {
635 debug!(repo = %self.repo, number, "spawning `glab milestone edit`");
636
637 let due_arg = args
638 .due_on
639 .as_ref()
640 .map(|due| due.format("%Y-%m-%d").to_string());
641 let number_str = number.to_string();
642
643 let mut cmd_args: Vec<&str> = vec![
644 "milestone",
645 "edit",
646 &number_str,
647 "--project",
648 &self.project_target,
649 "--title",
650 &args.title,
651 ];
652
653 if let Some(ref desc) = args.description {
654 cmd_args.push("--description");
655 cmd_args.push(desc);
656 }
657
658 if let Some(ref due_str) = due_arg {
659 cmd_args.push("--due-date");
660 cmd_args.push(due_str);
661 }
662
663 let output = self.runner.run("glab", &cmd_args).await.map_err(|e| {
664 CoreError::Platform(format!("Failed to spawn glab milestone edit: {e}"))
665 })?;
666
667 if !output.status.success() {
668 return Err(parse_glab_error(&output.stderr).into());
669 }
670
671 let paged = self.list(None).await?;
672 resolve_after_mutation(
673 paged,
674 |m| m.title == args.title || m.number == number,
675 "milestone lookup truncated after edit; too many milestones to confirm the write \
676 landed",
677 "Milestone not found after edit".into(),
678 )
679 }
680
681 async fn close(&self, number: u64) -> Result<MilestoneData> {
682 debug!(
683 repo = %self.repo,
684 number,
685 "spawning `glab milestone edit --state close`"
686 );
687
688 let number_str = number.to_string();
689 let output = self
690 .runner
691 .run(
692 "glab",
693 &[
694 "milestone",
695 "edit",
696 &number_str,
697 "--state",
698 "close",
699 "--project",
700 &self.project_target,
701 ],
702 )
703 .await
704 .map_err(|e| {
705 CoreError::Platform(format!("Failed to spawn glab milestone edit: {e}"))
706 })?;
707
708 if !output.status.success() {
709 return Err(parse_glab_error(&output.stderr).into());
710 }
711
712 let paged = self.list(None).await?;
713 resolve_after_mutation(
714 paged,
715 |m| m.number == number,
716 "milestone lookup truncated after close; too many milestones to confirm the write \
717 landed",
718 "Milestone not found after close".into(),
719 )
720 }
721
722 async fn reopen(&self, number: u64) -> Result<MilestoneData> {
723 debug!(
724 repo = %self.repo,
725 number,
726 "spawning `glab milestone edit --state activate`"
727 );
728
729 let number_str = number.to_string();
730 let output = self
731 .runner
732 .run(
733 "glab",
734 &[
735 "milestone",
736 "edit",
737 &number_str,
738 "--state",
739 "activate",
740 "--project",
741 &self.project_target,
742 ],
743 )
744 .await
745 .map_err(|e| {
746 CoreError::Platform(format!("Failed to spawn glab milestone edit: {e}"))
747 })?;
748
749 if !output.status.success() {
750 return Err(parse_glab_error(&output.stderr).into());
751 }
752
753 let paged = self.list(None).await?;
754 resolve_after_mutation(
755 paged,
756 |m| m.number == number,
757 "milestone lookup truncated after reopen; too many milestones to confirm the write \
758 landed",
759 "Milestone not found after reopen".into(),
760 )
761 }
762}
763
764#[cfg(test)]
765mod tests {
766 use super::*;
767 use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
768
769 #[test]
772 fn test_should_construct_gitlab_label_provider() {
773 let provider = GitLabLabelProvider::new("gitlab-org/gitlab");
774 assert_eq!(provider.repo, "gitlab-org/gitlab");
775 }
776
777 #[test]
778 fn test_should_construct_gitlab_label_provider_from_string() {
779 let repo = String::from("gitlab-org/gitlab");
780 let provider = GitLabLabelProvider::new(repo);
781 assert_eq!(provider.repo, "gitlab-org/gitlab");
782 }
783
784 #[tokio::test]
785 async fn test_should_use_explicit_repo_target_for_delete() {
786 let runner = MockCommandRunner::success("");
787 let provider = GitLabLabelProvider::with_runner_and_repo_target(
788 "owner/repo",
789 "https://192.168.230.23/iproost/proxy/api-src.git",
790 runner.clone(),
791 );
792
793 let result = provider.delete("bug").await;
794
795 assert!(result.is_ok(), "expected Ok, got {result:?}");
796 assert_eq!(
797 runner.recorded_calls()[0].1,
798 vec![
799 "label",
800 "delete",
801 "bug",
802 "--repo",
803 "https://192.168.230.23/iproost/proxy/api-src.git",
804 ]
805 .into_iter()
806 .map(String::from)
807 .collect::<Vec<_>>()
808 );
809 }
810
811 #[test]
812 fn test_should_debug_format_label_provider() {
813 let provider = GitLabLabelProvider::new("owner/repo");
814 let debug = format!("{provider:?}");
815 assert!(debug.contains("GitLabLabelProvider"));
816 assert!(debug.contains("owner/repo"));
817 }
818
819 #[test]
820 fn test_should_clone_gitlab_label_provider() {
821 let original = GitLabLabelProvider::new("owner/repo");
822 let cloned = original.clone();
823 assert_eq!(original.repo, cloned.repo);
824 }
825
826 #[test]
829 fn test_should_deserialize_label_api_response() {
830 let json = br##"{
831 "name": "bug",
832 "color": "#d73a4a",
833 "description": "Something isn't working"
834 }"##;
835
836 let api: LabelApiResponse = serde_json::from_slice(json).expect("valid LabelApiResponse");
837 let label: LabelData = api.into();
838 assert_eq!(label.name, "bug");
839 assert_eq!(label.color.as_deref(), Some("#d73a4a"));
840 assert_eq!(
841 label.description.as_deref(),
842 Some("Something isn't working")
843 );
844 }
845
846 #[test]
847 fn test_should_deserialize_label_list() {
848 let json = br##"[
849 {"name": "bug", "color": "#d73a4a", "description": "Bug"},
850 {"name": "feature", "color": "#0075ca", "description": null}
851 ]"##;
852
853 let list: Vec<LabelApiResponse> = serde_json::from_slice(json).expect("valid label list");
854 assert_eq!(list.len(), 2);
855 assert_eq!(list[0].name, "bug");
856 assert_eq!(list[1].name, "feature");
857 }
858
859 #[test]
860 fn test_should_deserialize_empty_label_list() {
861 let json = b"[]";
862 let list: Vec<LabelApiResponse> = serde_json::from_slice(json).expect("valid empty list");
863 assert!(list.is_empty());
864 }
865
866 #[test]
869 fn test_should_construct_gitlab_milestone_provider() {
870 let provider = GitLabMilestoneProvider::new("gitlab-org/gitlab");
871 assert_eq!(provider.repo, "gitlab-org/gitlab");
872 }
873
874 #[tokio::test]
875 async fn test_should_use_explicit_project_target_for_close() {
876 let runner = SequencedMockCommandRunner::from_results(&[
877 (true, ""),
878 (
879 true,
880 r#"[{"id":1,"iid":3,"title":"v1.0","description":null,"state":"closed","due_date":null,"created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-01T00:00:00Z"}]"#,
881 ),
882 ]);
883 let provider = GitLabMilestoneProvider::with_runner_and_project_target(
884 "owner/repo",
885 "https://192.168.230.23/iproost/proxy/api-src.git",
886 runner.clone(),
887 );
888
889 let ms = provider.close(3).await.expect("close should succeed");
890
891 assert_eq!(ms.number, 3);
892 assert_eq!(
893 runner.recorded_calls()[0].1,
894 vec![
895 "milestone",
896 "edit",
897 "3",
898 "--state",
899 "close",
900 "--project",
901 "https://192.168.230.23/iproost/proxy/api-src.git",
902 ]
903 .into_iter()
904 .map(String::from)
905 .collect::<Vec<_>>()
906 );
907 }
908
909 #[test]
910 fn test_should_debug_format_milestone_provider() {
911 let provider = GitLabMilestoneProvider::new("owner/repo");
912 let debug = format!("{provider:?}");
913 assert!(debug.contains("GitLabMilestoneProvider"));
914 assert!(debug.contains("owner/repo"));
915 }
916
917 #[test]
918 fn test_should_clone_gitlab_milestone_provider() {
919 let original = GitLabMilestoneProvider::new("owner/repo");
920 let cloned = original.clone();
921 assert_eq!(original.repo, cloned.repo);
922 }
923
924 #[tokio::test]
927 async fn test_should_fail_when_label_create_glab_fails() {
928 let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
929 let provider = GitLabLabelProvider::with_runner("owner/repo", runner);
930 let args = CreateLabelArgs {
931 name: "bug".to_string(),
932 color: "#d73a4a".to_string(),
933 description: None,
934 };
935 let result = provider.create(args).await;
936 assert!(result.is_err());
937 }
938
939 #[tokio::test]
940 async fn test_should_fail_when_milestone_create_glab_fails() {
941 let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
942 let provider = GitLabMilestoneProvider::with_runner("owner/repo", runner);
943 let args = CreateMilestoneArgs {
944 title: "v1.0".to_string(),
945 description: None,
946 due_on: None,
947 };
948 let result = provider.create(args).await;
949 assert!(result.is_err());
950 }
951
952 #[tokio::test]
953 async fn test_should_create_label_without_output_json_and_refetch_via_list() {
954 let runner = SequencedMockCommandRunner::from_results(&[
955 (true, ""), (true, r##"[{"id":101,"name":"bug","color":"#d73a4a"}]"##), ]);
958 let provider = GitLabLabelProvider::with_runner("owner/repo", runner);
959
960 let args = CreateLabelArgs {
961 name: "bug".to_string(),
962 color: "#d73a4a".to_string(),
963 description: None,
964 };
965
966 let label = provider.create(args).await.expect("should create");
967
968 assert_eq!(label.name, "bug");
969 }
970
971 #[tokio::test]
972 async fn test_should_normalize_color_without_hash_prefix() {
973 let runner = SequencedMockCommandRunner::from_results(&[
974 (true, ""),
975 (true, r##"[{"id":101,"name":"bug","color":"#d73a4a"}]"##),
976 ]);
977 let provider = GitLabLabelProvider::with_runner("owner/repo", runner.clone());
978
979 let args = CreateLabelArgs {
980 name: "bug".to_string(),
981 color: "d73a4a".to_string(), description: None,
983 };
984
985 provider.create(args).await.expect("should create");
986
987 let calls = runner.recorded_calls();
988 let create_call = &calls[0];
989 let color_idx = create_call
990 .1
991 .iter()
992 .position(|a| a == "--color")
993 .expect("--color flag present");
994 assert_eq!(create_call.1[color_idx + 1], "#d73a4a");
995 }
996
997 #[tokio::test]
998 async fn test_should_pass_through_color_that_already_has_hash_prefix() {
999 let runner = SequencedMockCommandRunner::from_results(&[
1000 (true, ""),
1001 (true, r##"[{"id":101,"name":"bug","color":"#d73a4a"}]"##),
1002 ]);
1003 let provider = GitLabLabelProvider::with_runner("owner/repo", runner.clone());
1004
1005 let args = CreateLabelArgs {
1006 name: "bug".to_string(),
1007 color: "#d73a4a".to_string(), description: None,
1009 };
1010
1011 provider.create(args).await.expect("should create");
1012
1013 let calls = runner.recorded_calls();
1014 let create_call = &calls[0];
1015 let color_idx = create_call
1016 .1
1017 .iter()
1018 .position(|a| a == "--color")
1019 .expect("--color flag present");
1020 assert_eq!(create_call.1[color_idx + 1], "#d73a4a");
1021 }
1022
1023 #[tokio::test]
1024 async fn test_should_edit_label_with_label_id() {
1025 let list_json = r##"[{"id":101,"name":"bug","color":"#d73a4a"}]"##;
1026 let edited_json = r##"[{"id":101,"name":"critical","color":"#d73a4a"}]"##;
1027 let runner = SequencedMockCommandRunner::from_results(&[
1028 (true, list_json), (true, edited_json), (true, edited_json), ]);
1032 let provider = GitLabLabelProvider::with_runner("owner/repo", runner);
1033
1034 let args = CreateLabelArgs {
1035 name: "critical".to_string(),
1036 color: "#d73a4a".to_string(),
1037 description: None,
1038 };
1039
1040 let label = provider.edit("bug", args).await.expect("should edit");
1041
1042 assert_eq!(label.name, "critical");
1043 }
1044
1045 #[tokio::test]
1046 async fn test_should_normalize_color_without_hash_prefix_on_edit() {
1047 let list_json = r##"[{"id":101,"name":"bug","color":"#d73a4a"}]"##;
1048 let edited_json = r##"[{"id":101,"name":"bug","color":"#d73a4a"}]"##;
1049 let runner = SequencedMockCommandRunner::from_results(&[
1050 (true, list_json),
1051 (true, edited_json),
1052 (true, edited_json),
1053 ]);
1054 let provider = GitLabLabelProvider::with_runner("owner/repo", runner.clone());
1055
1056 let args = CreateLabelArgs {
1057 name: "bug".to_string(),
1058 color: "d73a4a".to_string(), description: None,
1060 };
1061
1062 provider.edit("bug", args).await.expect("should edit");
1063
1064 let calls = runner.recorded_calls();
1065 let edit_call = &calls[1];
1066 let color_idx = edit_call
1067 .1
1068 .iter()
1069 .position(|a| a == "--color")
1070 .expect("--color flag present");
1071 assert_eq!(edit_call.1[color_idx + 1], "#d73a4a");
1072 }
1073
1074 #[tokio::test]
1075 async fn test_should_trim_whitespace_before_normalizing_color() {
1076 let runner = SequencedMockCommandRunner::from_results(&[
1077 (true, ""),
1078 (true, r##"[{"id":101,"name":"bug","color":"#d73a4a"}]"##),
1079 ]);
1080 let provider = GitLabLabelProvider::with_runner("owner/repo", runner.clone());
1081
1082 let args = CreateLabelArgs {
1083 name: "bug".to_string(),
1084 color: " d73a4a ".to_string(),
1085 description: None,
1086 };
1087
1088 provider.create(args).await.expect("should create");
1089
1090 let calls = runner.recorded_calls();
1091 let color_idx = calls[0]
1092 .1
1093 .iter()
1094 .position(|a| a == "--color")
1095 .expect("--color flag present");
1096 assert_eq!(calls[0].1[color_idx + 1], "#d73a4a");
1097 }
1098
1099 #[tokio::test]
1100 async fn test_should_delete_label_without_yes_flag() {
1101 let runner = MockCommandRunner::success("");
1102 let provider = GitLabLabelProvider::with_runner("owner/repo", runner.clone());
1103
1104 provider.delete("bug").await.expect("should delete");
1105
1106 assert_eq!(
1107 runner.recorded_calls()[0].1,
1108 vec!["label", "delete", "bug", "--repo", "owner/repo"]
1109 .into_iter()
1110 .map(String::from)
1111 .collect::<Vec<_>>()
1112 );
1113 }
1114
1115 #[tokio::test]
1116 async fn test_should_create_milestone_without_output_json_and_refetch() {
1117 let runner = SequencedMockCommandRunner::from_results(&[
1118 (true, ""), (
1120 true,
1121 r#"[{"id":1,"iid":3,"title":"v1.0","description":null,"state":"active","due_date":null,"created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-01T00:00:00Z"}]"#,
1122 ),
1123 ]);
1124 let provider = GitLabMilestoneProvider::with_runner("owner/repo", runner);
1125
1126 let args = CreateMilestoneArgs {
1127 title: "v1.0".to_string(),
1128 description: None,
1129 due_on: None,
1130 };
1131
1132 let ms = provider.create(args).await.expect("should create");
1133
1134 assert_eq!(ms.number, 3);
1135 assert_eq!(ms.title, "v1.0");
1136 }
1137
1138 #[tokio::test]
1139 async fn test_should_edit_milestone_without_output_json_and_refetch() {
1140 let runner = SequencedMockCommandRunner::from_results(&[
1141 (true, ""), (
1143 true,
1144 r#"[{"id":1,"iid":3,"title":"v1.1","description":null,"state":"active","due_date":null,"created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-01T00:00:00Z"}]"#,
1145 ),
1146 ]);
1147 let provider = GitLabMilestoneProvider::with_runner("owner/repo", runner);
1148
1149 let args = CreateMilestoneArgs {
1150 title: "v1.1".to_string(),
1151 description: None,
1152 due_on: None,
1153 };
1154
1155 let ms = provider.edit(3, args).await.expect("should edit");
1156
1157 assert_eq!(ms.title, "v1.1");
1158 }
1159
1160 #[tokio::test]
1161 async fn test_should_close_milestone_without_output_json_and_refetch() {
1162 let runner = SequencedMockCommandRunner::from_results(&[
1163 (true, ""),
1164 (
1165 true,
1166 r#"[{"id":1,"iid":3,"title":"v1.0","description":null,"state":"closed","due_date":null,"created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-01T00:00:00Z"}]"#,
1167 ),
1168 ]);
1169 let provider = GitLabMilestoneProvider::with_runner("owner/repo", runner.clone());
1170
1171 let ms = provider.close(3).await.expect("should close");
1172
1173 assert_eq!(ms.number, 3);
1174 assert_eq!(ms.state, State::Closed);
1175 assert_eq!(
1177 runner.recorded_calls()[0].1,
1178 vec![
1179 "milestone",
1180 "edit",
1181 "3",
1182 "--state",
1183 "close",
1184 "--project",
1185 "owner/repo"
1186 ]
1187 .into_iter()
1188 .map(String::from)
1189 .collect::<Vec<_>>()
1190 );
1191 }
1192
1193 #[tokio::test]
1194 async fn test_should_reopen_milestone_without_output_json_and_refetch() {
1195 let runner = SequencedMockCommandRunner::from_results(&[
1196 (true, ""),
1197 (
1198 true,
1199 r#"[{"id":1,"iid":3,"title":"v1.0","description":null,"state":"active","due_date":null,"created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-01T00:00:00Z"}]"#,
1200 ),
1201 ]);
1202 let provider = GitLabMilestoneProvider::with_runner("owner/repo", runner.clone());
1203
1204 let ms = provider.reopen(3).await.expect("should reopen");
1205
1206 assert_eq!(ms.number, 3);
1207 assert_eq!(ms.state, State::Open);
1208 assert_eq!(
1210 runner.recorded_calls()[0].1,
1211 vec![
1212 "milestone",
1213 "edit",
1214 "3",
1215 "--state",
1216 "activate",
1217 "--project",
1218 "owner/repo"
1219 ]
1220 .into_iter()
1221 .map(String::from)
1222 .collect::<Vec<_>>()
1223 );
1224 }
1225
1226 #[test]
1229 fn test_should_deserialize_milestone_api_response() {
1230 let json = br#"{
1231 "id": 1,
1232 "iid": 1,
1233 "title": "v1.0 Release",
1234 "description": "First stable release",
1235 "state": "active",
1236 "due_date": "2026-06-01",
1237 "created_at": "2026-01-01T00:00:00Z",
1238 "updated_at": "2026-01-01T00:00:00Z"
1239 }"#;
1240
1241 let api: MilestoneApiResponse =
1242 serde_json::from_slice(json).expect("valid MilestoneApiResponse");
1243 let data: MilestoneData = api.into();
1244
1245 assert_eq!(data.number, 1);
1246 assert_eq!(data.title, "v1.0 Release");
1247 assert_eq!(data.description, Some("First stable release".into()));
1248 assert_eq!(data.state, State::Open);
1249 }
1250
1251 #[test]
1252 fn test_should_deserialize_closed_milestone() {
1253 let json = br#"{
1254 "id": 2,
1255 "iid": 2,
1256 "title": "v0.9 Beta",
1257 "description": null,
1258 "state": "closed",
1259 "due_date": null,
1260 "created_at": "2026-01-01T00:00:00Z",
1261 "updated_at": "2026-06-01T00:00:00Z"
1262 }"#;
1263
1264 let api: MilestoneApiResponse =
1265 serde_json::from_slice(json).expect("valid MilestoneApiResponse");
1266 let data: MilestoneData = api.into();
1267 assert_eq!(data.state, State::Closed);
1268 assert!(data.description.is_none());
1269 }
1270
1271 #[test]
1272 fn test_should_deserialize_milestone_list() {
1273 let json = br#"[
1274 {"id": 1, "iid": 1, "title": "v1.0", "description": null, "state": "active", "created_at": "2026-01-01T00:00:00Z", "updated_at": "2026-01-01T00:00:00Z"},
1275 {"id": 2, "iid": 2, "title": "v0.9", "description": "Beta", "state": "closed", "created_at": "2026-01-01T00:00:00Z", "updated_at": "2026-06-01T00:00:00Z"}
1276 ]"#;
1277
1278 let milestones: Vec<MilestoneApiResponse> =
1279 serde_json::from_slice(json).expect("valid MilestoneApiResponse list");
1280 assert_eq!(milestones.len(), 2);
1281 assert_eq!(milestones[0].title, "v1.0");
1282 assert_eq!(milestones[1].title, "v0.9");
1283 }
1284
1285 #[tokio::test]
1288 async fn test_should_produce_complete_argv_for_gitlab_label_list_with_default_limit() {
1289 let runner = MockCommandRunner::success("[]");
1290 let provider = GitLabLabelProvider::with_runner("owner/repo", runner.clone());
1291
1292 let paged = provider.list(None).await.expect("should list");
1293
1294 assert!(paged.items.is_empty());
1295 assert_eq!(runner.recorded_calls()[0].0, "glab");
1296 assert_eq!(
1297 runner.recorded_calls()[0].1,
1298 vec![
1299 "label",
1300 "list",
1301 "--repo",
1302 "owner/repo",
1303 "--output",
1304 "json",
1305 "--per-page",
1306 "100",
1307 "--page",
1308 "1"
1309 ]
1310 .into_iter()
1311 .map(String::from)
1312 .collect::<Vec<_>>()
1313 );
1314 }
1315
1316 #[tokio::test]
1317 async fn test_should_produce_complete_argv_for_gitlab_milestone_list_with_default_limit() {
1318 let runner = MockCommandRunner::success("[]");
1319 let provider = GitLabMilestoneProvider::with_runner("owner/repo", runner.clone());
1320
1321 let paged = provider.list(None).await.expect("should list");
1322
1323 assert!(paged.items.is_empty());
1324 assert_eq!(runner.recorded_calls()[0].0, "glab");
1325 assert_eq!(
1326 runner.recorded_calls()[0].1,
1327 vec![
1328 "milestone",
1329 "list",
1330 "--project",
1331 "owner/repo",
1332 "--output",
1333 "json",
1334 "--per-page",
1335 "100",
1336 "--page",
1337 "1"
1338 ]
1339 .into_iter()
1340 .map(String::from)
1341 .collect::<Vec<_>>()
1342 );
1343 }
1344
1345 #[tokio::test]
1353 async fn test_should_use_bare_repo_as_project_flag_never_full_remote_url() {
1354 let runner = MockCommandRunner::success("[]");
1355 let provider = GitLabMilestoneProvider::with_runner("iproost/iproost-docs", runner.clone());
1356
1357 provider.list(None).await.expect("should list");
1358
1359 let args = &runner.recorded_calls()[0].1;
1360 assert!(
1361 args.windows(2)
1362 .any(|w| w[0] == "--project" && w[1] == "iproost/iproost-docs"),
1363 "--project 必须是裸 namespace/project,实际参数: {args:?}"
1364 );
1365 assert!(
1366 !args.iter().any(|a| a.contains("://") || a.contains('@')),
1367 "--project 绝不能携带完整 remote URL,实际参数: {args:?}"
1368 );
1369 }
1370
1371 #[tokio::test]
1380 async fn test_should_error_when_label_edit_lookup_is_truncated() {
1381 let labels: Vec<String> = (0..1001)
1382 .map(|i| format!(r##"{{"id":{i},"name":"label-{i}","color":"#ffffff"}}"##))
1383 .collect();
1384 let json = format!("[{}]", labels.join(","));
1385 let runner = MockCommandRunner::success(&json);
1386 let provider = GitLabLabelProvider::with_runner("owner/repo", runner);
1387
1388 let args = CreateLabelArgs {
1389 name: "renamed".to_string(),
1390 color: "#ffffff".to_string(),
1391 description: None,
1392 };
1393
1394 let err = provider
1395 .edit("label-999", args)
1396 .await
1397 .expect_err("edit should fail when lookup is truncated");
1398 assert!(err.to_string().contains("truncated"));
1399 }
1400
1401 #[tokio::test]
1404 async fn test_should_report_truncation_not_missing_when_create_readback_is_truncated() {
1405 let labels: Vec<String> = (0..1001)
1406 .map(|i| format!(r##"{{"id":{i},"name":"label-{i}","color":"#ffffff"}}"##))
1407 .collect();
1408 let json = format!("[{}]", labels.join(","));
1409 let runner = MockCommandRunner::success(&json);
1413 let provider = GitLabLabelProvider::with_runner("owner/repo", runner);
1414
1415 let args = CreateLabelArgs {
1416 name: "brand-new-label".to_string(),
1417 color: "#00ff00".to_string(),
1418 description: None,
1419 };
1420
1421 let err = provider.create(args).await.expect_err(
1422 "create should report truncated read-back rather than silently claiming success or \
1423 lying about not-found",
1424 );
1425 let msg = err.to_string();
1426 assert!(
1427 msg.contains("truncated"),
1428 "expected a truncation error, got: {msg}"
1429 );
1430 assert!(
1431 !msg.contains("not found after create"),
1432 "must not report the just-created label as missing when the read-back was merely \
1433 truncated: {msg}"
1434 );
1435 }
1436}